Grapple Component Documentation PDF

Grapple Component Documentation Jonathan Van Damme
DOCUMENTATION
Ver. 1.0.1
Jonathan Van Damme 2020-11-26
1
TABLE OF CONTENTS
1. OVERVIEW OF THE GRAPPLE COMPONENT ...................................................... 6
1.3.1. Concept ............................................................................................................................................................. 7
1.3.2. Functionality ..................................................................................................................................................... 7
1.5.1. Master Grapple Component / Controlled Grapple Object ................................................................................ 8
1.5.2. Participant / Applied Grapple Object ................................................................................................................ 8
1.6.1. Concept ............................................................................................................................................................. 9
1.6.2. How to access ................................................................................................................................................... 9
1.6.3. Links to documentation .................................................................................................................................... 9
2. EFFECTS OF THE GRAPPLE SEQUENCE ........................................................... 10
2.1.1. Global Grapple Data ........................................................................................................................................ 10
2.1.2. Local Grapple Data .......................................................................................................................................... 11
2.1.3. Storage in the Grapple Object ......................................................................................................................... 11
Grapple Component 1
2.2.1. Scene Root ...................................................................................................................................................... 12
2.2.2. Reposition Target ............................................................................................................................................ 12
2.2.3. Scene Collision Actor ....................................................................................................................................... 13
2.2.4. Defining reposition settings using Grapple Data............................................................................................. 15
2.2.5. Reposition Objects .......................................................................................................................................... 16
2.3.1. Animation Data ............................................................................................................................................... 17
2.3.2. Animation Updates ......................................................................................................................................... 18
2.3.3. Blendspaces .................................................................................................................................................... 19
2.3.4. Animation Matching ....................................................................................................................................... 21
2.3.5. Adapting Animation based on Skeleton .......................................................................................................... 25
2.4.1. Movement Settings and Movement Data Objects .......................................................................................... 26
2.4.2. Updating Movement Settings ......................................................................................................................... 27
2.4.3. Revert Values .................................................................................................................................................. 27
2.4.4. Snap to Control Rotation................................................................................................................................. 27
3. CONTROLLING THE GRAPPLE SEQUENCE ........................................................ 32
3.1.1. Initiate Grapple Sequence ............................................................................................................................... 32
▪ Execute Grapple Object .................................................................................................................................. 32
3.1.2. Grapple Attempt ............................................................................................................................................. 32
Grapple Component 2
3.2.1. Terminate Grapple Sequence (Input Function) ............................................................................................... 33
3.2.2. Termination Timer .......................................................................................................................................... 33
3.3.1. Input Functions ............................................................................................................................................... 34
3.3.2. Different phases of the Grapple Attempt (Summary) ..................................................................................... 35
3.3.3. First Phase: Search Candidates ....................................................................................................................... 36
3.3.4. Second Phase: Apply Selection Criteria ........................................................................................................... 37
3.3.5. Third Phase: Initiate Grapple Sequence on Success........................................................................................ 39
4. OTHER FUNCTIONALITY ............................................................................ 40
4.1.1. Concept ........................................................................................................................................................... 40
4.1.2. Adding Queued Events to a Grapple sequence ............................................................................................... 40
4.2.1. concept............................................................................................................................................................ 42
4.2.2. User Command Targets ................................................................................................................................... 42
4.2.3. How to use ...................................................................................................................................................... 43
4.4.1. Snap to Control Rotation from Client.............................................................................................................. 44
4.4.2. Snap to Control Rotation from Server............................................................................................................. 44
4.5.1. Construct and add Character Push Object ...................................................................................................... 45
4.5.2. Using Macros................................................................................................................................................... 45
Grapple Component 3
4.5.3. Character Push Objects ................................................................................................................................... 46
5. INTERNAL MECHANISMS ........................................................................... 48
5.1.1. Replication Mode on Input Events .................................................................................................................. 48
5.1.2. Replication of Grapple Attempts..................................................................................................................... 48
5.2.1. Stored Timestamps ......................................................................................................................................... 49
5.2.2. Relevant functions .......................................................................................................................................... 49
5.2.3. Usage............................................................................................................................................................... 50
5.4.1. Status Object Base Class ................................................................................................................................. 52
5.4.2. Child Classes .................................................................................................................................................... 53
5.5.1. Concept ........................................................................................................................................................... 63
5.5.2. State Tag Manager .......................................................................................................................................... 63
5.5.3. Adding and removing state tags ..................................................................................................................... 64
5.5.1. Evaluating current State Tags and consequences ........................................................................................... 64
5.5.2. Consequences ................................................................................................................................................. 64
5.5.3. Built in State Tags ............................................................................................................................................ 65
5.6.1. Functioning of the Object Converter Blueprint ............................................................................................... 66
5.6.2. Application: converting animation assets based on Skeleton......................................................................... 66
Grapple Component 4
5.8.1. Functions in Category ‘External References’ ................................................................................................... 71
5.8.2. Search Scene Component ............................................................................................................................... 71
5.8.3. Attachment Definitions ................................................................................................................................... 72
5.9.1. Debug Settings ................................................................................................................................................ 73
5.9.2. Debug Messages ............................................................................................................................................. 74
5.9.3. Debug UI.......................................................................................................................................................... 74
6. TUTORIALS ............................................................................................ 75
7. OTHER INFORMATION .............................................................................. 80
Grapple Component 5
1. OVERVIEW OF THE GRAPPLE COMPONENT

Grapple Component
The Grapple Component is an Actor Component which can be added to any Pawn. The Grapple Component’s main
functionality relates to Grapple Sequences. It allows other Blueprints to control the Grapple Sequence, and acts as a proxy
that represents its owning Actor in the Grapple Sequence.
Grapple Sequence
A Grapple Sequence is an event where different characters interact with one another in the game world, for example by
playing a synchronized sequence of animations together.
On a technical level, the Grapple Sequence is a state one or more Grapple Components can enter, where they each become
Participant and assume a specific role.
The Grapple Sequence can apply different effects to each of its Participants. Most notably, Participants will play animations
that are synchronized with one another. More generally, effects can be purely related to player feedback (e.g. synchronized
animation updates; changes to the camera and viewpoint), but they can also affect gameplay (e.g. repositioning; ability to
move; damage). Each Grapple Sequence is defined by a Grapple Object. The content included with the Grapple Component
exists as a toolset for creating these Grapple Sequences.
A few visual examples are shown below and can be tested out in the content examples
Grapple Component 6
Grapple Object
1.3.1. Concept
Grapple Objects are Blueprint Objects that inherit from class GrappleObject. They contain most of the functionality that is
required to define and manage a Grapple Sequence. They are used to define a Grapple Sequence and manage its Participants.
On a technical level, Grapple Objects are added to the Grapple Component as Status Objects.
1.3.2. Functionality
Grapple Objects can be applied and reverted on Grapple Components, causing said Grapple Components to Enter or Exit the
Grapple Sequence respectively. Each Grapple Component that has entered a Grapple Sequence, becomes a Participants and
is assigned a unique Participant Index.
The Grapple Object applies the effects of a Grapple Sequence to other Objects in the game world. In some cases, this is done
through the Grapple Component.
- Effects are applied and reverted whenever Participants enter or exit the Grapple Sequence. This typically occurs at the very
beginning and the very end of the Grapple Sequence. To this end, the Grapple Object contains Grapple Data in the form of a
variable structure. This Grapple Data describes the state Grapple Component and its owning Actor are in during the Grapple
Sequence. 1
- The Grapple Object can be configured to apply effects based on external input, which is received through User Commands.
- The Grapple Component can also execute Queued Events at specifically planned times during the Grapple Sequence.
Getting Started
Most users will be able to get started with the Grapple Component doing the following:
– Consulting the first section (i.e. this section, pages 6 through 9) of the Documentation.
– Following the tutorial on Installation, which can be found at the end of this document.
– Following the tutorial on Implementation, which can be found at the end of this document.
– Following the tutorial on Setting up a Grapple Sequence, which can be found at the end of this document.
– Consulting Object GrappleSequenceTutorial2 for more information and for links to commonly used Blueprint nodes.
The tutorials in this document will link to other sections where necessary.
1 Grapple Data is included in the GrappleObject_StructBased Class, but not in the base GrappleObject base Class. While
GrappleObject_StructBased is probably most suitable for most users, GrappleObject can be used instead if you only want the functionality
of managing Participants an entering/exiting the Grapple Sequence. For both of these Classes, it is possible to add your own functionality
that is applied when entering/exiting the Grapple Sequence.
2This Object can be found in the content examples:
Plugins/GrappleComponent/Content/GrappleComponent/GrappleSequenceTutorial.uasset.
Grapple Object 7
Links between Grapple Components and Grapple Objects

A Grapple Object is dependent on Grapple Components for most of its functionality. The relations between a Grapple Object
and a Grapple Component can be described as follows.
Master
Grapple Component
(Often the same
Grapple Component)
Is Master of Is Controlled by
f Get Controlled Grapple Object f Get Master Grapple Component
Grapple Sequence
Grapple Object
Is Participant of Is Applied to
f Get Applied Grapple Object f Get Participants
f Get Participant Index f Get Participant by Index
Participant 0 Participant 1 Participant 2

Grapple Component Grapple Component Grapple Component
1.5.1. Master Grapple Component / Controlled Grapple Object

A Grapple Sequence is Controlled by a Master Grapple Component. This means that Input Functions used on this Grapple
Component that affect a Grapple Sequence, will take effect on the Controlled Grapple Object. A Grapple Component becomes
the Master of any Grapple Sequence that it Initiates and can only have one controlled Grapple Sequence. If a new one is
Initiated, the previous one is Terminated.
- To access the Master Grapple Component on a Grapple Object, use function Get Master Grapple Component.
- To access the controlled Grapple Object on a Grapple Component, is function Get Controlled Grapple Object. While
it is possible to access the Controlled Grapple Object in this way, it is suggested to use Input Functions instead.
1.5.2. Participant / Applied Grapple Object

A Grapple Sequence can have one or more Participants. These are the Grapple Components that are influenced by the
Grapple Object, and have effects applied to them based on the Grapple Sequence.
- To access all Participants on a Grapple Object, use function Get Participants.
- To access a specific Participant based on its Participant Index, use function Get Participant by Index.
- To access the applied Grapple Object from a Grapple Component, use function Get applied Grapple Object.
- To get the current Participant Index of a Grapple Component on its applied Grapple Object, use function
Get Participant Index.
The process of becoming a Participant in a Grapple Sequence and applying grapple Data is referred to as Entering the
Grapple Sequence. The process of reverting Grapple Data and being removed as a Participant, is referred to as Exiting the
Grapple Sequence.
Links between Grapple Components and Grapple Objects 8

Input Functions
1.6.1. Concept
Input Functions on the Grapple Component are functions that are specifically meant for user input. Most commonly, they
are used to control Grapple Sequences from their Master Grapple Component. They can also be used on any Grapple
Component for other functionality that is not tied to a Grapple Sequence.
Most input functions include parameters that determine their Replication Mode and Timestamp.
1.6.2. How to access

Input functions can be found in the Input Functions category on the Grapple Component. They are easily accessible by right-
clicking in any Blueprint Graph and searching for "Grapple Component Input" (either with a Grapple Component selected as
the target, or with 'context sensitive' disabled).
An overview of the Input Events on the Grapple Component can be found on the Input Events Graph on the Grapple
Component.
1.6.3. Links to documentation

The following Input Functions are explained elsewhere in this document.
• Grapple Attempt (Input) • Process User Command (Input)

• Grapple Attempt Advanced (Input) • Consume Next Queued User Command (Input)
• Grapple Attempt Success (Input) • Update Animation (Input)
• Execute Grapple Object (Input) • Update Animation for Multiple Participants (Input)
• Initiate Grapple Sequence (Input) • Apply Damage from Grapple Component (Input)
• Authorize Termination (Input) • Initiate Grapple Sequence With Current Participants (Input)
• Terminate Grapple Sequence (Input) • Snap to Control Rotation From Client (Input)
• Update Participants (Input) • Snap to Control Rotation From Server (Input)
Input Functions 9
2. EFFECTS OF THE GRAPPLE SEQUENCE

This section is only relevant in case your project is using Grapple Objects that inherit from GrappleObject_StructBased (which is
recommended). These are the Grapple Objects that use Grapple Data. It is also possible to use Grapple Objects without Grapple Data. This
can be done in case you are planning to implement the effects of the Grapple Sequence manually, and only want the functionality that
manages Participants and other links to Grapple Components. In that case, your Grapple Object should inherit from GrappleObject instead
of GrappleObject_StructBased. More information about Grapple Objects can be found in the section on Status Objects.
Grapple Data
In the case if Grapple Objects inheriting from GrappleObject_StructBased, the effects of the Grapple Sequence are
determined by its Grapple Data. This Grapple Data is split up into Global Grapple Data and Local Grapple Data.
2.1.1. Global Grapple Data

The Global Grapple Data contains the settings that will be applied during a Grapple Sequence and are common to all
Participants. As such, they apply to the Grapple Sequence as a whole.
Global Grapple Data are defined using a variable structure of type Struct_GC_GrappleData_Global, which consists of the
following member variables.
Grapple Sequence Name The name used to identify the Grapple Sequence. This member variable is optional.
Local Grapple Data Member variable type: struct_GC_GrappleData_Local

The Grapple Settings that are specific to each individual Participant. These settings are stored in an array
of type struct_GC_GrappleData_Local, where each element corresponds to the Local Grapple Data of the
Participant with that index.
Duration Time after which the Grapple Sequence is Terminated. If a negative value is set, the Grapple Sequence will
not be terminated automatically. In that case, it can be terminated manually using Input Function
Terminate Grapple Sequence (Input) on the Grapple Component.
Scene Root Member variable type: struct_GC_AttachmentDefinition

The primitive component that acts as the Scene Root for the Grapple Sequence. Participants will be
repositioned relative to this component, depending on their Local Reposition Data.
By default, the Scene Root will be the root component of the Owning Actor of Participant 0.
Reposition Data (Global) Member variable type: struct_GC_RepositionData_Global
Defines the Global Reposition Data, i.e. how the Grapple Sequence as a whole should be placed in the
game world.
Ignore Collision between Whether to ignore collision between Participants during the Grapple Sequence. It is also possible to disable
Participants collision entirely for an individual Participant using Movement Settings.
Apply Timestamp to Increase the animation start time to compensate latency between different connections. This is done by
Animation Start Time calling function Apply Timestamp to Animation Data, which makes use of the timestamp stored when
Grapple Data were applied.
Apply Timestamp to Shorten the duration of the Reposition to compensate latency between different connections. This is done
Reposition Duration by calling function Apply Timestamp to Reposition Duration, which makes use of the timestamp stored
when Grapple Data were applied.
Grapple Data 10
2.1.2. Local Grapple Data

Local Grapple Data contains the settings that will be applied during a Grapple Sequence and that are specific to a single
Participant.3 Local Grapple Data is defined using a variable structure of type Struct_GC_GrappleData_Local, which consists of
the following member variables.
Repositioning Member variable type: struct_GC_RepositionSettings.

The way this Participant will be repositioned relative to the Scene Root4 of the Grapple Sequence.
Animation (On Apply) Member variable type: struct_GC_AnimationData.

The animation that is played when the Grapple Data are Applied.
Animation (On Revert) Member variable type: struct_GC_AnimationData.

The animation that is played when the Grapple Data are Reverted.
Animation Matching Member variable type: struct_GC_Animation Matching.

The way bones on this Participant should be retargeted in order to match the location of bones on other
Participants.
See also: Animation Matching (adapting animation depending on skeletal mesh).
Movement Member variable type: struct_GC_MovementSettings.

Settings related to the movement of the Character, which are applied in layers by the Grapple Component.
When the Grapple Settings are reverted, the Movement Settings are usually reset to their Revert Values.
Sequence Camera Member variable type: struct_GC_SequenceCameraData.

Defines the Sequence Camera settings for this Grapple Sequence. By default, the Sequence Camera is not
used.
Update Revert Values Whether to update Revert Values right before applying the Grapple Settings. Revert Values are stored
before Applying based on their current values. Use this If you want a Character to exit the Grapple Sequence the same way
it has entered.
2.1.3. Storage in the Grapple Object

Grapple Data are stored in a Grapple Object. When creating your own Grapple Object, you can set its Grapple Data by
overriding either function GenerateGrappleData or variable Stored_GrappleData.
3 For the settings that are relevant to all Participants, see struct_GC_Data_Global.
4 The Scene Root is defined in the Global Grapple Data using a struct_SceneComponentDefinition.
Grapple Data 11
Repositioning
The Grapple Sequence can influence the world transformation of Components on Pawns, as well as their parent/child
relations to other Components. This is done through repositioning.
Settings related to repositioning in a Grapple Sequence are split up between the Global Grapple Data and the Local Grapple
Data.
2.2.1. Scene Root

The Scene Root is a transformation that acts as the root for the Grapple Sequence. Participants will be repositioned relative
to the transformation of the Scene Root, unless the Grapple Sequence is using a Scene Collision Actor.
The Scene Root is defined in the Global Reposition Data of a Grapple Sequence using a variable structure of type
struct_GC_AttachmentDefinition. While this structure allows you to define an attach socket and a relative transform, these
settings will only have effect if your Grapple Sequence is using a Scene Collision Actor.
By default, the Scene Root will be the root component of the Master Grapple Component’s owner (Participant 0).
2.2.2. Reposition Target

This is the Scene Component that acts as a reference point for repositioning. All repositioned Scene Components will be
transformed relative to this target.
The Reposition Target is automatically set by the Grapple Component. The actual Scene Component assuming the function
of the Reposition Target depends on whether the Grapple Sequence is using a Scene Collision Actor.
– If there is no Scene Collision Actor, the Scene Root will be the Reposition Target.
– If there is a Scene Collision Actor, the scene component 'Scene Root Correction’ of the Scene Collision actor will be
the Reposition Target.
Repositioning 12
2.2.3. Scene Collision Actor
2.2.3.1. Purpose
Optionally, you can provide a blueprint class of

type Scene Collision Actor5 in the Global Grapple
Data.
This will spawn a Scene Collision Actor at the

beginning of the Grapple Sequence. This is an actor
that contains one or more Scene Components that
represent the physical dimensions of the Grapple
Sequence and the Participants. When the Scene
Collision Actor is spawned, it will automatically find
a suitable transform for the Grapple Sequence in
the world.
The Scene Collision Actor is spawned at the

location of the Scene Root, and takes its place as
the Reposition Target. Depending on the Global
Reposition Data, the spawn rotation of the Scene
Collision Actor will be modified so that it is aligned
towards (looks at) a target Scene Component.
Using a Scene Collision Actor ensures that characters do not collide with the world during the Grapple Sequence.
Note that the Scene Collision will take the place of the Scene Root provided above, meaning that all Participants will be
repositioned based on the root of the Scene Collision Actor instead.
2.2.3.2. Scene Root Correction
The Attempt Transform Correction event executes the Scene Collision Actor's main functionality, which is looking for a world
transform that acts as the root of a Grapple Sequence and that leaves enough space for all relevant animations to play out,
without having characters collide with the world.
To this end, the Scene Collision Actor contains one or more Primitive Components. These Primitive Components represent
the Participants in the current Grapple Sequence, as well as the space they need to be able to move within.
The Scene Collision actor will test if any of these Primitive Components are colliding with the world, and if so, will try applying
some 'corrections' to the original transform, in order to make the Grapple Sequence fit into the game world physically.
5 Blueprint'/Game/Shared/GrappleComponent/Blueprint/SceneCollision/SceneCollisionActor.SceneCollisionActor'
Repositioning 13
2.2.3.3. How to use
To make use of a Scene Collision Actor, select a Scene Collision Actor Class when defining the Global Reposition Data of your
Grapple Sequence.
2.2.3.4. Automatic Scene Collision Actor
By default, class SC_Automatic is selected.
This Scene Collision Actor that automatically sets up collision based on the estimated proportions of the Grapple Sequence.
It ensures that the Grapple Sequence is placed in such a way that none of the participating Characters collide with the game
world.
2.2.3.5. Creating your own Scene Collision

Actor
To create your own Scene Collision Actor, follow these steps:
- Create a child Blueprint Class of SceneCollisionActor.

- Add the necessary Primitive Components to represent the
physical dimensions of your Grapple Sequence. These
primitive Components should be parented to the Scene
Root Correction Scene Component.
2.2.3.6. Disabling the Scene Collision Actor
To disable the Scene Collision Actor for a Grapple Sequence, set the
Scene Collision Actor Class to (None) in your Global Reposition Data.
Repositioning 14
2.2.4. Defining reposition settings using Grapple Data
2.2.4.1. Global Reposition Data
The Global Reposition Data defines the transformation of the Grapple Sequence in the game world.
These settings are defined as part of the Global Grapple Data, using a variable structure of type
Struct_CG_RepositionData_Global, which consists of the following member variables.
Scene Collision Actor Class The Class of the Scene Collision Actor, which will manage the repositioning of the Grapple
Sequence as a whole. This can be left blank if you do not wish to use a Scene Collision Actor.
The Scene Collision Actor is spawned at the location of the Scene Root, and takes its place as the
Reposition Target.
By default, class SC_Automatic is selected. This Scene Collision Actor Class will automatically ensure
that the Grapple Sequence is placed in such a way that none of the participating Characters collide
with the game world.
To disable the Scene Collision Actor, change the selected Class to (None).
The other settings in this variable structure only work if a Scene Collision Actor is spawned.
Spawn on Floor Whether to spawn the Scene Collision Actor on the floor instead of the actual position of the Scene
Root.
Use Look Target Optionally, you can define a target Scene Component the scene Component should be aligned
towards. If a relative transform is provided, its rotation will be applied after the look at function.
This member variable determines whether the Scene Collision Actor should be facing a Look Target
when it is spawned. If this is not the case, it will simply assume the world rotation of the Scene
Root.
Look Target Member variable type: struct_GC_AttachmentDefinition
This member variable determines the target the Scene Collision Actor should look at when it is
spawned.
Reposition Scene Collision Actor Whether to adjust the transformation of the Scene Collision Actor on all Clients, after it has found
based on Server Transform its transformation in the server. Enabling this setting ensures that the Grapple Sequence has the
same transformation on all connections.
Reposition Time The blend time when adjusting the transformation of the Scene Collision Actor based on the server.
Repositioning 15
2.2.4.2. Local Reposition Data
Local reposition data defines the relations to the Reposition Target for each Participant.
The Grapple Component will set up all other Participants relative to the Scene Root. This is done by extracting the relevant
Reposition Data for each Participant. This data is found withing the Local Grapple Data for that Participant.
Reposition Settings for a Single Participant are defined using a variable structure of type Struct_GC_RepositionData_Local,
which consists of the following member variables.
Repositioning Enabled Whether to adjust the transformation of the owning Actor of this Participant when applying the Grapple
Settings.
Target Transform The transformation relative to the Scene Root the Actor should assume.
Compensate Character Whether to compensate the height of characters, and calculate the target transformations from floor
Height height instead.
Affect Location Whether the transformation should affect the location of the Participant.
Affect Rotation Whether the transformation should affect the rotation of the Participant.
Blend Time The time during which the Actor is repositioned gradually to its target position.
Blend Curve The curve used when gradually blending between transformations.
Attach when repositioning Whether to attach the Actor to the Scene Root when the process of repositioning has completed.
is complete
Update Target Transform Whether to update the target transformation continually when repositioning is active. If this is disabled,
Continuously the transform is calculated once at the start.
Update Start Transform Whether to update the start transformation continually when repositioning is active. If this is disabled,
Continuously the transform is calculated once at the start.
Attach Scene Component Whether to attach the Actor to the Scene Root when the process of repositioning has completed.
Maintain transform Every Whether to keep applying the relative transformation every tick, until the Reposition Object is removed.
Tick This can be used as an alternative to attaching the Scene Component.
2.2.5. Reposition Objects

On a technical level, repositioning is handled on the Grapple Component using Reposition Objects, which are added to the
Grapple Component as Status Objects.
Repositioning 16
Animation
2.3.1. Animation Data
2.3.1.1. struct_GC_AnimationData
The Grapple Component processes animation instructions when the Update Animation (Input) function is called. These
animation updates are processed in the Linked Anim Instances of the Grapple Component. By default, this is the Linked Anim
Graph that has been placed in the Character’s Animation Blueprint.
These animation instructions are stored in a variable structure called struct_GC_AnimationData.
Animation Type Member variable type Enum_GC_AnimationType
Specifies the type of animation to be used (Anim Sequence, Blendspace or Animation Montage).
Montage – Asset In case Montage is selected under Animation Type, the Animation Montage asset that will be
used is selected here.
AnimSequence – Asset In case Anim Sequence is selected under Animation Type, the Anim Sequence asset that will be
used is selected here.
Blendspace - Asset In case Blendspace is selected under Animation Type, the Blendspace asset that will be used is
selected here.
Blend time The desired blend time between animations.
Start Time The initial position of the animation (in seconds)
Play Rate The play rate of the animation
Loop Whether the animation should loop (start over when it is finished)
Force restart animation Whether to force the animation to restart if the same asset is already playing
Root Motion Enabled Whether to enable root motion during the animation.
Montage - Section - Jump To In case Montage is selected under Animation Type, the section to jump to. If this member
variable is set to ‘none’, the section will remain unchanged.
Montage - Section - Set Next - In case Montage is selected under Animation Type, the function Montage Set Next Section will
Updated Section be called on the Animation Blueprint. This member variable will be passed on to the parameters
of this function. It should contain the name of the section that needs to be changed.
Montage - Section - Set Next - In case Montage is selected under Animation Type, the function Montage Set Next Section will
Desired Section be called on the Animation Blueprint. This member variable will be passed on to the parameters
of this function. It should contain the name of the next section.
Animation 17
2.3.1.2. Enum_GC_AnimationType
This enumeration is used to select the type of animation update we want to process when playing animation from the Grapple
Component. These modes act as ‘channels’ that the Animation Blueprint switches between. On a technical level, animation
is processed differently based on the type of asset being used (Animation Sequence, Animation Montage or Blendspace).
Stop All Stop all animation currently being played by the Grapple Component.
AnimSequence Use an Animation Sequence as the source for the animation. This can be user-friendly because external
animation assets are typically imported into the Engine as Animation Sequences.
Montage Use an Animation Montage as the source for the animation. Montages are the most suitable way to create
a Grapple sequence. They support the use of Montage Slots, Sections, and are more stable in multiplayer
projects They also enable users to combine and selectively play animations that are contained in a single
asset.
Blendspace Use a Blend Space as the source for the animation. Blend Spaces are assets that allow any number of
animations to be blended between based on the values of multiple inputs.
Unchanged Do not change the animation.
2.3.1.3. Generating Animation Data
Animation Data can be generated using a Make struct_GC_AnimationData node. This node contains a lot of pins.
Alternatively, it is possible to use any of the following Macros:
- Macro - Make Animation Data (Montage)

- Macro - Make Animation Data (Montage + Section)
- Macro - Make Animation Data (Anim Sequence)
- Macro - Make Animation Data (Blendspace)
- Macro - Make Animation Data (Stop All)
- Macro - Make Animation Data (Unchanged)
2.3.2. Animation Updates

Animation can be updated through the Grapple Component by
using node Update Animation (Input).
During a Grapple Sequence, it is also possible to update

Animation Data on multiple Participants using node Update
Animation for Multiple Participants (Input).
These events take the input of a struct_GC_AnimationData

variable structure, either in the form of a single variable or an
array.
Animation is also updated at the beginning and at the end of a

Grapple Sequence, if any animation data is provided in the
Local Grapple Data.
Animation 18
2.3.3. Blendspaces
2.3.3.1. General information
The Grapple Component can play Blendspaces on its Animation Blueprint and can generate
coordinates for said Blendspaces. These coordinates can be synchronized between Participants.
2.3.3.2. How to use
To start playing a Blendspace, update animation using node Update Animation (Input) on the
Grapple Component, setting the animation mode to Blendspace.
Blendspaces can be generated by the Grapple Component using function

Generate Blendspace Coordinates. This function has the following parameters:
Coordinate Input The basis from which Blendspace Coordinates are generated. For more information on these modes, see the
Mode section on enumeration Enum_GC_BlendspaceCoordinateInputMode.
Reference Grapple The Grapple Component we should evaluate when generating Blendspace Coordinates.
Component
Send to Animation Whether the generated coordinates should be used immediately by the Animation Blueprint.
Blueprint
Apply to All Whether to send the coordinates over to all other Participants in the Grapple Sequence.
Participants
Coordinates can also be set directly using node Set Pending Blendspace Coordinates. They can be accessed using function Get
Pending Blendspace Coordinates.
2.3.3.3. Generating Blendspace Coordinates during Grapple

Sequence
It is possible that you need a Grapple Sequence to generate Blendspace Coordinates while it
is active. This can be done by going through the following steps.
- In the Class Defaults tab of your Grapple Object, set variable Should Receive Tick
(found under the Status Object – Settings category) to true. This will cause the
Grapple Component to enable ticking, and to send over a tick event to the Grapple
Object, as long as this Grapple Object is active.
- Implement the On Tick Received event in your Grapple Object (this is done by
adding the Event On Tick Received node in the Grapple Object’s Event Graph. This
Event can then be connected to a
Generate Blendspace Coordinates node
that is executed on any Participant.
Animation 19
2.3.3.4. Enum_GC_BlendspaceCoordinateInputMode
The enumeration Enum_GC_BlendspaceCoordinateInputMode describes how Blendspace coordinates are generated by the
Grapple Component.
Coordinates are generated in the graph of function Generate Blendspace Coordinates.
These descriptions often mention a Reference Grapple Component. This is the participant specified under
struct_GC_AnimationData that will be the source used for calculating Blendspace coordinates.
None (set manually) The Grapple Component will not generate coordinates for the Blendspace. The event Update Blendspace
Coordinates can be used to set coordinates manually.
Local Movement Use the direction the Reference Grapple Component is moving in (relative to its world rotation).
Direction
Local Look Direction Use the direction the Reference Grapple Component is looking at (relative to its world rotation).
Controller Movement Use the current movement of the Reference Grapple Component’s controller .
Input
Controller Look Input Use the current look of the Reference Grapple Component’s controller .
Delta Rotation (current - The rotation of the Reference Grapple Component, compared to the rotation during the last update.
last)
Delta Rotation (target - Use the current control rotation on the Reference Grapple Component’s controller, compared to the
current) current rotation of the Reference Grapple Component.
Copy from other Copy the Blendspace coordinates currently used by the Reference Grapple Component.
participant
Speed and Direction X-axis represents the local direction the character is moving in; Y-axis represents the current velocity
relative to Max Walk Speed on the Character Movement Compoent.
2.3.3.5. Linked Anim Instances
The Grapple Component sends animation updates over to all of its Linked Anim Instances. These are Animation Blueprints
that are able to respond to animation related instructions from the Grapple Component. They are added automatically if the
Grapple Component has been implemented following the steps in the Implementation tutorial in the documentation.
Animation 20
2.3.4. Animation Matching

Animation Matching is currently only supported on Characters with Skeletal Meshes using UE4_Mannequin_Skeleton as its skeleton.
2.3.4.1. Typical Use Cases
Some animations will no longer match each other if they are played on skeletal meshes with proportions that are different
from the one used for animating.
The Animation Matching feature attempts to remedy this mismatching by a certain extent. If Animation Matching is enabled,
the Grapple Component will move the location of certain bones in the owner's skeletal mesh to match the position of certain
other bones in the skeletal mesh associated with another Grapple Participant.
Grapple Sequence where all Participants Same Grapple Sequence where one Same Grapple Sequence where one
use the same skeletal mesh the animation participant has a scaled version of the participant has a scaled version of the
assets were created with. original mesh, without Animation original mesh, with Animation Matching
Matching. enabled.
2.3.4.2. Virtual Mesh Actor
Animations can appear mismatched when they are played on skeletal meshes that have different proportions than the
skeletal meshes the animations were originally created in. The Grapple Component can attempt to resolve this mismatching
by moving the relevant bones based the Skeletal Mesh on one Participant, based on the Skeletal Mesh of another Participant.
This is done by internally creating an ‘ideal scenario’, where all relevant animations are being played on their original skeletal
meshes. The Grapple Component then takes the relative bone locations from this ‘ideal scenario’, and applies them to the
non-ideal scenario that is taking place in the Grapple Sequence.
The original skeletal meshes mentioned above are added into the game world using a Virtual Mesh Actor. This Actor has the
following properties:
• It is a child of SkeletalMeshActor.
• Is attached to the character’s Skeletal Mesh Component
• It has a Skeletal Mesh Component (inherited from class SkeletalMeshActor).
Animation 21
o Skeletal Mesh - The Skeletal Mesh Component has its skeletal mesh set to the skeletal mesh that was used
to create the animation.
o Animation - The Skeletal Mesh Component has an Animation Blueprint that copies all animation sent from
the Grapple Component to the main Character Mesh. In consequence, it will always have the ‘raw’ pose of
the Character as intended by the Grapple Component. By default, its Anim Instance class is set to be the
same one that is used as a Linked Anim Graph on the Character’s own Animation Blueprint (in this case
used ‘standalone’ Animation Blueprint instead of a Linked Anim Graph).
o Visibility - The Skeletal Mesh Component has its visibility set to false by default. It is only made visible when
its bone locations are relevant for the Grapple Component.
o Material - Even when the visibility of the Skeletal Mesh Component is set to true, all materials are set to be
an invisible material by default. If debug info is enabled on the Grapple Component, the Skeletal Mesh
Component will use a white x-ray material instead (see image below: al Virtual Meshes are set to the
Mannequin in its original scale, and are assuming the reference pose because the Grapple Component does
not have any animation active).
2.3.4.3. Animation Matching Settings
Bones will be moved based on the Animation Matching Settings provided by the user. These settings can be set in the
following ways:
• Setting the Animation Matching Settings in the Global Grapple Data of your GrappleObject.
• Using Notify Notify_Grapple_UpdateAnimationMatchingSettings inyour animation asset.6
The variable structure struct_GC_AnimationMatching contains a set of instructions on how to adjust the animation on the
Owner Skeletal Mesh Component in order to match the animation on other Participants. Essentially, the member variables
specify the following:
• which bones are being affected;

• based on which bones on the other Participant they should be moved; and
• which other Participant to base these corrections on.
6Blueprint'/Game/GrappleComponent/Blueprint/Notify/LocalFunctionality/Notify_Grapple_UpdateAnimationMatchingSettings.Notify_G
rapple_UpdateAnimationMatchingSettings'.
Animation 22
2.3.4.4. Terminology
Retargeted Bone The bone that is actually being moved by the Grapple Component.
Reference Bone The bone that needs to be at a target position relative to the master bone.
If no Reference Bone is set, the Retargeted Bone will act as the Reference Bone.
The reference bone name can also refer to a socket.
Master Bone The name of the bone/socket that the reference bone should keep a ‘correct position’ to. This ‘correct position’ is
calculated by taking the relative locations of these bones on the respective character’s Virtual Meshes, and then
applying it to the actual Character meshes in the game world.
The master bone name can also refer to a socket.
Target Position The position of the reference bone relative to the master bone.
2.3.4.5. Bones that can be subject to Animation Matching
Hand_r Animation matching on the limbs is done by creating a two bone IK chain. The effector location will be the calculated so that
the reference bone will be in the target position relative to the master bone.
Hand_l
A location for the joint target (ie. the target location of the knee/elbow) will also be calculated based on the pose of the
Foot_r Virtual Mesh.
Foot_l Animation matching on the hands and feet will thus affect multiple bones on the limb (more specifically the thigh, calf and
foot bone for the legs and the upperarm, lowerarm and hand bones on the arms.
Pelvis Animation matching on the pelvis is applied moving the pelvis (=retargeted bone) in such a way that the reference bone will
be at the target position compared to the master bone.
Animation matching on the pelvis will eventually affect all deform bones on the Skeletal Mesh, as they are all below the
pelvis in the bone hierarchy.
The following visual example shows a Grapple Sequence where the pelvis bone on one of the Participants is being moved in
order to better match the animation on the other character.
Grapple Sequence before Grapple sequence as played Grapple Sequence

Animation Matching on Virtual Meshes after Animation Matching
Reference Bone Master Bone Reference Bone
on Virtual Mesh on Character Mesh on Character Mesh
Master Bone (hand_r; participant 0)
(neck_01; participant 1) (neck_01; participant 1)
on Virtual Mesh
(hand_r; participant 0)
Target
position
(calculated
by Grapple
Component)
Retargeted Bone
(pelvis; participant 1)
Animation 23
2.3.4.6. struct_GC_AnimationMatchingData
This struct contains a set of instructions on how to adjust the animation on the Owner Skeletal Mesh Component in order to
match the animation on other Participants (Animation Matching). Essentially, the member variables specify the following:
• which bones are being affected;

• based on which bones on the other Participant they should be moved; and
• which other Participant to base these corrections on.
Enabled Whether Animation Matching should be processed by the Grapple Component.

Get blend value from Whether the Blend Value for the Animation based should
animation curve be based on the value of Animation Curve
AnimationMatching on the animation asset that is
currently playing.
Animation Curves can de added and edited in the
Animation Editor.
For more information on Animation Curves, please refer to
the relevant section in the documentation of the Engine.
https://docs.unrealengine.com/en-
US/Engine/Animation/Persona/AnimCurves/index.html
Blend Time Blend time between the pose with and without Animation Matching.
Reference Participant The Participant to adjust the animation to.
Index
Retarget Pelvis Retarget [none name]: whether to adjust the bone.

Pelvis Master bone [Bone name] master bone: the name of the bone/socket that the retargeted bone should keep
a ‘correct position’ to. This ‘correct position’ is calculated by taking the relative locations of these
Pelvis Reference Bone
bones on the respective character’s Virtual Meshes, and then applying it to the actual Character
Retarget Right Hand meshes in the game world.
Right Hand Master Bone Pelvis reference bone: The pelvis can be repositioned in such a way that another bone maintains
the ‘correct position’ relative to the other Character.
Retarget Left Hand
Left Hand Master Bone
Retarget Right Foot
Right Foot Master Bone
Retarget Left Foot
Left Foot Master Bone
Animation 24
2.3.5. Adapting Animation based on Skeleton

There are two ways to modify the animation in your Grapple Sequence based on the skeleton of your target Participants:
A. The first way is to add a Selection Condition that filters Participants based on the Skeleton used by their Linked
Skeletal Mesh.
B. The second way is to use the same grapple data, but replace references to animation assets to those of their
respective counterparts for other skeletons. Store references for your Grapple animations to all of their counterparts
for different skeletons. This can be done using an Object Converter Blueprint using the following steps:
1. Create a child class of Object Conversion_StoredData.

For the purposes of this tutorial, we will call this child object
AnimationRemappingData7.
2. Open AnimationRemappingData in the editor and

modify its variable Modifier Mappings.
3. This variable contains references to objects and the

object they should be converted to, based on a certain
Modifier Object. In this case, the input obects are the
animation assets, and the command is the skeleton that
should be used.8
An example of this last step is shown on the image to the

left. Montage a_grapple_spinningkick_00_Montage will be
converted to RTG_a_grapple_spinningkick_00_Montage if
the Modifier Object is TutorialTTP_Skeleton.
The Grapple Component only needs this data, and will

make sure animation references converted based on the
right input.
4. On the Grapple Component, set the ‘Object Converter

Blueprint Class’ variable to a reference to class
AnimationRemappingData. This will make sure the Grapple
Component is actually using the data we have stored
previously.
If this is done correctly, the Grapple Component will now replace the specified animation assets with their pre-defined
counterparts on other skeletons.
For a more detailed explanation of this workflow and of the internal functioning of the Object Converter Blueprint, see the
section on the Object Converter Blueprint.
7This object can also be found in the sample content:

Blueprint'/Game/GrappleComponent/SampleContent/Animation/AnimationRemap/AnimationRemappingData.AnimationRemappingDat
a'
8 For a more detailed explanation of this process, please consult the Graph of function ConvertObject on the Object Conversion Blueprint.
Animation 25
Movement
2.4.1. Movement Settings and Movement Data Objects

The Grapple Component can affect the way Characters move in the
game world. This is done using Movement Data Objects9. These
Objects are stored in layers on the Grapple Component, and are
applied from low to high.
The Movement Data Object’s function is to store movement

settings, in the form of a variable structure of type
struct_GC_MovementSettings. The member variables all perform
one of the following functions:
– Stop movement immediately (unlike all other

functionality on the Movement Data Object, this action is
applied immediately).
– Modify a Boolean variable. Users can specify which

operation they want to execute by inputting a variable of
type Enum_ModifyBoolean.
– Modify a variable that is of another type than Boolean.

These member variables always come in pairs. A first
member variable (of type Boolean) acts as a switch and
determines if the variable in question should be changed,
and another member variable contains the new value of
the variable in question.
9Blueprint'/Game/Shared/GrappleComponent/Blueprint/MovementDataObject/MovementDataObject.
MovementDataObject'
Movement 26
2.4.2. Updating Movement Settings

Movement Settings can be updated in the following ways:
– Initiating a Grapple Sequence and providing Movement Data as a part of the Local Grapple Data for a Participant.
– Constructing an Object of Class MovementDataObject and providing it to the Grapple Component using the Update Movement
Data Objects Event. This will add the Movement Data Object to a list on the Grapple Component, and will apply its Movement
Settings in the right order. It is recommended to store the output Object as a Variable, so that you can remove the Object,
reverting its Movement Settings.
– Using the Manage Movement Data Object Macro. This allows users to input Movement Data directly, and apply/revert it to when
necessary. The Object is created within the Macro, and a Reference to the created Object is stored internally as well.
2.4.3. Revert Values

The Revert Values for a Grapple Component (i.e. the default state of all the variables affected by Movement Data Objects)
are stored at layer 0, in an Object stored in variable Movement Data Object - Revert Values. These Revert Values can be
updated in the following ways.
– Function Movement Data - Update Revert Values updates the Revert Values based on input Movement Data.
– Function Movement Data - Update Revert Values Based on Current State updates Revert Values based on the current state of the
actor.
- This function is automatically called on begin play. To disable this behaviour, set variable Update Revert Values on Begin
Play to false.
- This function is called when Entering a Grapple Sequence if member variable Update Revert Values before Applying is
set to true in the Local Grapple Data.
2.4.4. Snap to Control Rotation

The Grapple Component contains Events that can be used to instantly set the rotation of the owning Pawn to be its control
rotation across all Connections.
– Event Snap to Control Rotation From Server (Input) : Takes the Control Rotation for the Controller possessing the Pawn owning
this Grapple Component (based on its value on the Server), and sets it to be the actual Rotation of the Pawn on all Connection.
– Event Snap to Control Rotation From Client (Input) : Takes the Control Rotation for the Controller possessing the Pawn owning
this Grapple Component (based on its value on the Client), and sets it to be the actual Rotation of the Pawn on all Connection.
Movement 27
Sequence Camera
2.5.1.1. Purpose of the Sequence Camera
If a Participant in a Grapple Sequence is controlled by a Player controlled Character, the Grapple Sequence can influence the
viewpoint of this Player. This can make the Grapple Sequence appear more dramatic, impactful and cinematic to human
players.
This is achieved by accessing the Player Camera Manager. 10 The View Target on this Player Camera Manager is then changed
to a Sequence Camera Actor. This is an actor that is created for each Grapple Sequence that requires a Sequence Camera.
The Sequence Camera Actor handles all logic required to animate/modify the Sequence Camera as needed, without affecting
the default View Target of the Player Controller.
2.5.1.2. Sequence Camera Settings
The Grapple Component and the Sequence Camera Actor process instructions from the Sequence Camera Settings.
These instructions are provided in the from of a variable structure of type struct_GC_SequenceCameraData. This variable
structure consists of the following member variables.
General Settings
Sequence Camera Whether the Grapple Component should create and control a Sequence Camera Actor.
Enabled
Sequence Camera The Class of Sequence Camera Actor that will be spawned for this Grapple Sequence. This
Actor Class variable can be changed in case the user wants to create their own version (Child Object) of the
Sequence Camera Actor in order to implement specific behaviour.
Focus Point
The Sequence Camera Actor contains a Scene Component that represents its Focus Point (i.e.. a physical location in the Game World
where the center of the action in a Grapple Sequence should be).
The Focus Point of the Sequence Camera has two purposes:
- It is the location of the Spring Arm Component, which means that if the Camera Component needs to be moved in order to
avoid collision with the world, it will be moved towards the location of the Focus Point.
- If enabled in the Sequence Camera Settings, the Camera Component will be rotated to look at the location Focus Point. On
most Grapple Sequences, this creates the illusion of a handheld camera filming the action.
Focus Point - Relevant Member Variable Type: array of struct_AttachmentDefinition variable structures.
Sockets
The location of this Scene Component is updated for every tick that the Sequence Camera is
active. The location is based on the average location of the Scene Components or Sockets
provided in this Member Variable.
Focus Point - Correction to the Focus Point location, which is added after calculating the average position an
Correction Offset applied in world space.
Camera Transform
10 For more information on the Player Camera Manager and its View Target, please consult the following page of the Engine Documentation:
https://docs.unrealengine.com/en-US/API/Runtime/Engine/Camera/APlayerCameraManager/index.html.
Sequence Camera 28
In most cases, the Sequence Camera’s transformation will be set based on other Scene Components (e.g. a camera bone on the
Skeletal Mesh Component of the Character).
Camera Transform - Whether to set the transformation on the Camera Component of the Sequence Camera Actor
Attach based on other Scene Components.
By default, the Sequence Camera will be attached to the Camera Component on the Character.
This means that Players will perceive the Grapple Sequence as if their viewpoint has not changed,
but the settings (tracking of the focus point, post process settings, field of view, …) have only been
changed on the existing camera.
In reality, the Sequence Camera simply copies the transformation of the original View Target, and
applies its own effects from there. This means that the original View Target (typically the
Character itself, driven by a Camera Component) remains unaffected by the Grapple Sequence.
Camera Transform - Member Variable Type: struct_GC_AttachmentDefinition.

Attachment Definition
Defines the Scene Component the Sequence Camera should be attached to, the relevant Socket
and the relative transform.
Camera Transform - Whether to rotate the Sequence Camera towards the focus point after calculating the previous
Look at Focus Point transformations.
Camera Transform - Whether to set the Control Rotation (on the Controller that is possessing the Character) to the
Affect Control world rotation of the Sequence Camera. This can facilitate seamless blending between the
Rotation default View Target and the Sequence Camera, because View Targets on Character Blueprints
are often Camera Components that are directly affected by the Control Rotation.
Spring Arm Settings
Spring Arm - Probe The Probe Channel11 to be used by the Spring Arm Component on the Sequence Camera Actor.
Channel
Camera Settings
Camera Settings - Whether to affect the field of view of the camera.

Affect Field of View
Camera Settings - The field of view when the Sequence Camera is fully blended in.
Target Field of View
Camera Settings - Post Post Process Settings12 that will be overridden when the Sequence Camera is active.
Process Settings to
Override
Blend Settings
Blend in time The time over which to blend in to the Sequence Camera.
Blend out time The time over which to blend back out of the Sequence Camera.
11For more information on Spring Arm Components and their Variables, please consult the following page of the Engine Documentation:
https://docs.unrealengine.com/en-US/Gameplay/HowTo/UsingCameras/SpringArmComponents/index.html.
12 For more information on Post Process Settings, please consult the following page of the Engine Documentation:
https://docs.unrealengine.com/en-US/Engine/Rendering/PostProcessEffects/index.html.
Sequence Camera 29
Implementable Functions on the Grapple Object

The Grapple Object contains some events that can be implemented to facilitate the creation of your own Grapple
Sequences.
More information on these events can be found in Graph ‘Implementable Events on the Grapple Object’ on Object
GrappleSequenceTutorial. A summary can also be found on the next page.
Implementable Functions on the Grapple Object 30

User Commands
On User Command Please consult the section on User Commands for more information.
Received
Queued Events
On Initialize Queued Please consult the section on Queued Events for more information.
Events
Grapple Attempt
Test Selection Conditions Please consult the section on Selection Criteria for more information.
on Candidate
Apply Selection Criteria Please consult the section on Selection Criteria for more information.
Grapple Sequence (with default functionality)
On Execute Called by the Grapple Component when the Grapple Object is Executed. This method can be used instead
of the 'Grapple Attempt' node on the Grapple Component, in case the user wishes give additional
instructions related to this Grapple Object, rather than just performing a Grapple Attempt.
By default, the 'On Executed' function simply performs a Grapple Attempt based on the Grapple Object.
To execute a Grapple Object on the Grapple Component, use function Execute Grapple Object (Input).
On Grapple Attempt Called by the Grapple Component when it has successfully performed a Grapple Attempt based on this
Success Object.
By default, this function clears all Pending Grapple Attempts and initiates a Grapple Sequence with all
found Participants, in addition to the Master Grapple component which is inserted as participant 0.
On Grapple Attempt Called by the Grapple Component when a Grapple Attempt fails based on this Object.
Failed It should be noted that Clients will only be notified when a Grapple Attempt fails on the server, if variable
Notify if Attempt Fails on Server is set to true.
Grapple Sequence (without default functionality)
On Initiate Called when the Grapple Sequence has been Initiated (i.e. when it has started, regardless of whether any
Participants are present). The time the Grapple Sequence was initiated is used to synchronize animation
and to calculate when the Grapple Sequence should end.
On Terminate (Before) Called right before the Grapple Sequence is terminated (i.e. when it has ended, regardless of whether
any Participants are present). This can be useful if you still need some references that were present
during the Grapple Sequence.
On Terminate (After) Called when the Grapple Sequence has been terminated (i.e. when it has ended, regardess of whether
any Participants are present). When a Grapple Sequence is Terminated, all Participants are ejected.
On Termination Called by the Grapple Component when Termination is authorized. This is done using function Authorize
Authorized Termination (Input).
On Construct Called by the Grapple Component when the Grapple Object is constructed.
A Grapple Object is constructed whenever it is needed by the Grapple Component. This can be the case
when initiating a Grapple Sequence, when performing a Grapple Attempt or when Executing a Grapple
Object. If variable Grapple Object is Persistent is set to true, the Grapple Object is only constructed once.
On Apply Called when any Grapple Component applies the Grapple Data based on this Object.
On Revert Called when any Grapple Component reverts the Grapple Data based on this Object.
On Perform Grapple Called when a Grapple Component executes a Grapple Attempt based on this Object.
Attempt
Implementable Functions on the Grapple Object 31

3. CONTROLLING THE GRAPPLE SEQUENCE

Initiating a Grapple Sequence
When a Grapple Sequence is initiated, it updates its Participants, applies its Effects to all said Participants, it starts executing
Queued Events, and starts receiving User Commands from its Master Grapple Component. This point in time can be seen as
the ‘beginning’ of the actual Grapple Sequence.
A Grapple Sequence is always Initiated from a Grapple Component, which will then become the Master of the Grapple
Sequence. Initiating a Grapple Sequence will terminate the Grapple Sequence that is currently controlled by the Master
Grapple Component.
Grapple Sequences can be initiated in the following ways.
3.1.1. Initiate Grapple Sequence

Function Initiate Grapple Sequence (Input) on the Grapple Component can be used to
make a specific set of Grapple Components enter a Grapple Sequence together.
Initiating a Grapple Sequence directly is useful in cases where you have determined
that a Grapple Sequence will initiate, regardless of circumstances in the game world. It
gives you direct control over a Grapple Sequence. When using this node, only the
Global Grapple Data on the Grapple Object will be taken into account. The Search
Method and the Selection Criteria of the Grapple Object are not relevant in this case.
Is a Grapple Sequence is already active and controlled by the Grapple Component, it is

possible to use Function Initiate Grapple Sequence With Current Participants (Input).
This function will change the Grapple Object and Grapple Data, but keep the current
Participants, effectively transitioning between Grapple Sequences.
▪ Execute Grapple Object

It is also possible to use the Input Function Execute Grapple Object (Input). This event
creates a Grapple Object from the specified class and calls the Execute event on it. It is
a more generic way to activate the ‘main functionality’ of a Grapple Object, similar to
the way one would activate an ability on a Character.
What this function does exactly, depends entirely on the Grapple Object. Unless the On
Executed event is overridden, it simply performs a Grapple Attempt on the relevant
Grapple Component with the newly created Grapple Object as the input.
3.1.2. Grapple Attempt

A grapple attempt is a process where the Grapple Component searches for other Grapple Components that are eligible to
join a Grapple Sequence, filters those Candidates based on certain criteria and then initiates a Grapple Sequence with itself
and these Candidates as the Participants. It will typically serve as the link between a Grapple Sequence and gameplay.
All Grapple Attempts are initiated on the basis of a Grapple Object Class. This can be done using Input Function Grapple
Attempt (Input) or Grapple Attempt Advanced (Input). Please consult the dedicated section on Grapple Attempts for more
information.
Initiating a Grapple Sequence 32

Terminating a Grapple Sequence

When a Grapple Sequence is Terminated, all of its Effects are reverted, its Participants are removed, it stops executing
Queued Events, and stops receiving User Commands from its Master Grapple Component.
A Grapple Sequence is always Terminated from its Master Grapple Component. After termination, this Grapple Component
will no longer be Controlling the Grapple Object.
3.2.1. Terminate Grapple Sequence (Input Function)

A Grapple Sequence can be terminated directly using Input Function Terminate
Grapple Sequence (Input). When called on a Grapple Component, this function will
instantly Terminate the Controlled Grapple Object.
3.2.2. Termination Timer

Grapple Sequences can be Terminated using a timer, which will Terminate the
Grapple Sequence when the input time has elapsed.
3.2.2.1. Set Termination Timer
It is possible to set the Termination Timer directly using Event Set Termination Timer.
3.2.2.2. Grapple Sequence Duration
The Termination Timer is also set automatically if a duration for the Grapple Sequence is provided in the Global Grapple Data.
3.2.2.3. Authorize Termination (Input Function)
By default, a Grapple Sequence will automatically terminate after its Termination Timer has elapsed. However, it is possible
that a Grapple Sequence needs to stay active until there is confirmation from the Grapple Component that it is allowed
terminate.
For example, this could be the case for a Grapple Sequence where the Grapple Object could still receive input from a player
on a remote connection at the very end of the Grapple Sequence. In that case, we do not want the Grapple Sequence to
terminate on other connections, unless the server has definitively decided that the Grapple Sequence is about to end.
Please note that this behaviour is not enabled by default. A Grapple Object that is created from scratch does not wait until
termination is explicitly authorized by the Grapple Component.
To modify this behaviour, set variable Terminate Without Authorization to false. The
Grapple Component will then wait until function Authorize Termination (Input) is
called before actually Terminating the Grapple Sequence.
Please note that authorizing termination only has an effect if the Grapple Sequence is
Terminated using a timer. This functionality can still be overridden by Terminating the
Grapple Sequence instantly using Input Function Terminate Grapple Sequence (Input).
Terminating a Grapple Sequence 33

Grapple Attempt
A grapple attempt is a process where the Grapple Component searches for other Grapple Components that are eligible to
join a Grapple Sequence, filters those Candidates based on certain criteria and then initiates a Grapple Sequence with itself
and these Candidates as the Participants.
It will typically serve as the link between a Grapple Sequence and gameplay.
3.3.1. Input Functions

Typically, a Grapple Attempt is initiated based on input from a Pawn or a Controller, using Input Functions on the Grapple
Component.
3.3.1.1. Grapple Attempt (Input)
The most simple way to execute a Grapple Attempt is to use Input Function
Grapple Attempt (Input). This node takes the input of a Grapple Object Class,
and executes a Grapple Attempt based on it instantly.
Function Grapple Attempt Advanced (Input)

is designed for cases where you want your
character to perform a Grapple Attempt at
specific times (not instantly) or continuously
over a certain duration.
It can also be used to perform multiple

Attempts at the same time. However, only a
single attempt can succeed. The input array
of the advanced Grapple Attampt Node
should be read as: "try index 0 first, and if it
does not succeed, try index 1, then 2, ... " etc.
3.3.1.2. Grapple Attempt Advanced (Input) For an example on how to enter different
Grapple Sequences based on gameplay
circumstances, one could look at the graph
It is also possible to execute a Grapple Attempt using Input Function Grapple
of GrappleCharacter_Green in the sample
Attempt Advanced (Input). This node has additional parameters, which are content. This Character can Initiate three
explained on the next page. different Grapple Sequences:
1. G_Double: a Grapple Sequence

where the character attacks 2 targets.
2. G_StealthTakedown: Typical
takedown move that can only be
performed from behind a target.
3. G_Spinningkick: Fairly 'normal' and

weaker attack with a knockback effect.
Note that these Grapple Objects are
arranged from 'exceptional' to 'normal'.
If conditions are fulfilled for one element of

the array, the next elements will become
irrelevant.
Grapple Attempt 34
Input Function Grapple Attempt Advanced (Input) has the following Parameters.
All grapple attempts are performed based on a Grapple Object. This class of objects has several functions that are called by the
Grapple Component and that generate the data necessary for a Grapple Sequence.
Grapple Object Class The Grapple Object class to be used for the Grapple.
This parameter takes the input of an array instead of a single variable. All of these attempts will be
performed sequentially.
The Grapple Component constructs Grapple Objects for each of the classes specified above, and adds them to the Pending Grapple
Attempts. These Attempts are then executed at specific times based on the parameters below.
Attempt Instantly Execute pending Grapple Attempts immediately (at the time node is used). These parameters all
concern the timing of
Attempt Every Tick Execute pending Grapple Attempts every tick, until Event the Grapple Sequence.
Stop Executing Pending Grapple Attempts Every Tick is called. Modify They can be combined if
variable Grapple Attempt Cooldown when performing Every Tick to set a necessary.
cooldown for this functionality.
Attempt When Notified Execute pending Grapple Attempts when function

Execute Pending Grapple Attempts is called.
Some other data is also included that does not directly affect the Grapple Attempt.
Update Animation This parameter can be used to immediately do an Animation Update. If the Grapple Attempt was
successful, this animation will usually be interrupted by the animation of the Grapple Sequence. If the
Grapple Attempt fails, the animation will keep playing.
By default, no animation is played.
Forbidden State Tags The Grapple Component will ignore the input from this node if any of the State Tags provided here is
active.
3.3.2. Different phases of the Grapple Attempt (Summary)

During a Grapple Attempt, the following actions are performed:
- Search Candidates: Find Candidates to join the Grapple Sequence.

- Apply Selection Criteria: Find out which of these Candidates can join the Grapple Sequence.
- On success, initiate Grapple Sequence: Start a new Grapple Sequence with the remaining Candidates.
The Blueprint logic used for Grapple Attempts can be consulted in the Input Functions Graph of the Grapple Component.
Grapple Attempt 35
3.3.3. First Phase: Search Candidates
3.3.3.1. Candidates
In the context of a Grapple Attempt, Candidates are Grapple Components that are considered to become a Participant of the
Grapple Sequence that is initiated when the Grapple Attempt is successful. They can be seen as ‘potential Participants’.
3.3.3.2. Search Candidates Function on the Grapple

By default, function Search Candidates will
Object search for Candidates using any Primitive
Component on the Linked Pawn that has
During the first phase, the Grapple Component will call function Search one of the following tags :
Candidates on the Grapple Object.
- the name of the Grapple Sequence (as
This function can be overridden if you wish to build your own logic that finds defined in the Global Grapple Data); or
Grapple Components that are Candidates to join the Grapple Sequence, which
- “defaultgrapplehitbox“
will be the case for most projects.
Using this Primitive Component, it will find
all overlapping Pawns that have a Grapple
Component.
3.3.3.3. Helper functions on the Grapple Component
When overriding function Search Candidates on the Grapple Object, it should be noted that the Grapple Component itself
has a few functions built in that might assist users when searching for Candidates:
– Function Search Candidates - Scene Component Overlap
– Function Search Candidates - Line Trace from Camera
– Function Search Candidates - Use Pending Candidates
- Rather than searching for Actors in the game world, this function accesses variable Pending Candidates on
the Grapple Component. This variable is publicly accessible by other Blueprints, and can be used to set the
Candidates that will be used before the attempt is executed.
These functions on the Grapple Component can be implemented as needed in function Search Candidates on the Grapple
Object.
Grapple Attempt 36
3.3.4. Second Phase: Apply Selection Criteria

If any Candidates are found during the first phase (Search Candidates), the Grapple Component will examine if a Grapple
Sequence should be initiated, which Candidates should become Participants (if any) and in which Participant Index each
Candidate should occupy.
3.3.4.1. Selection process
This selection process is handled as a whole by function Apply Selection Criteria on the Grapple Object.
This function can be overridden if you wish to build your own logic that finds Grapple Components that are Candidates to join the
Grapple Sequence. Alternatively, it is possible to override any of the other functions on the Grapple Object that are called as a part
of it. Different aspects of the Selection Process are as follows.
Function Test Selection Conditions on Group tests Grapple Conditions on all Candidates (by executing function Test Selection
Conditions on Candidate for each of them), and removes Candidates that do not fit the conditions.
It is recommended not to override this function, but to override function Test Selection Conditions on Candidate instead.
Function Test Selection Conditions on Candidate checks if a single Candidate is eligible to become a Participant in the
Grapple Sequence. It returns true if this is the case. By default, it only checks if the Candidate is in a state where it can
enter a Grapple Sequence.
This function should be overridden in case you want to specify the conditions that a Candidate must meet in
order to become a Participant (e.g. attacker is standing behind the target; target is incapacitated; target is
below 50 % health; …). It is recommended to keep a call to the parent function included when overriding this
function, because the parent function checks if the Grapple Component is able to enter a Grapple Sequence
in its current state.
Function Arrange Candidates is then executed on the remaining group of Candidates. This function will put the Candidates in the
right order.
This function can be overridden in case you wish to build your own function that changes the order of Candidates.
However, it provides three basic ways to arrange candidates (Match actors with target transformsations; Closest actor;
Input Order), which can be selected using an input parameter of type Enum_GC_CandidateArrangement.
By default, function Arrange Candidates executes function Arrange Candidates Automatically. This function attempts
to occupy all slots in the Grapple Sequence by Candidate that intuitively makes the most sense to human players. The
function considers all Candidates and all target transformations that are available for each Participant (based on the
Local Reposition Data, which is in turn defined in the Local Grapple Data). It then looks for the optimal way to allocate
each available Participant Index to a Candidate, so that the Candidates have to travel as little distance as possible.
Function Enforce Maximal amount of Candidates is then executed on the remaining Candidates. This function removes the
Candidates at the end of the array that exceed the maximal amount of Participants.
This function can be overridden in case you wish to determine manually which Candidates are eliminated if there are
too many.
The remaining Candidates are used in output parameter Remaining Candidates.
The output parameter Selection Criteria fulfilled is set to true if the following conditions are fulfilled:
enough Candidates were found (which is verified using function Enforce Minimal amount of Candidates); and
the Grapple Component that initiated the Grapple Sequence is in a state where it can enter a Grapple Sequence (which
is verified using function Test Condition – Can Enter Grapple Sequence on the Grapple Component itself.
Grapple Attempt 37
3.3.4.2. Practical recommendations when overriding aspects of the selection process
The selection process of function Apply Selection Criteria consists of various steps. Depending on the needs of your project,
it is possible that only a few of these steps need to be overridden, without changing the general structure of the selection
process. In that case, it is recommended not to override function Apply Selection Criteria itself, but rather one of the other
functions (e.g. Test Selection Conditions on Candidate or Arrange Candidates).
It is also possible to override function Apply Selection Criteria which will re-define the selection process as a whole. If you
wish to override this function, but start out from a copy of the original Graph of the function (which includes all default
functionality), it is recommended to proceed as follows.
Navigate to the My Blueprint

tab and override function
Apply Selection Criteria.
The Graph of your new function will now open.

Right-click the input node and add a call to the
parent function (in case this node is not present
yet).
Connect all pins on the parent function node to their counterparts in

the current Graph. Right-click the parent function node and expand it.
A copy of the parent function will then be available in the current Graph
(you might need to connect the execution pins manually).
3.3.4.3. Initial versus Final Phase
Depending on the needs of your project, these tasks can be split up amongst the server and the owning connection. This is
why some of these functions have an input parameter called Phase (of type enum_GC_SelectionCriteriaTestPhase, which can be
aither initial or final) This parameter determines if we are applying selection criteria in an initial phase (which is done on the
owning client before sending the result over to the server) or in a final phase (which takes place on the server).
By default, all operations are executed during both phases (testing selection conditions for each Candidate, checking if there
are enough candidates). Other operations (arranging candidates and removing excessive candidates) are only executed
during the final phase on the server.
Grapple Attempt 38
3.3.5. Third Phase: Initiate Grapple Sequence on Success

Once the Grapple component has established the list of eligible Candidates, the Grapple Attempt will enter its third and final
phase.
If the Grapple Attempt was successful, the Grapple Component will call event On Grapple Attempt Success on the Grapple
Object. By default, this will simply cause the Grapple Object to Initiate a Grapple Sequence through the Grapple Component
using input function Initiate Grapple Sequence (Input).
Update Participants
3.4.1.1. Event Update Participants
Participants can also be updated directly using Input Function

Update Participants (Input) on the Grapple Component. This Event
allows users to add or remove Participants based on its input
parameters.
Update Participants 39
4. OTHER FUNCTIONALITY
Queued Events
4.1.1. Concept
Queued Events occur at a fixed time during the Grapple Sequence, and
typically have an influence on gameplay (for example a character being
pushed away or taking damage).
The GrappleSequenceTutorial Object contains a Graph with an

example layout for Queued Events.
Queued Event nodes are typically connected to the event 'OnApplied'

on a Grapple Object. This event is called whenever Grapple Data is
being applied on a Grapple Component, based on this Grapple Object.
Animation also starts to play at this time, making it a good referenc
epoint for Queued Events.
4.1.2. Adding Queued Events to a Grapple sequence

Implement Event On Initialize Queued Events in a Graph on a Grapple Object.
This Event is Called when the Grapple Sequence is initiated. It can be used to hook
up Queued Events.
It should be noted that Events can be Queued at any time. This means that the
construction we are building here could also be connected to other Events, e.g.
Event On User Command Received or Event on Apply.
To add a Queued Event, use function Add Queued Event. On this node you can
specify a delay (input parameter time), as well as the point in time from which
this delay should be calculated (input parameter timeframe). You should also
provide a name for the Queued Event (input parameter Function Name).
The timeframe is specified using an enumeration of type
enum_GC_GrappleSequenceTimeframe. To calculate the final delay, the Grapple
Object uses Timestamps.
If input parameter Is Cancelable is set to true, the Queued Event will be cancelled
when the Grapple Sequence is Terminated or when function Cancel Queued
Events is called.
Queued Events 40
Proceed by adding an event or function to the Grapple Object that has the same
name that has been provided to function Add Queued Event.
Optionally, you can add a "Macro - Queued Event Utility" node from Macro
Library "ML_GrappleMacros_GrappleObject". It contains pins with references to
the Master Grapple Component (which by default is always the one linked to the
Grapple Object), and also allows to re-route the event to different Participants.
By default, this Node also makes sure that no input goes through when the
Grapple is no longer active.
The Queued Event Utility node should then be connected to the actual logic you
want to add into the Grapple Sequence. These Events can be called on the
Grapple Component or on any Blueprint in your project.
Your final setup should look something like this (this Graph can be found on Object GrappleSequenceTutorial).
Input Functions on the Grapple Component will often be added as

Queued Events. For a list of these input functions, consult the section
on Input Functions in this documentation or the Event Graph called
Graph - Input Functions on the Grapple Component.
Queued Events 41
User Commands
4.2.1. concept
User Commands are instructions that are handled by the Grapple Component. They are usually sent over by other Objects,
like Character Blueprints or Controllers. The Grapple Component sends these User Commands over to its User Command
Targets (by default, the Applied Grapple Object and the Controlled Grapple Object).
4.2.2. User Command Targets

In User Commands can be sent over to any Blueprint Object. Each Grapple Component contains a list of User Command
Targets. This list can be accessed using function Get User Command Targets. User Command Targets can be added or
removed using functions
Add User Command Target and Remove User Command Target.
The Objects added as User Command Targets can add functionality on their end by implementing Blueprint Interface
BI_GrappleComponentInterface, more specifically its Event Process Incoming User Command.
Grapple Objects implement this Interface natively. They are automatically added as User Command Targets on all Grapple
Components that are Participants, as well as their Master Grapple Component. This can be disabled by modifying the
following variables on the Grapple Object:
- Auto Receive User Commands from Participants during Grapple Sequence ; and
- Auto Receive User Commands from Master during Grapple Sequence.
User Commands 42
4.2.3. How to use
4.2.3.1. Processing User Commands on the Grapple Component
User Commands are sent to the Grapple Component using Input Function Process User Command (Input).
The User Command will be processed according to the selected input mode. The input mode is selected using an variable of
type enum_GC_UserCommandInputMode. This enumeration describes the way in which a User Command should be
processed.
Execute The User Command is Executed (i.e. sent over to all User Command Targets) immediately.
Queue Add the User Command to a Queue, where each User Command is executed in whenever Input Function
Consume Next Queued User Command (Input) is called.
Store Provisionally Store the User Command on the Grapple Component. If a Grapple Sequence is initiated, all stored User
Commands that were input after the input that lead to the successful Attempt will be queued (meaning that
they will only be executed when Input Function Consume Next Queued User Command (Input) is called.
This input mode is designed for specific situations in network environments.
When performing a Grapple Attempt in a multiplayer project, there is usually a small delay between the input
on the Client and the moment the Grapple Sequence is initiated. This is the case because all Grapple Attempts
need to be verified on the server before the Grapple Sequence is initiated. However, it is possible that you still
need the inputs during this small delay to be registered, in case they need to be used in the Grapple Sequence
(for example, in a situation where a character does a variation of an attack when the input is pressed twice).
4.2.3.2. Implementation on Grapple Objects
User Commands can be accessed on Grapple Objects by implementing Event on User Command Received. Incoming User
Commands can be filtered by using the Filter User Command macro.
User Commands 43
Apply Damage
Damage can be dealt through the Grapple Component. This can de done using function Apply Damage from Grapple
Component, which should be used on the Grapple Component that is inflicting the damage.
It is suggested to use a Queued Event to apply damage, as illustrated below.
Snap to Control Rotation
4.4.1. Snap to Control Rotation from Client

Input Function Snap to Control Rotation From Client (Input) takes the
Control Rotation for the Controller possessing the Pawn owning this
Grapple Component (based on its value on the Client), and sets it to be
the actual Rotation of the Pawn on all Connection.
4.4.2. Snap to Control Rotation from Server

Input Function Snap to Control Rotation From Server (Input) takes the
Control Rotation for the Controller possessing the Pawn owning this
Grapple Component (based on its value on the Server), and sets it to be
the actual Rotation of the Pawn on all Connection. This Event can be
triggered by applying Movement Settings.
Apply Damage 44
Push Character
The Grapple Component can push characters around in the game world by launching them, applying an impulse or directly
affecting their movement input. This can be done in the following ways.
4.5.1. Construct and add Character Push Object

A Character Push can be initiated by constructing an
object of type CharacterPushObect_DirectionBased
(or alternatively for a more advanced setup,
CharacterPushObject), and adding it to the Grapple
Component of the Pushed Character using function
Add / Remove Status Object.
For more information on Status Objects and how to

manage them, please consult the section on Status
Objects.
4.5.2. Using Macros

Alternatively, it is possible to initiate a Character Push
using Macro node Push Character (Using Grapple
Component). To instantly launch a character, use
Macro node Launch Character (Using Grapple
Component).
The input parameters on these nodes correspond to the names of variables on Object Classes CharacterPushObject and
CharacterPushObject_DirectionBased. For more information, please consult the section on Character Push Objects, which
contains an explanation of these variables (marked as settings).
Push Character 45
4.5.3. Character Push Objects
4.5.3.1. Character Push Object
Class CharacterPushObject
Parent FadeObject
Description Character Push Objects are used to affect the movement of characters in the game world, typically in cases
where this movement is not directly controlled by the player.
Implemented functions from StatusObject
On Added - Remove Self From Previous Managing Object

- Add Hit Tester to Affected Object
On Removed - Remove Hit Tester from Affected Object
Get Managing Object The Managing Object is always the Grapple Component on the Pushed Actor.
Implemented functions from FadeObject

The functionality from Fade Object is used as a basis to push Characters around.
Apply Fade Output Generate Push Velocity and Apply Push Velocity based on the Push Method (On Tick)
Value
On Fade Started - Remove all other Character Push Objects and Reposition Objects on the Affected Object
- Revert Movement Data from Grapple Sequence
- Add State Tag ST_CharacterPushActive
- Update Movement Data on the Affected Object
- Update Animation (on Start)
- Apply Push Velocity based on the selected Push Method (on Start)
On Fade Ended - Remove State Tag ST_CharacterPushActive

- Revert Movement Data from Push
- Update Animation (on Start)
- Apply Push Velocity based on the selected Push Method (on End)
Implementable functions
Generate Push Velocity Calculates the target velocity of the Push, based on gameplay circumstances.
Settings
Pushed Actor The actor that will be pushed by this Object.
Input Speed The base speed (velocity) of the Push. Will be multiplied by the Fade Output value.
Affect Z Velocity Whether the character should also be pushed in the Z direction. If not, only X and Y are influenced.
Push Method (On Start) The Application Method used to push the character. Different options are:
-Add Movement Input (using Character Movement Component)
Push Method (On Tick)
-Add Impulse
Push Method (On End) -Launch Character
-Do Nothing
Movement Settings The Movement Data that should be applied during the Push.
during Push
Animation (on Start) The animation that should be played when the Push starts.
Animation (on End) The animation that should be played when the Push ends.
Push Character 46
Incompatible Status Status objects of these Classes will be removed once this Object is added.
Object Classes
Hit Tester The Hit Tester used by this Character Push Object. When the Hit Tester detects a relevant hit, the Push will
be interrupted.
4.5.3.2. Direction Based Character Push Object
Class CharacterPushObject_DirectionBased
Parent CharacterPushObject
Description Direction Based Character Push Objects generate their Push Velocity based on an input direction and a
reference scene component.
Functions implemented from CharacterPushObject
Generate Push Velocity Generates Push Velocity by taking the base direction (provided in variable Push Velocity – Direction) and
rotating it by the rotation of the Scene Component provided using variable Push Velocity - Reference Scene
Component. This vector is then normalized and multiplied by the input speed and the current fade output
value.
Settings
Push Velocity - The direction we should push the Character in. the vector length does not matter, because the input vector
Direction will be normalized and multiplied by the fade output value and the input speed.
Push Velocity - The input direction will be rotated by the rotation of this Scene Component. This variable can be seen as the
Reference Scene space in which we should calculate the input direction. If this is left blank, the input direction will be
Component interpreted in world space.
4.5.3.3. Application Method
The way a Character is Pushed can be set using an enumeration of type enum_GC_CharacterPushApplicationMethod.
Add Movement Input Add Movement Input to the Pushed Actor. This is optimal for multiplayer, but only possible
(Character) for Character Blueprints.
Add Impulse (Character Use the Add Impulse function on the Character Movement Component of the Pushed Actor.
Movement Component)
Launch Character Use the Launch Character function on the Pushed Actor. Only possible for Character
Blueprints.
Do nothing Does not perform any action.
Push Character 47
5. INTERNAL MECHANISMS
Replication
5.1.1. Replication Mode on Input Events

Some Input Functions on the Grapple Component support Networking, making them suitable for multiplayer projects. To this
end, they often contain an input parameter named Replication Mode, which defines in which way an event should be
replicated to other connections, using an enumeration of type enum_GS_ReplicationMode. This enumeration contains the
following enumerators.
Do not replicate Execute the event on the current connection. It will not be sent over to the server or to clients.
Execute on all (if Server) If we are on the server, send the event over to all clients. If we are on a client, ignore the event.
Execute on All (if Owning If we are on the server, send the event over to all clients. If we are on a client, send the event to
Connection) the server, which will in turn send it to all clients.
Execute on server (if Owning If we are on the client, execute the event on the server.
Client)
5.1.2. Replication of Grapple Attempts

Grapple Attempts should be executed on the Owning Client. If the Grapple Criteria are met on the Client, they will be verified
on the server. This is why some of the functions related to Selection Criteria have an input parameter that specifies whether
they are executed in an Initial or a Final Phase.
If the criteria are also successful on the Server, it will have the Grapple Attempt Success (Input) Event executed on all other
connections.
Replication 48
Timestamps
5.2.1. Stored Timestamps

The Grapple Component and the Grapple Object store the exact moment at which some events occur in timestamp variables.
The following Timestamps are stored:
On Grapple Component
These timestamps are mainly meant for internal use on the Grapple Component
Timestamp - Grapple Settings Applied/Reverted The time function Apply/ Revert - All Pending Grapple Data was used.
Timestamp - Last Grapple Attempt Tick The last time a Grapple Attempt was performed in ‘every tick’ mode.
On Grapple Object
These timestamps can be accessed using function Get Timestamp on the Grapple Object.
Timestamp - Last User Command Received Refers to the time the last User Command was received by this Grapple Object.
Timestamp - Grapple Sequence Initiated Refers to the time the Grapple Sequence based on this Object was initiated.
Timestamp - Custom A custom timestamp that can be set using function Set Custom Timestamp based
on Current Time or by directly accessing variable Timestamp – Custom.
Timestamp - Last Participant Update Refers to the time function Update Participants was last used on this Grapple
Object.
5.2.2. Relevant functions
On Grapple component
Calculate Delay Since Calculates the delay since the input time. Returns 0 if an invalid timestamp (i.e. one with a value smaller
than 0) negative value is provided.
Make Timestamp from Get the current server world time from the Game State
Current Time
Generate Timestamp if Invalid Generates a timestamp if the input timestamp is not valid (ie. smaller than 0).
On Grapple Object
Get Timestamp Gets the stored time based on a timestamp slot.
Get Delay Since Timestamp Refers to the time function Update Participants was last used on this Grapple Object.
Set Custom Timestamp based Set Timestamp – Custom based on the current time.
on Current Time
Timestamps 49
5.2.3. Usage
5.2.3.1. Replication on Input Functions
Many Input Functions provide the option to specify a timestamp. This can be useful in case the Input Function is replicated.
If an invalid timestamp (i.e. a negative value) is provided, the Grapple Component will generate a timestamp on the server
and replicate it to all Clients. This is the optimal way to manage timestamps, so it is recommended to leave the timestamp
parameter on input functions at its default value (-1).
5.2.3.2. Corrections when applying Grapple Data
When applying Grapple Data, the Grapple Component can:
- Increase the animation start time to compensate latency between different connections. This is done by calling
function Apply Timestamp to Animation Data, which makes use of the timestamp stored when Grapple Data were
applied.
- Shorten the duration of the Reposition to compensate latency between different connections. This is done by calling
function Apply Timestamp to Reposition Duration, which makes use of the timestamp stored when Grapple Data
were applied.
Both of this methods for compensating latency can be disabled in the Global Grapple Data.
5.2.3.3. Corrections to Queued Event delays
Users can make use of timestamps when adding Queued Events. When using function Add Queued Event, set input parameter
Timeframe to the timestamp you wish to use. To use a custom timestamp, call function Set Custom Timestamp based on Current
Time or modify variable Timestamp – Custom before adding the Queued Event.
If you want to add a Queued Event without any compensation based on timestamps, set the Timeframe to ‘current time’.
Timestamps 50
Custom Blueprint Objects used by the Grapple Component (Overview)

This page contains an overview of the custom Object Classes used by the Grapple Component. They are elaborated on further in this document.
Scene Collision Actor

Actor
Sequence Camera Actor
Actor Component Grapple Component
Grapple Object
Grapple Object
(Struct Based)
Reposition Object
Gradual Transformation Object

Status Object
Look Target Object
Object
Fade Object
Character Push Object
Character Push Object
(Direction Based)
Movement Data Object

Hit Tester Bounce Object
Object Converter
Object Converter
(Stored Data)
State Tag
State Tag Manager
Custom Blueprint Objects used by the Grapple Component (Overview) 51

Status Objects
5.4.1. Status Object Base Class
5.4.1.1. Concept
Status Objects are Objects that can be added to and removed from an Affected Object. They can apply effects to this Affected
Object. They are managed by a Managing Object.
5.4.1.2. Affected Object(s)
An Affected Objects is an Object the Status Object is added to or Removed from. Every Affected Object contains a list of
Status Objects applied to is. Every Object can be an Affected Object, provided that it implements Blueprint Interface
BI_StatusObjectInterface.
- To add or remove a Status Object, use Interface Call Add / Remove Status Object on the Affected Object.
- To access all Status Objects added to an Affected Object, use Interface Call Get added Status Objects.
All of the functions from Blueprint Interface BI_StatusObjectInterface should be implemented on the Managing Object. The
Grapple Component is meant to be the Managing Object for all Status Objects that come with the project, and implements
all of these functions by default.
5.4.1.3. Managing Object
Every Status Object stores one reference to a Managing Object. This is Object does not necessarily need to be an Affected
Object of the Status Object. By default, the Managing Object is the Outer Object of the Status Object. This can be Changed
by overriding function Get Managing Object on the Status Object. Every Object can be a Managing Object, provided that it
implements Blueprint Interface BI_StatusObjectInterface.
- Status Objects can use Interface Call Enable / Disable Tick Updates for Status Object on the Managing Object. The Managing
Object should then call Function On Tick on that Status Object every tick.
5.4.1.4. Implementable Functions
The Status Object contains the following functions that can be overridden.
Implementable Functions
On Added Called when the Status Object is added to any Affected Object.
On Removed Called when the Status Object is removed from any Affected Object.
On Tick Can be called by the Managing Object every Tick. To enable or disable, use function Enable / Disable Tick Updates on
the Status Object.
Get Managing This function is used whenever the Object needs to access its Managing Object. By default, it returns the Outer Object
Object of the Status Object.
Status Objects 52
5.4.2. Child Classes
5.4.2.1. Grapple Object
Class GrappleObject
Parent StatusObject
Description Grapple Objects are used to manage Grapple Sequences on Grapple Components.
Implemented functions from Status Object
Usage Overridden functionality
On Added The Grapple Object adds itself to a Grapple - Start receiving User Commands from Participant.
Component whenever this Grapple Component - Call Function Apply Grapple Sequence Effects
becomes a Participant on the Grapple Object.
On Removed The Grapple Object removes itself from a Grapple - Stop receiving User Commands from Participant.
Component whenever this Grapple Component is - Call Function Revert Grapple Sequence Effects
no longer a Participant on the Grapple Object.
On Tick Ticking will only be enabled if variable Enable Tick This function is implementable and should be used for
(found in category Grapple Object – Settings) is set logic that needs to run continuously. For example, it
to true. In that case, the Grapple Object will start could be used to generate Blendspace Coordinates
receiving tick updates from its Managing Object (i.e. during a Grapple Sequence.
Master Grapple Component) when the Grapple
Sequence is initiated. It will stop receiving tick
updates when the Grapple Sequence is Terminated.
Get Managing Object This function is used whenever the Object needs to For Grapple Objects, the Managing Object is always the
access its Managing Object. By default, it returns Master Grapple Component.
the Outer Object of the Status Object.
Implementable functions (Base Functionality)
Apply Grapple Applies the influence from the Grapple Sequence. When overriding this function, it is recommended to keep a
Sequence Effects call to the parent function, as it provides some base functionality.
Revert Grapple Reverts the influence from the Grapple Sequence. When overriding this function, it is recommended to keep
Sequence Effects a call to the parent function, as it provides some base functionality.
Implementable functions (Grapple Sequence Creation)
On Construct; On Execute; On Initiate; On Terminate These functions are called automatically by the Grapple Component or the
(Before); On Terminate (After); On Termination Grapple Object, and can be overridden to create Grapple Sequences. They are
Authorized; On Apply; On Revert; On Initialize easily accessible by right-clicking in any Graph and searching for "Grapple
Queued Events; On User Command Received Object Implementation" (either with a Grapple Object selected as the target,
or with 'context sensitive' disabled). They are laid out in detail on the Graph of
Object GrappleSequenceTutorial.
Settings
Grapple Object Is Persistent Grapple Objects stay stored on the Grapple Component that constructed them and can be re-used
Persistent in different phases of gameplay (eg. Executing the Grapple Object, performing a Grapple Attempt and initiating
the Grapple Sequence).
Remove Persistent Whether to remove the Persistent version of this Grapple Object when the Grapple Sequence is Terminated,
Object on Terminate so that it is reconstructed the next time it is used.
Cancel all Queued Whether to Cancel all Queued Events when the Grapple Sequence is Terminated
Events on Terminate
Status Objects 53
Terminate Grapple If set to false, the Grapple Sequence can only be Terminated after function Authorize Termination (input) is
Sequence without used on the Grapple Component.
Authorisation
Insert self as Master If a Grapple Attempt based on this Object is successful, add the Master Grapple Component to the list of
on Successful Grapple Participants before initiating initiating the Grapple Sequence.
Attempt
Auto Receive User User Commands processed by the Grapple Component are sent over (using a Blueprint Interface) to all Objects
Commands from that are stored as 'User Command Targets' for that Grapple Component. Any Grapple Sequence that is applied
Participants during to the Grapple Component wil automatically be added and removed when it is applied and reverted
Grapple Sequence respectively, if this setting is enabled.
Auto Receive User User Commands processed by the Grapple Component are sent over (using a Blueprint Interface) to all Objects
Commands from that are stored as 'User Command Targets' for that Grapple Component. Any Grapple Sequence that is applied
Master during to the Grapple Component wil automatically be added and removed when it is applied and reverted
Grapple Sequence respectively, if this setting is enabled.
Authorize The delay after which Termination is Authorized automatically. This will not happen if this variable
Termination after has a negative value.
Delay
Terminate Grapple The delay after which the Grapple Sequence is Terminated automatically. This will not happen if
Sequence after Delay this variable has a negative value. For Struct Based Grapple Objects, the value of this variable is set
automatically based on the duration specified in the Global Grapple Data.
Branching - Preset This variable consists of Grapple Object Classes, each mapped to a name. When a User Command
Branches with this name is received by the Grapple Object, it calls Input Function Initiate Grapple Sequence With
Current Participants on the Master Grapple Component.
Branching - Use If true, the Grapple Component will use the timestamp from the User Command that lead to the
Timestamp from User branch to initiate the new Grapple Sequence. If not, the current time will be used instead.
Command
Branching - The replication mode to use when initiating the new Grapple Sequence.
Replication Mode
Status Objects 54
5.4.2.2. Struct Based Grapple Object
Class GrappleObject_StructBased
Parent GrappleObject
Description Struct Based Grapple Objects are Grapple Objects that use a variable structure of type
struct_CG_GrappleData_Global (i.e. Global Grapple Data) to specify the effects of the Grapple Sequence.
Implemented functions from Grapple Object (base functionality)
Apply Grapple On Struct Based Grapple Objects, Function Apply Grapple Sequence Effects (from parent Class GrappleObject)
Sequence Effects will use the Grapple Data on the Object to apply the influence from the Grapple Sequence to Participants. This
is done using Function Apply/ Revert - All Pending Grapple Data on the Grapple Component.
The Grapple Component will use function Generate Global Grapple Data on the Grapple Object to determine
the effects of the Grapple Sequence.
Revert Grapple On Struct Based Grapple Objects, Function Revert Grapple Sequence Effects (from parent Class GrappleObject)
Sequence Effects will use the Grapple Data on the Object to revert the influence from the Grapple Sequence from Participants.
This is done using Function Apply/ Revert - All Pending Grapple Data on the Grapple Component.
Overridable functions
Generate Global Defines the Global Grapple Data for this Grapple
Grapple Data Object in the form of a variable structure. For
more information on the composition of Global
Grapple Data, please consult the Graph of this
function on Object GrappleSequenceTutorial.
An alternative way to define Global Grapple

Data is to override variable Stored Global
Grapple Data.
Settings
Stored Global Grapple The default Global Grapple Data, which is stored by the Grapple Object and will be output by function
Data Generate Global Grapple Data. This value is ignored if function Generate Global Grapple Data Is overridden.
Status Objects 55
5.4.2.3. Fade Object
Class FadeObject
Parent StatusObject
Description Fade Objects are Status Objects that apply an effect over a certain duration.
Implemented functions from Status Object

On Added Calls parent function.
Calls function Start Fade if variable Auto Activate Pending is set to true.
On Removed - Interrupt Fade
- Disable Ticking
On Tick Calls parent function.
- Test Interrupt Conditions and Interrupt Fade if necessary
- Update Progress based on fade direction and delta time
- Apply Fade Output Value (based on current progress and progress curve)
- Check Fade Completion and apply Fade completed handling method
On Fade Started The Fade starts when function Start Fade is used on the Fade Object. This happens automatically (when the
Fade Object is added to an Affected Object) if variable Auto Activate Pending is set to true.
On Fade Ended The fade ends when it is interrupted, when function End Fade is called manually or when its progress has
completed (depending on the Fade completed handling method).
Apply Fade Output This function is called automatically during every tick of the fade and will output a float value based on
Value current progress and progress curve.
Test Fade Interrupt This function is called automatically during every tick of the fade, and will interrupt the fade if it returns true.
Conditions
On Fade Interrupted Called when the fade is interrupted. Interrupting the fade will immediately end the fade. A fade is interrupted
when function Test Fade Interrupt Conditions returns true or when function Interrupt Fade is called manually.
Status Objects 56
5.4.2.1. Hit Testers
Class HitTester
Parent FadeObject
Description Hit Tester Objects are used to check and evaluate hits that occur on one or more Primitive Components.
On Added Start testing hits on all Tested Primitive Components
On Removed Start testing hits on all Tested Primitive Components
On Any Hit The Object calls this Event whenever one of the tested primitive components is hit by another component
On Relevant Hit The Object calls this Event when a 'relevant hit' occurs on one of the tested primitive components. This is a hit
that meets certain conditions regarding hit type, collision object type and velocity.
Test Hit Relevance This function determines if there is a relevant hit. I fit is overridden, variables Accepted Hit types, Accepted
Collision Object Types and Minimal Velocity are ignored.
Determine Hit Type This function determines the hit type (default, bounce or landing). If the function is not overridden, this
happens automatically based on the impact normal.
Settings
Tested Primitive The Primitive Components that should be observed by the Hit Tester Object.
Components
Accepted Hit types The hit types that will be considered to determine if there is a relevant hit. The hit type is determined by calling
function 'Determine Hit Type' on the Hit Tester Object.
Accepted Collision The external components (i.e. the ones that are hitting the tested primitive components) with these collision
Object Types object types will be considered for a relevant hit.
Minimal Velocity The minimal velocity required for a relevant hit
Relevant Hit The minimal delay between relevant hits. Any relevant hits will be ignored while the colldown is active.
Cooldown
Status Objects 57
5.4.2.1. Bounce Objects
Class BounceObject
Parent HitTester
Description Bounce Objects are Hit Testers that push or launch a Character when they detect a relevant hit.
Implemented functions from HitTester
Test Hit Relevance Uses the parent functionality to test if the hit is relevant, but also calls function Test hit for Bounce Relevance.
On Relevant Hit Calls function Apply Bounce Velocity.
Test hit for Bounce Checks if the current movement mode on the Linked Character is accepted based on the Accepted Movement
Relevance Modes.
Apply Bounce Velocity Adds an impulse or launches the Character.
Settings
Linked Character The Character that is affected by the Bounce Object.
Accepted Movement The movement modes that the Linked Character is allowed to be in, in order for the hit to be considered
Modes relevant.
Bounce Velocity The velocity that will be applied by function Apply Bounce Velocity.
Status Objects 58
5.4.2.2. Gradual Transformation Object
Class GradualTransformationObject
Parent FadeObject
Description Gradual Transformation Objects are used to modify the Transformation of a Scene Component over a
certain duration.
Apply Fade Output This function is called automatically during - Calculate Target Transform
Value every tick of the fade and will output a float - Set Target Transform variable
value based on current progress and progress - Apply Gradual Transformation
curve.
Calculate Target Generates he target Transformation of the Transformed Scene Component. This transformation is applied
Transform every tick (during the Fade) using function Apply Gradual Transformation.
Settings
Affect Location Whether to affect the location of the Transformed Scene Component.
Affect Rotation Whether to affect the rotation of the Transformed Scene Component.
Affect Scale Whether to affect the scale of the Transformed Scene Component.
Sweep Whether to use the Sweep flag when transforming the Transformed Scene Component.
Teleport Whether to use the Teleport flag when transforming the Transformed Scene Component.
Rotation Multiplier A factor that is applied to each axis of the Rotation in the Target Transform . This variable can be used to lock
certain axes. The most common usage is to set it to (0, 0, 1) to keep Pawns upright.
Status Objects 59
5.4.2.3. Reposition Object
Class RepositionObject
Parent GradualTransformationObject
Description Reposition Objects are Gradual Transformation Objects that will gradually set the transformation of a
Scene Component based on interpolation between two target transformations
Implemented function from StatusObject
On Added Reposition Objects can be added to Grapple - Remove other Reposition Objects with same
Components when they apply effects from a Transformed Scene Component
Grapple Sequence. This is done using function - Store variables based on current state
Reposition Participant on the Grapple
Component or by setting the Local Reposition
Data for a Participant.
On Removed Reposition Objects are removed from the - Revert attach parent if variable On Removal - Revert
Grapple Component when the effects from the Parent Binding is set to true.
Grapple Sequence are reverted. - Revert relative transform if variable On Removal -
Revert Relative Transform is set to true.
On Fade Started Detach from initial attach parent if variable Attach When Complete is set to true.
On Fade Ended Apply new attach parent.
Implemented functions from GradualTransformationObject
Calculate Target The target transformation is calculated by interpolating between state 0 and state 1.
Transform
Settings
Attach When Complete Whether to attach the Scene Component after repositioning.
State 0 - Parent Scene Component Describes the initial state of the Transformed Scene component. These variables are set
State 0 - Attach Socket automatically by the Reposition Object.
State 0 - Relative Transform
State 0 - Update Continuously Whether to keep updating the initial state over the duration of the Fade.
State 1 - Parent Scene Component Describes the target State of the Transformed Scene component. These variables should be
State 1 - Attach Socket provided when constructing the Reposition Object.
State 1 - Relative Transform
State 1 - Update Continuously Whether to keep updating the target state over the duration of the Fade.
On Removal - Revert Parent Binding Whether to revert the attach parent of the Transformed Scene component to its value in state 0.
On Removal - Revert Relative Whether to revert relative transformation of the Transformed Scene component to its value in
Transform state 0.
Height Correction - Enable for Whether to reposition the Transformed Scene component based on lowest point on this Scene
Transformed Scene Component Component (where it would typically touch the ground). This only works if the Transformed Scene
component is a CapsuleComponent, SphereComponent or BoxComponent. Height Correction is
mainly intended for repositioning character with different capsule heights relative to one
another.
Height Correction - Enable for State Whether to interpret transformations relative to the Parent Scene Component in the target state
1 parent based on lowest point on this Scene Component (where it would typically touch the ground). This
only works if the Transformed Scene component is a CapsuleComponent, SphereComponent or
Height Correction - Enable for State
BoxComponent. Height Correction is mainly intended for repositioning character with different
0 parent
capsule heights relative to one another.
Status Objects 60
5.4.2.4. Look Target Object
Class LookTargetObject
Parent GradualTransformationObject
Description Look Target Objects are Gradual Transformation Objects that will gradually set the transformation of a
Scene Component based on interpolation between two target transformations
On Fade Started If the fade is going forward, store initial transformations.
Implemented functions from GradualTransformationObject
Calculate Target The target transformation is calculated by interpolating the initial rotation and the rotation and the one
Transform when applying the Look Target and the Rotation Offset.
Settings
Look Target The Scene Component the Transformed Scene Component should be aligned towards.
Rotation Offset A correction that is applied after calculating the look at transformation for the Transformed Scene
Component.
Update Look At Start Location Whether to keep updating the initial state over the duration of the Fade.
every Tick
Update Look At Target Location Whether to keep updating the target state over the duration of the Fade.
every Tick
Status Objects 61
5.4.2.5. Movement Data Object
Class MovementDataObject
Parent StatusObject
Description The Grapple Component can affect the way Characters move in the game world. This is done using
Movement Data. Movement Data Objects are stored in layers on the Grapple Component, and are applied
from low to high.
The Movement Data Object’s function is to store movement settings, in the form of a variable structure of
type struct_GC_MovementSettings.
On Added If the Affected Object is a Grapple Component, the Movement Data Object adds itself on the target layer
using function Movement Data - Add / Remove Layer. The rest of the functionality is handled by the Grapple
Component.
On Removed If the Affected Object is a Grapple Component, the Movement Data Object removes itself using function
Movement Data - Add / Remove Layer. The rest of the functionality is handled by the Grapple Component.
Settings
Movement Settings The Movement Settings applied by this Object.
Layer Movements object on lower layers are applied first. Higher ones are applied afterwards, overriding the
values of the lower layers.
Status Objects 62
State Tags
5.5.1. Concept
State Tags are Objects that are added to and removed from a State Tag Manager. They each hold an array of 'Reasons' that
keep them active. If they run out of Reasons, they are removed from the State Tag Manager. State Tags are used to define
certain circumstances the Grapple Component needs to take into account, that are an exception rather than the rule. As
such, you might only need the Grapple Component to do certain things if there are any (one or more) reasons to do so.
Examples of such things are:
- Refuse Input from the user - Input should be accepted if there are no reasons to refuse it. However, it may be ignored in certain
situation eg. the character being a Participant in a Grapple Sequence of performing another action.
- Prohobit the Grapple Component from entering a Grapple Sequence – This could be done while the Grapple Component is
already a Participant in another Grapple Sequence.
- Have Ticking Enabled – By default, ticking is disabled on the Grapple Component. However, certain functionalities (like
Repositioning and Push Character) do require some logic to be executed every tick. This is why these graphs will add a state tag
with consequence should tick enabled when they activate. When they are no longer active, the state tag is removed.
5.5.2. State Tag Manager

The State Tag Manager is an object that handles State Tags which can be applied to
the outer Object it has been assigned to. State Tags are Objects that are added to
and removed from a State Tag Manager. They each hold an array of 'Reasons' that
keep them active. If they run out of Reasons, they are removed from the State Tag
Manager. They are used to define certain circumstances the Grapple Component
needs to take intro account, that are an exception rather than the rule.
A State Tag Manager is automatically assigned to each Grapple Component, which

uses State Tags in several of its functionalities.
To access the State Tag Manager on a Grapple Component, use function Get State Tag Manager. Other Objects can
implement the State Tag Manager as well (although this is not done in any of the
assets relevant to the Grapple Component). To access the State Tag Manager for
any Object, use Interface Call Get State Tag Manager for Object (from Blueprint
Interface BI_StateTagInterface).
State Tags 63
5.5.3. Adding and removing state tags

State tags can be manipulated by accessing the State Tag Manager on the Grapple Component and using the Add/Remove
State Tag function on it.
- Performing the add operation adds a State Tag to the list of

active State Tags. If a State Tag with the same name already
exists, nothing will happen.
- Performing the remove operation removes the State Tag with
the provided name. Its consequences will then no longer be
applicable if there are no other active State Tags with the
same consequence enabled.
5.5.1. Evaluating current State Tags and consequences

State tags can be manipulated by accessing the State Tag Manager on the Grapple Component and using the Check State Tag
or Check State Tag Advanced function on this linked State Tag Manager.
This function will return ‘true’ if a State Tag of the

specified class is active, and will also return a list of
State Tag classes that ‘justify’ this state tag being
active.
It is also possible to use function Check State Tag

Advanced on the State Tag Manager. This allows
you to specify override causes. These are the state
tag classes that should not be considered as a
reason when checking if the specified State Tag is
active.
5.5.2. Consequences
State tags are linked to one another in the sense that each State Tag class has a set of other State Tag classes that are the
consequences of that State Tag. What this means, is that activating some State Tags will lead to the activation of other State
Tags. The relation between State Tags is based on consequence, rather than being a strict hierarchy.
State Tags 64
5.5.3. Built in State Tags

The following State Tags are built in to the Grapple Component and are used for its different functionalities.
On update Consequences
Description
State Tag Name (Functions On State Tag Added and (When this State Tag is added, the
(This state tag is added while … )
On State Tag Removed do the following) following ones are added as well)
ST_CannotEnterGrappleSequence This Grapple Component cannot become a Participant in a (no action on update) (no consequences)
new Grapple Sequence. Usually checked when evaluating
the Grapple Criteria during a Grapple Attempt.
ST_CharacterPushActive Any Character Push Object is active on the Linked Actor of (no action on update) ST_ShouldTick
this Grapple Component.
ST_GrappleAttempt_EveryTick This Grapple Component is performing a Grapple Attempt (no action on update) ST_ShouldTick
every tick.
ST_GrappleAttempt_Pending The Grapple Component has any pending Grapple (no action on update) (no consequences)
Attempts.
ST_GrappleAttempt_Verifying A Grapple Attempt is successful on the Client (and variable (no action on update) (no consequences)
Notify If Attempt Fails on Server is set to true for its Class).
Deactivated when the Server tells the Client that the
Grapple attempt has failed, or when a Grapple Sequence is
entered (usually on success).
ST_GrappleSequenceActive The Grapple Component is a Participant in a Grapple (no action on update) ST_RefuseInput
Sequence.
ST_CannotEnterGrappleSequence
ST_RefuseInput The Grapple Component is ignoring from the player. Usually (no action on update) (no consequences)
checked when performing a Grapple Attempt.
ST_ShouldTick Active when the Linked Object (in this case, the Grapple Update ComponentTickEnabled if the Linked (no consequences)
Component) should have tick enabled. Object is an Actor Component.
State Tags 65
Object Converter
5.6.1. Functioning of the Object Converter Blueprint

The Object Conversion Blueprint (ObjectConversion_StoredData)13 converts Input Objects to Output Objects based on
Modifier Objects. Its internal functioning can be described as follows.
- The Object Converter Blueprint contains a function Convert Object. This function converts an Input Object to an
Output Object based on a Modifier Object.
- Variable Object Conversion Mappings on the Object Converter Blueprint contains all possible input objects, all
posisble Modifiers for that input object, and the output objects they should be converted to based on each Modifier.
- An object can be converted if it is found as a key in variable Object Conversion Mappings.
- Each key in variable Object Conversion Mappings (i.e. each object that can be converted) is mapped to a value of
type Struct_ObjectConversion.
- An object will be converted based on a certain Modifier, if that Modifier is found in the Struct_ObjectConversion
mapped to the input object. The value the command is mapped to, will be the output object (i.e. the object the input
object is converted to).
Modifier Output
Object A Object A
Input Modifier Output

Object Object B Object B
Modifier Output
Object C Object C
5.6.2. Application: converting animation assets based on Skeleton

The Object Converter Blueprint is used by the Grapple Component to convert one animation asset (Montage, Anim Sequence
or Blendspace) to another, based on the relevant Skeleton.
This is done by using the original assets from the Animation Data as Input Objects, and the name of the Skeleton asset on the
targeted Character as the Modifier. The Grapple Component then uses an Object Conversion Blueprint defined by the user,
where all relevant animation assets are mapped to their counterparts on different Skeletons. In the Sample Content, this
Object Converter Blueprint is AnimationRemappingData. For a practical explanation on how to apply this functionality in your
own project, see the section on adapting animation assets based on the target Skeleton.
The sample content contains one Grapple Sequence that has been set up to be played on Skeletal Meshes using
UE4_Mannequin_Skeleton as well as TutorialTPP_Skeleton. To this end, Animation Montages
a_grapple_spinningkick_00_Montage and a_grapple_spinningkick_01_Montage were retargeted to another Skeleton. Object
Conversion Blueprint AnimationRemappingData was set up to convert the relevant Animation Montages to their
counterparts on the other Skeleton. A visual explanation of this system is provided on the next page.
13It should be noted that this ObjectConversion_StoredData Class inherits from the ObjectConversion parent Class, which does not contain
any stored date, but does contain a Convert Object function.
Object Converter 66
Value of variable ObjectConversionMappings in Object Visual Representation of these values.

Conversion Blueprint AnimationRemappingData.
Please note that the cells in blue with the dotted lines contain information that
(Blueprint'/Game/GrappleComponentContentExamples/SampleConte is not strictly necessary. If the original skeleton name is provided as the
nt/Animation/AnimationRemap/AnimationRemappingData.Animation command, the Input Object is simply converted to itself.
RemappingData')
Output Object
RTG_a_grapple_spinningkick_00_
Modifier Object Montage
TutorialTPP_Skeleton
(=montage using the same
animation sequence retargeted
to the other Skeleton)
Input Object
Montage
a_grapple_spinningkick_00_Monta
ge
Output Object
Montage
Modifier Object
a_grapple_spinningkick_00_Mont
UE4_Mannequin_Skeleton
age
(=same asset as the input object)
Output Object
RTG_a_grapple_spinningkick_01_
Modifier Object Montage
TutorialTPP_Skeleton (=montage using the same
animation sequence retargeted
to the other Skeleton)
Input Object
Montage
a_grapple_spinningkick_01_Monta
ge
Output Object
Montage
Modifier Object
a_grapple_spinningkick_01_Mont
UE4_Mannequin_Skeleton
age
(=same asset as the input object)
Internal Mechanisms 67
Enumerations
Enumerations used by the Grapple Component that are not discussed elsewhere, are explained in this section.
5.7.1.1. Enum_GC_GrappleSequenceOperation
Defines the ‘direction’ we are moving when performing operations.
Enter / Apply Apply Grapple Settings (when entering a Grapple Sequence)
Exit / Revert Revert Grapple Settings (when exiting a Grapple Sequence)
5.7.1.2. Enum_GC_ResetSwitch
Defines whether the Grapple Component should be setting new settings, or revert settings to their Revert Values.
Set Custom Values Apply Settings, usually based on the member variables of a variable structure.
Reset To Default Revert Settings to their Revert Values.
5.7.1.3. enum_GC_GrappleSequenceTimeframe
Refers to a specific moment in the Grapple Sequence, ussuallt stored in a timestamp on the Grapple Object.
Current time Refers to the current server time, taken from the Game State
Grapple Sequence Refers to the time the Grapple Sequence was initiated on this Grapple Object
Initiation
Last User Command Refers to the time where the currently/last processed User Command that was received by the
Received Grapple Object
Last Participant Refers to the time a Perticipant was last added to or removed from the Grapple Object
Update
Custom Timestamp Refers to the value of variable 'Timestamp - Custom' on the Grapple Object
5.7.1.4. Enum_GC_RoleType
Defines the current state the Grapple Component currently occupies, in the context of a Grapple Sequence.
None The Grapple Component currently has no role in a Grapple Sequence.
Master The Grapple Component is currently the Master in a Grapple Sequence.
Follower The Grapple Component is currently a Follower ( Participant other than the Master) in a Grapple
Sequence.
5.7.1.5. Enum_GC_RotationSpaceSelection
This enumeration contains options on how to interpret a rotation. It usually accompanies a variable of type rotator.
World Indicates that the rotator should be interpreted in world space.
Actor Indicates that the rotator should be interpreted the space of the Actor linked to this Grapple
Component.
Control Rotation Indicates that the rotator should be interpreted relative to the control rotation of the Pawn
linked to this Grapple Component.
5.7.1.6. enum_GC_SearchMethod
For more information about this enumeration, please navigate to the relevant passage in the section on
Search Targets.
5.7.1.7. enum_GS_ConnectionType
This enumeration describes whether a connection is the Server or a Client.
Client Indicates that the connection is a Client.
Server Indicates that the connection is a Server.
5.7.1.8. enum_GS_ModifyBoolean
Describes a modification that should occur to a variable of type Boolean.
Do not modify The variable should remain unchanged.
Set to TRUE The variable should be set to TRUE.
Set to FALSE The variable should be set to FALSE.
5.7.1.9. enum_GS_ReplicationMode
For more information about this enumeration, please navigate to the relevant passage in the section on Replication.
5.7.1.10. enum_GS_SceneComponentSelectionType
Defines how to find a scene component to base the target transform on, if the camera transform is affected by the Sequence
Camera.
Custom The object defined by the 'CustomSequenceCameraMesh' variable under settings.

This selection method requires the additional input of a Scene Component Object reference.
Actor Root Component The Root Component of an actor.
Base Mesh The main skeletal mesh animated by the Grapple Component.
Virtual Mesh The Virtual Mesh that is used for animation retargeting.
Camera Component The Camera Component on the Character.
Search Command Calls function ‘Search Scene Component’ (from Blueprint Interface
‘BI_GrappleComponentInterface’ on the owning actor. This Interface function can be
implemented if you want to look up a specific Scene Component based on an input command.
This selection method requires the additional input of a Search Command (variable of type
name).
5.7.1.11. Enum_GS_UI_Colors
This enumeration contains a list of names for preset colors used in the debug user interface. It is not relevant for users.
References to external Objects
5.8.1. Functions in Category ‘External References’

The Grapple Component uses different functions that acquire references to other Objects
that the Grapple Component needs for its different functionalities. These functions can be
found in category ‘External References’.
5.8.2. Search Scene Component

Function Search Scene Component on Blueprint Interface BI_GrappleComponentInterface
finds a Scene Component that is in some way linked to an Object, based on an input Search
Command.
This Search Command functions as a sort of ‘tag’, which is used to uniquely identify a Scene
Component when interfacing with a specific Object.
For example, when performing this function on a Character Blueprint:
- Search Command ‘CharacterMesh’ could return the main Skeletal Mesh used
by the Character; and
- Search Command ‘DefaultGrappleHitbox’ could return the Primitive Component that is used to search for
Participants when performing a Grapple Attempt.
An example of how this function could be implemented is shown below.
A way of calling this Function with some extra functionality from the Grapple Component, is by using function
SearchSceneComponentOnObject. This function attempts to perform the Interface call on the target object. The parameters
of this function add the following functionality.
- Only Accept Primitive Components: this parameter provides the option to filter the output so that only Primitive
Components are accepted.
- Search By Tag If Not Found: this parameter allows users to find a Scene Component based on its component tags,
if the Input Object is an Actor. This means that you can also use the function by changing the component tags on the
Input Object, without needing to implement the Interface.
5.8.3. Attachment Definitions

The Grapple Component sometimes uses an attachment definition to refer to a Scene Component, or to a transformation
relative to it.
This is done using a variable structure of type struct_GC_AttachmentDefinition. This variable structure contains instructions
for finding a Transform in the context of a Grapple Sequence.
Member Variable Type: enum_GS_SceneComponentSelectionType

Selection Type
The type of Scene Component to look for.
Reference Participant Index The Participant based on which we should look for the Scene Component mentioned above. 14
Search Command Input In case Search Command is selected under selection type, the Grapple Component calls
function ‘Search Scene Component’ (from Blueprint Interface ‘BI_GrappleComponentInterface’
on the owning actor. This Interface function can be implemented if you want to look up a
specific Scene Component based on an input command.
This member variable contains the Search Command that will be used.
Custom Scene Component Input In case ‘Custom’ is specified under Selection Type, a Scene Component Object reference can
be input here.
Socket Name The Socket on the Scene Component specified above that we should base out Transform on.
Relative Transform The relative transformation (either to the Socket or the Scene Component itself)
Attachment definitions can be applied using function Apply Attachment Definition.
14For example, if ‘Actor Root Component’ is specified under Selection Type and the Reference Participant Index is 0, this Attachment
Definition is referring to the Root Component of the Master Grapple Component ( = the Participant with index 0).
Debug Tools
5.9.1. Debug Settings

The Grapple Component contains the following debug settings.
Disable Debug Info on Clients Whether to only display debug information on the server (and not on all clients). Only has effect if
'show debug info' has been set to true. Note that this Variable will only have an effect during setup.
Debug - Global Switch Whether to allow any of the debug information (normally controlled by the other settings) to be
visible.
Debug - Show Virtual Mesh Whether to show a visible material on the Virtual Mesh.
Debug - Show UI See the section on Debug UI.
Debug - Print Messages See the section on Debug Messages.
Debug Color The color used to refer to this Grapple Component in the Debug UI.
Settings related to debugging can be updated in the following ways:
– In the Grapple Component Blueprint itself, by setting the relevant variables in category ‘Debug’
– At runtime, Using event ApplyDebugSettings will apply the settings on a single Grapple Component
– At runtime Using event ApplyDebugSettings_AllGrappleComponents will apply the settings on all Grapple
Components
5.9.2. Debug Messages

The Grapple Component can print messages to the screen ant to the log
(using the Print Text function built into the Engine).
This can be done using function DebugMessage.
Messages will be printed if they are enabled in the Debug Settings, or if

parameter Always Print (Ignore Settings) is set to true.
5.9.3. Debug UI
If variable Debug - Show UI is set to true, the Grapple Component will add
a widget of Class UI_GC_DebugHUD to the player screen.
This widget contains several Widgets of Class UI_CG_Frame, which in turn

contain the following information on individual Grapple Components:
- The name of the Actor this Grapple Component belongs to;
- The reason this widget is visible;
- Either the current Participants Following this Grapple Component

or the Master Grapple Component this Grapple Component is
following; and
- The active state tags for this Grapple Component.
Widgets will be shown automatically for the Grapple Component on the

currently possessed Pawn, as well as for any other Participants if this
Grapple Component is currently Participating in a Grapple Sequence.
6. TUTORIALS
This Section contains some tutorials that should get you started with the Grapple Component.
Installation
To add the Grapple Component to your project, place all contents of the Content folder in the Content folder of your own project. The ContentExamples folder can be left out.
This can also be done by opening the project file, right clicking on the GrappleComponent folder and selecting Migrate.
Accessing the Content Examples

The content examples can be found in folder Content/GrappleComponent/ContentExamples.
To access the Demonstration Game Mode, open Content/GrappleComponent/ContentExamples/GrappleComponent_ExampleMap.umap and play this level in the editor.
Tutorials 75
Implementation
Follow these steps to implement the Grapple Component into a Character Blueprint.
1. Gather necessary assets 4. Set up Animation Blueprint – Method 1 – Linked Anim Graph (Recommended)
Make sure the content in the Grapple Navigate to the template for the Grapple Component Animation Blueprint (Object GrappleComponent_AnimBP, found in
Component Content is included in your project. the AnimBP folder of the Grapple Component folder). If you use the Grapple Component as an addon, you need to show
enable ‘show engine content’ in your content browser in order to find this object. Create a Child Blueprint Class of this
This can be done by following the previous
object.
tutorial.
On this newly created Blueprint, navigate to the Class Settings and set the Target
Skeleton to be the same one your Character’s Skeletal Mesh is using.
Note that the target skeleton flag is marked as advanced under the class settings.
This means that you might need to expand the section to see the option.
2. Add Grapple Component to your

Character Blueprint
Open your Character Blueprint.

Navigate to the Components panel.
Add a component of class GrappleComponent.
Open the Animation Blueprint used by your Character’s main Skeletal Mesh.
In the Anim Graph of this Blueprint, add a Linked Anim Graph node before your
output pose.
3. Create Default Grapple Hitbox (optional)
With the newly created node selected, navigate to the details panel and set the
Instance Class to be the Animation Blueprint we have just created.
Optionally, you can add a Primitive Component that will be
used to search for targets. The Linked Anim Graph should be placed so that its output influences the output
pose of the Animation Blueprint.
If you want the Grapple Component to use this Primitive
Component by default, it should have a tag named
defaultgrapplehitbox .
Tutorials 76
4. Set up Animation Blueprint – Method 2 (Montages Only) Regardless of the method used, all nodes should be placed in between the character’s default animation graph nodes, including relevant
animation slots and the output pose.
It is possible to work without a Linked Anim Graph by simply connecting the
Montage Slots you are using to the output pose.
If you already have montage slots set up, this method requires no
implementation at all.
It should be noted that this method is only viable if Grapple Sequences use
Animation Montages only. This method does not support the Animation
Matching feature.
4. Set up Animation Blueprint – Method 3 (Manual

Implementation)
Animation for Grapple Sequences can also be implemented manually, by

using the events from Blueprint Interface
'BI_GrappleComponentAnimationInterface’.
Your Character is now Compatible with the Grapple Component!
For instructions on how to create your own Grapple Sequence, please proceed to the next tutorial.
Tutorials 77
Grapple Component Documentation Jonathan
Follow these steps to implement the Grapple Component Van Damme
into a Character Blueprint.
Setting up a Grapple Sequence Follow these steps to create a custom Grapple Sequence and initiate it from gameplay.
For many users, it might be easier to follow along on the 2. Make Grapple Data
GrappleSequenceTutorial Object, which contains a Graph with the same
instructions as this document. The Graph also provides references to the relevant Method 1
functions and other nodes.
On your newly created Grapple Object, override function Generate Global Grapple Data. In the Graph of this function, use a Make
Struct_GC_GrappleData_Global node to generate the Global Grapple Data.
Method 2 Method 3
1. Create Grapple Object
An alternative to using this Blueprint layout to generate Global Modify the default value of variable Stored_GlobalGrappleData on the
Right-click an empty space in the Content Browser and create a new Blueprint Grapple Data, is to use the macro called '(Simplified) Generate Grapple Object. This can be done in the Class Defaults tab.
Class that inherits from Class GrappleObject_StructBased Global Grapple Data', which will only expose the essential
parameters to create a 'typical' third person Grapple Sequence
with an attacker and a target,
Tutorials 78
3. Define Search Method (Optional) 4. Define Selection Criteria (Optional) Functions can be overridden on any Blueprint by navigating to
the My Blueprint tab, opening the Functions section and
This step is only relevant in case you are This step is only relevant in case you are initiating this Grapple Sequence from a Grapple Attempt. opening the override menu. From there, you can select the
initiating this Grapple Sequence from a
function you wish to override.
Grapple Attempt. On your newly created Grapple Object, you can implement your own logic for applying
Selection Criteria by overriding functions 'Apply Selection Criteria' and/or 'Test Selection
On your newly created Grapple Object, Conditions’.
override function 'Search Candidates’. This
function finds Grapple Components in the Function Apply Selection Critetia can be overridden if you wish to build your own logic that
game world that will become Candidates to checks if a group of Candidates is fit for the Grapple Sequence based on this Object, and
enter a Grapple Sequence. determines the Participant Index for each Candidate.
Please consult the Graph of this function in Function Test Selection Conditions on Candidate can be overridden if you wish to build your own logic
GrappleSequenceTutorial for more that checks if a single Candidate is fit for the Grapple Sequence based on this Object.
information
Please consult the Graph of these functions in GrappleSequenceTutorial for more information
5. Override Events (Optional) 6. Initiate Grapple Sequence from other Blueprint Option B: Execute Grapple Object Option C: Initiate Grapple Sequence
It is also possible to use the The node InitiateGrappleSequence on the Grapple

The Grapple Object contains various Events and Option A: Grapple Attempt
'Execute Grapple Object' event. Component can be used to make a specific set of
Functions that can be overridden based on the
A grapple attempt is a process where the Grapple Component searches for This event creates a Grapple Grapple Components enter a Grapple Sequence
needs of your project. These Events and
other Grapple Components that are eligible to join a Grapple Sequence, Object from the specified class and together.
Functions can be used to add your own
filters those Candidates based on certain criteria and then initiates a calls the Execute event on it.
functionality that goes beyond the one built into The InitiateGrappleSequence node is useful in
the Grapple Object itself. Grapple Sequence with itself and these Candidates as the Participants.
Unless this event is overridden on cases where you have determined that a Grapple
It will typically serve as the link between a Grapple Sequence and the Grapple Object, it simply calls Sequence will initiate, regardless of circumstances
Please consult the Implementable Events on the
gameplay. GrappleAttempt on the relevant in the game world. It gives you direct control over
Grapple Object Graph of the
Grapple Component with the a Grapple Sequence. When using this node, only
GrappleSequenceTutorial Object for a detailed
All Grapple Attempts are initiated on the basis of a Grapple Object Class. newly created Grapple Object as the Global Grapple Data on the Grapple Object will
explanation of these functions.
This can be done using node Grapple Attempt (Input) or node Grapple input. be taken into account. The Search Method and
Attempt Advanced (Input). Selection Criteria are not relevant.
Your Grapple Sequence can now be initiated from gameplay.
Tutorials 79
7. OTHER INFORMATION
Credits
The Grapple Component was created by Jonathan Van Damme. For more information, please contact jon@jonvandam.com.
The creation of the Grapple Component was made possible by:
– Unreal Engine – The framework in which the project was created.
– Jim Kroovy (Youtube / Patreon) – Creator of animation assets ThirdPerson_Basic_Kick_Push_L and

ThirdPerson_Basic_Kick_Turning360_L (used in the content examples).
– Mr Mannequins Tools by Jim Kroovy – Mr Mannequins Tools is a Blender add-on that exports animations and
weighted meshes that are directly compatible with the third person mannequin that is available in Unreal Engine's
Third Person Template, without re-targeting anything in Unreal Engine.
Where to Get the Grapple Component

The Grapple Component is available on Gumroad.
Support
In case you have any further questions, feedback or suggestions regarding the Grapple Component, please contact
support@jonvandam.com.
Other Information 80

Grapple Component Documentation PDF

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Grapple Component Documentation PDF

Uploaded by

Copyright:

Available Formats

Grapple Component Documentation Jonathan Van Damme

Jonathan Van Damme 2020-11-26

1.3.1. Concept ............................................................................................................................................................. 7

1.3.2. Functionality ..................................................................................................................................................... 7

1.5.1. Master Grapple Component / Controlled Grapple Object ................................................................................ 8

1.5.2. Participant / Applied Grapple Object ................................................................................................................ 8

1.6.1. Concept ............................................................................................................................................................. 9

1.6.2. How to access ................................................................................................................................................... 9

1.6.3. Links to documentation .................................................................................................................................... 9

2. EFFECTS OF THE GRAPPLE SEQUENCE ........................................................... 10

2.1.1. Global Grapple Data ........................................................................................................................................ 10

2.1.2. Local Grapple Data .......................................................................................................................................... 11

2.1.3. Storage in the Grapple Object ......................................................................................................................... 11

2.2.1. Scene Root ...................................................................................................................................................... 12

2.2.2. Reposition Target ............................................................................................................................................ 12

2.2.3. Scene Collision Actor ....................................................................................................................................... 13

2.2.4. Defining reposition settings using Grapple Data............................................................................................. 15

2.2.5. Reposition Objects .......................................................................................................................................... 16

2.3.1. Animation Data ............................................................................................................................................... 17

2.3.2. Animation Updates ......................................................................................................................................... 18

2.3.3. Blendspaces .................................................................................................................................................... 19

2.3.4. Animation Matching ....................................................................................................................................... 21

2.3.5. Adapting Animation based on Skeleton .......................................................................................................... 25

2.4.1. Movement Settings and Movement Data Objects .......................................................................................... 26

2.4.2. Updating Movement Settings ......................................................................................................................... 27

2.4.3. Revert Values .................................................................................................................................................. 27

2.4.4. Snap to Control Rotation................................................................................................................................. 27

3. CONTROLLING THE GRAPPLE SEQUENCE ........................................................ 32

3.1.1. Initiate Grapple Sequence ............................................................................................................................... 32

▪ Execute Grapple Object .................................................................................................................................. 32

3.1.2. Grapple Attempt ............................................................................................................................................. 32

3.2.1. Terminate Grapple Sequence (Input Function) ............................................................................................... 33

3.2.2. Termination Timer .......................................................................................................................................... 33

3.3.1. Input Functions ............................................................................................................................................... 34

3.3.2. Different phases of the Grapple Attempt (Summary) ..................................................................................... 35

3.3.3. First Phase: Search Candidates ....................................................................................................................... 36

3.3.4. Second Phase: Apply Selection Criteria ........................................................................................................... 37

3.3.5. Third Phase: Initiate Grapple Sequence on Success........................................................................................ 39

4. OTHER FUNCTIONALITY ............................................................................ 40

4.1.1. Concept ........................................................................................................................................................... 40

4.1.2. Adding Queued Events to a Grapple sequence ............................................................................................... 40

4.2.2. User Command Targets ................................................................................................................................... 42

4.2.3. How to use ...................................................................................................................................................... 43

4.4.1. Snap to Control Rotation from Client.............................................................................................................. 44

4.4.2. Snap to Control Rotation from Server............................................................................................................. 44

4.5.1. Construct and add Character Push Object ...................................................................................................... 45

4.5.2. Using Macros................................................................................................................................................... 45

4.5.3. Character Push Objects ................................................................................................................................... 46

5. INTERNAL MECHANISMS ........................................................................... 48

5.1.1. Replication Mode on Input Events .................................................................................................................. 48

5.1.2. Replication of Grapple Attempts..................................................................................................................... 48

5.2.1. Stored Timestamps ......................................................................................................................................... 49

5.2.2. Relevant functions .......................................................................................................................................... 49

5.4.1. Status Object Base Class ................................................................................................................................. 52

5.4.2. Child Classes .................................................................................................................................................... 53

5.5.1. Concept ........................................................................................................................................................... 63

5.5.2. State Tag Manager .......................................................................................................................................... 63

5.5.3. Adding and removing state tags ..................................................................................................................... 64

5.5.1. Evaluating current State Tags and consequences ........................................................................................... 64

5.5.2. Consequences ................................................................................................................................................. 64

5.5.3. Built in State Tags ............................................................................................................................................ 65

5.6.1. Functioning of the Object Converter Blueprint ............................................................................................... 66