Grappling Hook Movement Mode

When you created the sprinting movement modifier in Sprint Movement Modifier, you only needed to temporarily change an existing movement mode to make the character run faster. For grappling, you need the character to move in a completely new way: fly towards a grapple point in the environment and then fall once reaching that grapple point. To make the character move in this way, you’ll create a new Movement Mode that defines how the player character moves when using the Grappling Hook action. 

When the player activates the Grappling Hook action, the new Movement Mode tests if the player is looking at a grapple point in range and starts interpolating the location of the player to the grapple point.

Create the Grapple Point Blueprint

The grapple point Blueprint is the Actor spawned in the level that the player grapples towards. Your grapple point will have an emissive Material that lights up when the player is looking at it and it’s in grappling range.

Create an Emissive Material

First, you’ll create a Material and Material Instance to use in the grapple point Blueprint. 

To create the emissive Material and Material Instance, follow these steps:

1. In the Content Browser, in the Content > Parkour folder, create a new folder named Materials.

2. In the new Materials folder, right-click and create a new Material, and name it M_Emissive. This will be the parent of the Material Instance used in the Grappling Hook.

3. Open the Material. In the Material Graph, in the Material root node, change Roughness and Specular to 0.

4. Create a VectorParameter node and name it BaseColor.

5. Connect the BaseColor parameter node’s RGB value to the Material root node’s Base Color pin.

6. Create another VectorParameter and name it EmissiveColor.

   

7. Create a ScalarParameter and name it Intensity. Set its Default Value to 3.

8. Add a Multiply node to multiply EmissiveColor and Intensity. Connect the result to the Material root node’s Emissive Color pin.

9. Click the BaseColor parameter node. In the Details panel, expand the Default Value section and set R, G, and B to 1. Do the same for EmissiveColor.

   The final Material Graph should look like this:

   

10. Click Apply and Save, and close the Material.

11. Return to the Content Browser. Right-click M_Emissive and select Create Material Instance. Name it MI_EmissiveBlue.

12. Open the Material Instance. Override and change these parameter values:

    1.  Set EmissiveColor to a blue color.

       

    2. Set Intensity to 0. The grapple point should start dull and white and only become emissive and blue when active.

13. Save and close the Material Instance.

Set up Grapple Point Appearance

In this tutorial, the grapple point is a simple rectangular prism. You can follow this design or create your own look for the grapple points.

To set up the Grapple Point Blueprint, follow these steps:

1. In the Content Browser, in the Content > Parkour > Blueprints folder, right-click and create a new Blueprint Class.

2. Select Actor as the parent class.

3. Name the Blueprint BP_GrapplePoint and open it.

4. In the Blueprint Editor, in the Components panel, select DefaultSceneRoot, click Add, and add a Static Mesh component. The mesh should be a child of the scene root.

5. Name the mesh component GrapplePoint.

   

6. In the Details panel, set the Static Mesh to SM_Ramp.

7. Click Compile.

   If you can’t see the mesh in the Viewport, zoom out.

8. In the Materials section, set Element 0 to MI_EmissiveBlue.

   

9. Transform the prism shape so the flat, square side is facing up and is a 0.5m square:

   1. Set the Rotation X value to -45.

   2. Set the Scale X, Y, and Z values to 0.5.

      

Add Grapple Point Logic

The grapple point should test its distance from the player and if the player camera is pointed at the grapple point. If the conditions pass, it should increase its Material’s emissive intensity and start to glow.

Store the Player Pawn as a Variable

To get and save the player Pawn, follow these steps:

1. Go to BP_GrapplePoint’s EventGraph tab.

2. From Event BeginPlay, drag off the exec pin and create a Get Player Controller from Input Device node.

3. Drag off the Return Value pin and add a Get Controlled Pawn node.

4. Before saving the Pawn object, check if it’s the expected Pawn type. Drag off the Get Controlled Pawn node’s Return Value pin and add a Cast to BaseAnimatedMannyPawn node.

   You cast to the Pawn’s parent BaseAnimatedMannyPawn class here because it’s the most general Pawn type that exposes the components you need in this Blueprint (the direction of the Pawn’s camera component in this case).

5. Connect the exec flow from Get Player Controller to the Cast To node.

6. If the Cast To succeeds, store the typed reference to the Pawn:

   1. In the Cast To node, right-click the As Base Animated Manny Pawn pin and select Promote to Variable.

   2. In the My Blueprint panel, rename the new variable PlayerPawn.

      

Change a Grapple Point’s Glow

Every frame, the Blueprint should lower or raise emissive intensity depending on whether the grapple point is within range and in the player’s line of sight.

To make the grapple point stop glowing when grappling conditions aren’t met, follow these steps:

1. In the My Blueprint panel, create a new variable of type float named CurrentIntensity. You’ll use this variable to store the grapple point Material’s current state.

2. From Event Tick, create a Branch node. This Branch will check if the distance between the grapple point Actor and player is less than 20 meters and returns False if out of range. You’ll set up its Condition later.

3. From the False exec pin, add a Set Current Intensity node and keep the value 0.

   

4. Drag off the Set node’s exec pin and add a Set Scalar Parameter Value on Materials node:

   1. The Target should be the Grapple Point mesh.

   2. For the Parameter Value pin, connect the Set node’s output pin.

   3. For the Parameter Name, enter Intensity.

      

To make the grapple point glow when both grappling conditions are met, follow these steps:

1. From the Branch node’s True pin, add another Branch node.

   This second Branch node compares the vectors of the grapple point and player camera. It returns True if the vectors are roughly aligned (player is looking at the grapple point) and False if they are not aligned (player is looking away). You’ll set up the condition later.

2. Connect the second Branch node’s False pin to the Set Current Intensity = 0.0 node so the False result of both Branch nodes turns off the grapple point’s glow.

   

3. Select the Set Current Intensity, Set Scalar Parameter, and Grapple Point nodes. Press Ctrl + D to duplicate them and move the copies above the originals, after the second Branch node.

4. Connect the second Branch node’s True pin to the new Set Current Intensity node, and change the value to 3.0.

   

Check for Distance to Player

Now you’ll build the conditions for each Branch node.

To test if the player is in range of the grapple point, subtract the player’s location from the grapple point’s location, get the length of that vector, and check if it is less than 20 meters (2000 units).

To add the condition that tests player distance from a grapple point Actor, follow these steps:

1. To the left of the Event Tick node, add two Get Actor Location nodes, placing one above the other.

2. For the second Get Actor Location node, from the My Blueprint panel, drag the Player Pawn variable onto the Target pin.

3. Connect both Get Actor Location nodes to a new Subtract node.

   

4. Drag the Subtract node’s output pin and add a Vector Length node to calculate the distance.

5. Drag off the Return Value pin and add a Less (<) node.

6. For the lower value of the Less node, enter 2000.

7. Connect the result to the first Branch node’s Condition pin.

   

Check for Player Camera Direction

To add the condition that tests player camera direction, follow these steps:

1. Drag off the Subtract node’s output pin and add a Normalize node above your Event Tick logic.

   Normalizing the vector converts it to a direction only, no length.

   

2. Get the direction of the player camera:

   1. Under the Normalize node, add a Get Player Pawn variable reference.

   2. Drag off Player Pawn’s pin, search for get camera variable, and add a Get Camera node.

   3. Drag off the Camera pin and add a Get Forward Vector node (in the Transformation section of the node actions list).

3. To compare two vector directions, get the dot product of those vectors. Add a Dot Product node and connect the Normalize and Get Forward Vector nodes to the Dot node’s inputs.

   

4. The dot product returns a 1 if the vectors are perfectly aligned, 0 if perpendicular, and -1 if the vectors point in the opposite direction. To make the grapple point activate when the player is roughly looking at it rather than aiming directly at it, add some tolerance to the dot product result.

   Drag off the dot product’s result and add a Greater (>) node. Enter 0.88 as the node’s second input.

5. Connect the Greater node’s output pin to the second Branch node’s Condition pin.

   

   If the dot product of the player and grapple point direction vectors is greater than 0.88, the Branch returns true.

6. Save and compile the Blueprint.

The finished event graph should look like this:

Test the Grapple Point

Return to the level editor, add a BP_GrapplePoint to your level, and play the level and check that it's a plain color when looking away, and emissive when looking at it.

Build the Grappling Hook Actor Component

When implementing mechanics with Mover, keep in mind that only one Movement Mode can be active at a time. When a Movement Mode isn’t active, its code isn’t running, so it can’t continuously check for the conditions it requires to activate. To switch between Movement Modes, you need another system that can act as a link between the game, player, and a Movement Mode. You can build a new Actor Component class and add it to your character to act as this link. The Actor Component checks for the conditions required to queue a Movement Mode.

Here, the Grappling Hook Actor Component checks whether the player is aiming at a grapple point in range. If they are, the character can queue the Grappling Hook Movement Mode with the grapple point information gathered by the Actor Component. 

Create the Actor Component Class

To set up a new Grappling Hook component, follow these steps:

1. In Unreal Editor, go to Tools > New C++ Class.

2. For the parent class, select Actor Component.

3. Name the class GrapplingHookActorComponent and click Create Class.

4. Similar to BP_GrapplePoint, the Actor Component also needs to check the player’s range and line of sight to the grapple point. In GrapplingHookActorComponent.h, declare the following public variables:

   • TSubclassOf<AActor> GrapplePointClass: The type of Actor the component should search for when looking for valid grapple targets in range.

     TSubclassOf<Type> is a variable that stores a class type that inherits from Type. You’ll set this to BP_GrapplePoint in the Pawn Blueprint.

   • float MaxGrappleRange: How far away the component can detect a BP_GrapplePoint. The default value is 2000.f to match BP_GrapplePoint.

   • float DotProductThreshold: Adjusts how aligned the player camera view has to be with the grapple point for the Movement Mode to activate. Set to 0.87f.

5. Add a UPROPERTY macro to all three properties with EditAnywhere, BlueprintReadWrite, and a category named “Grapple” to expose each to the level editor and Blueprints.

   C++

   UCLASS( ClassGroup=(Custom), meta=(BlueprintSpawnableComponent) )
   class PARKOURGAME_API UGrapplingHookActorComponent : public UActorComponent
   {
   	GENERATED_BODY()
   
   public:	
   	// Sets default values for this component's properties
   	UGrapplingHookActorComponent();
   
   	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Grapple")
   
   Expand code Copy full snippet(27 lines long)

6. Declare a public function named FindClosestGrappleTarget. Give it a UFUNCTION macro with BlueprintCallable and Category = "Grapple". 

   C++

   public:	
   	// Sets default values for this component's properties
   	UGrapplingHookActorComponent();
   
   	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Grapple")
   	TSubclassOf<AActor> GrapplePointClass;
   
   	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Grapple")
   	float MaxGrappleRange = 2000.f;
   
   
   Expand code Copy full snippet(19 lines long)

Your final GrapplingHookActorComponent.h should look like this: 

// Copyright Epic Games, Inc. All Rights Reserved.

#pragma once

#include "CoreMinimal.h"
#include "Components/ActorComponent.h"
#include "GrapplingHookActorComponent.generated.h"


UCLASS(ClassGroup = (Custom), meta = (BlueprintSpawnableComponent))

Implement the FindClosestGrappleTarget Function

The Grappling Hook component is responsible for finding a grapple point in range, so all of its logic is handled in the FindClosestGrappleTarget function. Like BP_GrapplePoint, this function calculates the distance and line of sight between the player and grapple points. It returns false if there is no valid grapple target, or it returns information about the closest valid grapple target it found.

Check for Valid Input and Gather Actor Information

1. In GrapplingHookActorComponent.cpp file, add the following #include statements:

   C++

   #include "Camera/CameraComponent.h"
   #include "Kismet/GameplayStatics.h"
   

   Copy full snippet(2 lines long)

2. Inside the FindClosestGrappleTarget function, add an if statement to check if the GrapplePointClass isn’t set in the component’s properties.

3. In the if statement, print a log message to warn the user there is no GrapplePointClass, and then return false. 

   C++

   bool UGrapplingHookActorComponent::FindClosestGrappleTarget(FVector& TargetLocation, AActor*& TargetGrapple) const
   {
       if (!GrapplePointClass)
       {
           UE_LOG(LogTemp, Warning, TEXT("GrappleTargetFinderComponent: GrapplePointClass not set!"));
           return false;
       }
   

   Copy full snippet(7 lines long)

4. Add an if statement to check that the component is attached to an owning AActor. If it doesn’t have an owner, return false.

   C++

   bool UGrapplingHookActorComponent::FindClosestGrappleTarget(FVector& TargetLocation, AActor*& TargetGrapple) const
   {
       if (!GrapplePointClass)
       {
           UE_LOG(LogTemp, Warning, TEXT("GrappleTargetFinderComponent: GrapplePointClass not set!"));
           return false;
       }
   
       AActor* Owner = GetOwner();
       if (!Owner)
   
   Expand code Copy full snippet(13 lines long)

5. Get the forward vector of the player’s camera component or the player itself:

   1. Declare a new FVector named Forward.

   2. Call Owner->FindComponentByClass() on the CameraComponent and save a pointer to it.

   3. Add an if statement to check if the camera component you saved is valid.

   4. If the camera component is valid, call GetForwardVector().GetSafeNormal() on the camera component and assign that value to Forward.

   5. If the camera component isn’t valid, call GetActorForwardVector().GetSafeNormal() on the owning character instead.

   C++

    // Try to get the camera component
       UCameraComponent* Camera = Owner->FindComponentByClass<UCameraComponent>();
       FVector Forward;
       if (Camera)
       {
           Forward = Camera->GetForwardVector().GetSafeNormal();
       }
       else
       {
           // Fallback to Actor forward vector
   
   Expand code Copy full snippet(12 lines long)

6. To find the closest grapple point, you’ll need to also save the player’s location and a list of all BP_GrapplePoint instances:

   1. Declare a const FVector named OwnerLoc to store the owning character’s location. Call GetActorLocation() to set the value.

   2. Declare a TArray of AActor pointers named GrapplePoints.

   3. To populate the array, call UGameplayStatics::GetAllActorsOfClass(UWorld,  SearchClass, StorageArray). Use GetWorld() to retrieve the current UWorld, and pass the GrapplePointClass and GrapplePoints array.

   C++

   // Get owner location
   const FVector OwnerLoc = Owner->GetActorLocation();
   
   // Gather grapple points
   TArray<AActor*> GrapplePoints;
   UGameplayStatics::GetAllActorsOfClass(GetWorld(), GrapplePointClass, GrapplePoints);
   

   Copy full snippet(6 lines long)

7. Before you loop through all grapple points in the array, declare variables you’ll use and update inside the loop:

   1. An AActor pointer named ClosestGrapple. You’ll update this in the loop when you first find a grapple point in range and any time you find a closer grapple point.

   2. A float named ClosestDistSq. Instead of using square root calculations to find the distance to each grapple point in the array, you’ll use the distance squared. Each time you find a new closest grapple point in the array, you’ll update ClosestDistSq. Since you haven’t found a grapple point yet, use the MaxGrappleRange as the closest distance. You’ll compare the distance to each element in the array with ClosestDistSq.

   C++

       AActor* ClosestGrapple = nullptr;
       float ClosestDistSq = MaxGrappleRange * MaxGrappleRange;
   

   Copy full snippet(2 lines long)

Check all Grapple Points

To loop through all grapple points and check each for distance and line of sight, follow these steps:

1. Add a for loop that loops through each element in the AActor* grapple point array.

   C++

    for (AActor* GrapplePoint : GrapplePoints)
       {
   

   Copy full snippet(2 lines long)

2. Inside the loop, first check that the GrapplePoint element is valid. If it’s not valid, skip that iteration of the loop.

3. Just like with BP_GrapplePoint, you’ll need to calculate the dot product between the direction the player is facing and the direction from the player to the grapple point:

   1. Declare a const FVector to subtract the player’s location from the GrapplePoint’s location and then get the safe normal of the result.

      C++

      const FVector ToGrapplePoint = (GrapplePoint->GetActorLocation() - OwnerLoc).GetSafeNormal();

      Copy full snippet(1 line long)

   2. Use FVector::DotProduct() to calculate the dot product between Forward and ToGrapplePoint and save the result.

      C++

      const float Dot = FVector::DotProduct(Forward, ToGrapplePoint);

      Copy full snippet(1 line long)

4. Get the FVector::DistSquared() from OwnerLoc to this GrapplePoint.

   C++

   const float DistSq = FVector::DistSquared(OwnerLoc, GrapplePoint->GetActorLocation());

   Copy full snippet(1 line long)

5. Move to the next iteration of the loop if either:

   1. Dot (the alignment of player camera versus grapple point) is less than the DotProductThreshold.

   2. The distance to this grapple point is greater than the distance to the closest grapple point you’ve found so far.

   C++

   // Dot product closer to 1 = looking directly at grappling point. 0.87 -> Arbitrary number that is more forgiving        
   if (Dot < DotProductThreshold) continue; 
   if (DistSq > ClosestDistSq) continue;
   

   Copy full snippet(3 lines long)

6. Check if there are any obstructing objects like walls between the player and the grapple point:

   1. Declare a FHitResult named Hit to store line trace hit result information.

      FHitResult is a struct in UE that stores information about the result of a collision query, including the Actor or component that was hit and where you hit it.

   2. Declare a FCollisionQueryParams struct instance named Params to configure how the line trace behaves.

      The FCollisionQueryParams constructor takes the following arguments:

      FCollisionQueryParams Params(TraceName, UseComplexCollision, IgnoreActor)

      • TraceName: Add a debug tag with SCENE_QUERY_STAT(GrappleTrace).

      • UseComplexCollision: Use true for more precise collision detection because grappling requires additional accuracy.

      • IgnoreActor: Use Owner to make the line trace ignore the character when performing the trace.

      C++

              // Line trace to check whether there's a wall
              FHitResult Hit;
              FCollisionQueryParams Params(SCENE_QUERY_STAT(GrappleTrace), true, Owner);
      

      Copy full snippet(3 lines long)

   3. Perform a line trace from the character’s location to this grapple point’s location.

      Use GetWorld()->LineTraceSingleByChannel() passing:

      • Hit: The FHitResult to store hit result information in:

      • OwnerLoc: The start of the trace

      • GrapplePoint->GetActorLocation(): The end of the trace.

      • The collision channel for the trace: ECC_Visibility

        Use ECC_Visibility for line-of-sight camera checks.

      • A FCollisionQueryParams object: Params

      Save the result in a bool named bHit.

      C++

           bool bHit = GetWorld()->LineTraceSingleByChannel(
                  Hit,
                  OwnerLoc,
                  GrapplePoint->GetActorLocation(),
                  ECC_Visibility,
                  Params
              );
      

      Copy full snippet(7 lines long)

7. Add an if statement that checks if the line trace hit an object and that object is not this grapple point:

   1. If true, skip to the next loop iteration.

   2. If false, that means you’ve found a close grapple point that is visible. Update ClosestDistSq to this grapple point’s distance and update ClosestGrapple to this grapple point Actor.

   C++

    if (bHit && Hit.GetActor() != GrapplePoint)
           {
               // Something blocking (wall)
               continue;
           }
   
           // Grapple Point valid and visible
           ClosestDistSq = DistSq;
           ClosestGrapple = GrapplePoint;
   

   Copy full snippet(9 lines long)

8. If no grapple points are found in range, ClosestGrapple is still null after the loop finishes. Add an if statement to check if ClosestGrapple has a value:

   1. If it has a value, set the TargetLocation and TargetGrapple output variables, and return true. You’ll use these variables later in Blueprints to queue the Grappling Hook Movement Mode.

   2. Otherwise, return false.

   C++

    if (ClosestGrapple)
       {
           TargetLocation = ClosestGrapple->GetActorLocation();
           TargetGrapple = ClosestGrapple;
           return true;
       }
   
       return false;

   Copy full snippet(8 lines long)

9. Save and compile your code.

Now, the FindClosestGrappleTarget() function returns false if there are no targets in range, if the player is not looking at any targets, or if there’s a wall blocking all potential targets. 

Your finished GrapplingHookActorComponent.cpp file should look like this:

// Copyright Epic Games, Inc. All Rights Reserved.

#include "GrapplingHookActorComponent.h"
#include "Camera/CameraComponent.h"
#include "Kismet/GameplayStatics.h"

// Sets default values for this component's properties
UGrapplingHookActorComponent::UGrapplingHookActorComponent()
{
	// Set this component to be initialized when the game starts, and to be ticked every frame. 

Create the Grappling Hook Movement Mode

The Grappling Hook Movement Mode is where the actual movement code resides, and it gets activated when the Grappling Hook component returns a valid grapple point and target location. 

When active, this Movement Mode interpolates the location of the player to the target location, and then launches them in the direction of the movement. It also attaches the player’s Cable Component to the grapple point instance while grappling.  

To see how the default Walking and Falling Movement Modes are implemented, you can find their classes in /All/EngineData/Plugins/Classes_Mover/Mover/Public/DefaultMovementSet/Modes. They provide a base template to work with when implementing custom movement modes. In the Grappling Hook Movement Mode, the player won’t have much control over the player character,  so it functions somewhat similar to the Falling Movement Mode.

Create and Set Up a New Movement Mode Class

First, create the Movement Mode class and add the necessary includes, forward declarations, and overrides.

To set up a new Movement Mode class, follow these steps:

1. In Unreal Editor, go to Tools > New C++ Class.

2. In the Choose Parent Class window, click All Classes, search for BaseMovementMode, and select that as the parent class.

   

3. Name the class GrapplingHookMovementMode and click Create Class.

4. In the header file, add an include for CableComponent:

   C++

   #include "CoreMinimal.h"
   #include "MovementMode.h"
   #include "CableComponent.h"
   #include "GrapplingHookMovementMode.generated.h"
   

   Copy full snippet(4 lines long)

    The Cable Component attaches itself to the grapple point when grappling.

5. To support the Movement Mode functionality, include a forward declaration for Legacy Movement Settings:

   C++

   class UCommonLegacyMovementSettings;
   

   Copy full snippet(1 line long)

   Movement Modes use Common Legacy Movement Settings to access shared movement configuration values, such as acceleration, gravity, and movement speed.

6. In the class declaration, add Blueprintable and BlueprintType specifiers to the UClass macro.

7. Add a public section and declare a constructor.

   C++

   UCLASS(Blueprintable, BlueprintType)
   class PARKOURGAME_API UGrapplingHookMovementMode : public UBaseMovementMode
   {
   	GENERATED_BODY()
   	
   public:
   UGrapplingHookMovementMode(const FObjectInitializer& ObjectInitializer);
   };
   

   Copy full snippet(8 lines long)

   Tip: The constructor includes FObjectInitializer so the Movement Mode can register shared movement settings during initialization.

8. Override BaseMovementMode’s core Movement Mode functions:

   • GenerateMove_Implementation: Builds the movement intent (what movement should happen).

   • SimulationTick_Implementation: Applies the actual movement simulation each frame.

   C++

   public:
   UGrapplingHookMovementMode(const FObjectInitializer& ObjectInitializer);	
   
   virtual void GenerateMove_Implementation(const FMoverSimContext& SimContext, const FMoverTickStartData& StartState, const FMoverTimeStep& TimeStep, FProposedMove& OutProposedMove) const override;
   
   	virtual void SimulationTick_Implementation(const FSimulationTickParams& Params, FMoverTickEndData& OutputState) override;
   

   Copy full snippet(6 lines long)

   In this Movement Mode, Simulation Tick will handle all movement since grappling input is only processed when the Movement Mode is activated, and no other input should affect the character when grappling.

   GenerateMove_Implementation isn’t used for movement here, but is still required because Mover expects Movement Modes to define their own generate-move step.

9. Add a protected section and declare the following properties and overrides:

   C++

   protected:
   	UPROPERTY()
   	TObjectPtr<const UCommonLegacyMovementSettings> CommonLegacySettings;
   
   	virtual void Deactivate(const FMoverEventContext& Context, FName NextModeName, const FMoverSimContext& SimContext) override;
   	virtual void OnRegistered(const FName ModeName, const FMoverSimContext& SimContext) override;
   	virtual void OnUnregistered(const FMoverSimContext& SimContext) override;
   

   Copy full snippet(7 lines long)

   The protected section of the Movement Mode’s header contains internal state and engine functions that are used by the Movement Mode.

10. In GrapplingHookMovementMode.cpp, add the following includes:

    C++

    #include "GrapplingHookMovementMode.h"
    #include "MoveLibrary/MovementUtils.h"
    #include "MoveLibrary/FloorQueryUtils.h"
    #include "MoverComponent.h"
    #include "DefaultMovementSet/Settings/CommonLegacyMovementSettings.h"
    #include "DefaultMovementSet/InstantMovementEffects/BasicInstantMovementEffects.h"
    
    #include UE_INLINE_GENERATED_CPP_BY_NAME(GrapplingHookMovementMode)
    

    Copy full snippet(8 lines long)

    UE_INLINE_GENERATED_CPP_BY_NAME ensures Unreal Engine includes the generated code for this class as part of this compilation unit. It’s a modern UE build pattern that manages .gen.cpp files for you.

11. Add the constructor for the Movement Mode.

    C++

    UGrapplingHookMovementMode::UGrapplingHookMovementMode(const FObjectInitializer& ObjectInitializer)
    	: Super(ObjectInitializer)
    {
    	SharedSettingsClasses.Add(UCommonLegacyMovementSettings::StaticClass());
    	GameplayTags.AddTag(Mover_IsOnGround);
    }
    

    Copy full snippet(6 lines long)

    The constructor initializes the Movement Mode by registering shared settings and adding default gameplay tags. Here, you are registering this movement mode as “grounded” in the Mover system for state checks. 

Implement GenerateMove

For your grappling Movement Mode, this function should retrieve the Pawn’s Mover Component, input data, current sync state, and delta time before any grapple-specific logic runs. GenerateMove runs every frame.

To implement the GenerateMove_Implementation override, follow these steps:

1. Implement the function and add the following standard set up for any Movement Mode:

   C++

   //Movement will be handled by simulation tick
   void UGrapplingHookMovementMode::GenerateMove_Implementation(const FMoverSimContext& SimContext, const FMoverTickStartData& StartState, const FMoverTimeStep& TimeStep, FProposedMove& OutProposedMove) const
   {
   	const UMoverComponent* MoverComp = GetMoverComponent();
   	const FCharacterDefaultInputs* CharacterInputs = StartState.InputCmd.InputCollection.FindDataByType<FCharacterDefaultInputs>();
   	const FMoverDefaultSyncState* StartingSyncState = StartState.SyncState.SyncStateCollection.FindDataByType<FMoverDefaultSyncState>();
   	check(StartingSyncState);
   
   	const float DeltaSeconds = TimeStep.StepMs * 0.001f;
   }
   

   Copy full snippet(10 lines long)

Add Standard Setup Code to SimulationTick

SimulationTick_Implementation is where movement is handled. To start implementing this function, you’ll first need to add the following block of code that sets up any type of Movement Mode:

void UGrapplingHookMovementMode::SimulationTick_Implementation(const FSimulationTickParams& Params, FMoverTickEndData& OutputState)
{
	/*
	// --- Standard Movement Mode Setup Code STARTS ---
	*/
	UMoverComponent* MoverComp = GetMoverComponent();
	const FMoverTickStartData& StartState = Params.StartState;
	// The component this Movement Mode is responsible for moving 
USceneComponent* UpdatedComponent = Params.MovingComps.UpdatedComponent.Get();
	UPrimitiveComponent* UpdatedPrimitive = Params.MovingComps.UpdatedPrimitive.Get();

This code gathers the standard Movement Mode context, validates required components, pulls the starting sync and input data, converts delta time, and prepares working variables for movement and orientation updates. You’ll use this block of code again when setting up your wall running Movement Mode in the next module of this tutorial series.

Set Up and Validate Grappling-Specific Properties

Next, in SimulationTick_Implementation, perform a one-time initialization of the class’ properties when the Movement Mode becomes active. This initialization sets some variables only once at the start of the movement.

Because of how the Movement Mode is queued in Blueprints, the first frame is evaluated by the SimulationTick function before the TargetLocation is initialized. Therefore, it’s useful to have a boolean tracking if TargetLocation has already been initialized.

To declare and initialize grappling-related properties and components, follow these steps:

1. In the header file, declare the following public variables:

   1. A bool to track if initialization has been completed:

      C++

      // Tracks if grapple setup has already run 
      bool bIsLocationInitialized = false;
      

      Copy full snippet(2 lines long)

   2. A UPROPERTY for the location of the target, the grapple point Actor at that target, and the character’s grapple Cable Component:

      C++

      // The location to move the character towards. Blueprints sets this to the target grapple point's location when switching to this Movement Mode.  
      UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Mover")
      FVector TargetLocation = FVector::ZeroVector; 
      
      // The BP_GrapplePoint Actor to attach the cable component to. Blueprints sets this when switching to this movement.
      UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Mover")
      AActor* TargetGrapplePoint; 
      
      // The character's grapple cable component
      UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Grapple")
      
      Expand code Copy full snippet(11 lines long)

   3. Two FVectors for the character’s starting position and direction towards the grapple point.

      C++

      // The character's position when the grapple begins
      FVector StartLocation = FVector(0, 0, 0);
      
      // Normalized direction from start location to grapple target
      FVector GrappleDirection = FVector(0, 0, 0);
      

      Copy full snippet(5 lines long)

   4. Two float values to control the speed and time of the grapple movement.

      C++

      // The character's travel speed (cm/s) while grappling
      UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Mover")
      float GrappleSpeed = 6000.f;   
      
      // Total time of the grapple movement (or the time it takes for the Alpha to go from 0 to 1).
      float TotalTime = 0.5f; 
      

      Copy full snippet(6 lines long)

   You won’t use TotalTime’s default value, but it’s best practice to set one to ensure the variable is initialized.

2. In the .cpp file, at the end of SimulationTick_Implementation, add an if statement to check if TargetLocation is set and not 0.

   C++

   void UGrapplingHookMovementMode::SimulationTick_Implementation(const FSimulationTickParams& Params, FMoverTickEndData& OutputState)
   {
   	/*
   	// --- Standard Movement Mode Setup Code STARTS ---
   	*/
   	UMoverComponent* MoverComp = GetMoverComponent();
   	const FMoverTickStartData& StartState = Params.StartState;
   	// The component this Movement Mode is responsible for moving 
   	USceneComponent* UpdatedComponent = Params.MovingComps.UpdatedComponent.Get();
   	UPrimitiveComponent* UpdatedPrimitive = Params.MovingComps.UpdatedPrimitive.Get();
   
   Expand code Copy full snippet(75 lines long)

   When the Movement Mode is queued, TargetLocation and similar variables won’t be set in the first frame, so make sure values are set before changing movement.

3. Add another if statement to handle one-time variable initialization when the Movement Mode is first activated. 

   C++

   if (TargetLocation != FVector::ZeroVector)
   {
   	// Initialize grapple state, storing start location and direction to the target
   	if (!bIsLocationInitialized)
   	{	
   	}
   }
   

   Copy full snippet(7 lines long)

4. Set the player’s StartLocation by calling GetActorLocation() on the Mover Component’s owner.

5. Set the player’s GrappleCable by calling FindComponentByClass<UCableComponent>().

   C++

   if (TargetLocation != FVector::ZeroVector)
   {
   	// Initialize grapple state, storing start location and direction to the target
   	if (!bIsLocationInitialized)
   	{	
   		StartLocation = MoverComp->GetOwner()->GetActorLocation();
   		GrappleCable = MoverComp->GetOwner()->FindComponentByClass<UCableComponent>();
   
   	}
   }
   

   Copy full snippet(10 lines long)

6. In a new if statement, check that the GrappleCable is valid.

   C++

   if (TargetLocation != FVector::ZeroVector)
   {
   	// Initialize grapple state, storing start location and direction to the target
   	if (!bIsLocationInitialized)
   	{	
   		StartLocation = MoverComp->GetOwner()->GetActorLocation();
   		GrappleCable = MoverComp->GetOwner()->FindComponentByClass<UCableComponent>();
   
   		// --- New Code Start ---
   		if (!GrappleCable)
   
   Expand code Copy full snippet(18 lines long)

7. Add another if statement to check that the TargetGrapplePoint is valid. 

   C++

   if (TargetLocation != FVector::ZeroVector)
   {
   	// Initialize grapple state, storing start location and direction to the target
   	if (!bIsLocationInitialized)
   	{	
   		StartLocation = MoverComp->GetOwner()->GetActorLocation();
   		GrappleCable = MoverComp->GetOwner()->FindComponentByClass<UCableComponent>();
   
   		if (!GrappleCable)
   		{
   
   Expand code Copy full snippet(25 lines long)

8. Use a Time = Distance/Speed calculation to calculate the TotalTime. Add 0.1 to the result as a minimum duration and ensure the grapple always takes a small amount of time to prevent snapping.

   C++

   if (!TargetGrapplePoint)
   {
   	if (GEngine) GEngine->AddOnScreenDebugMessage(-1, 2.f, FColor::Red, TEXT("No valid grapple target found!"));
   	return;
   }
   
   // --- New Code Start ---
   TotalTime = 0.1f + (TargetLocation - StartLocation).Size() / GrappleSpeed;
   // --- New Code End ---
   

   Copy full snippet(9 lines long)

9. Set GrappleDirection to the safe normal of the vector from StartLocation to TargetLocation.

   C++

   TotalTime = 0.1f + (TargetLocation - StartLocation).Size() / GrappleSpeed;
   
   // --- New Code Start ---
   GrappleDirection = (TargetLocation - StartLocation).GetSafeNormal();
   // --- New Code End ---
   

   Copy full snippet(5 lines long)

10. Finish setting up the GrappleCable so the player can see the cable attaching to the grapple point:

    1. Set the visibility of GrappleCable to true.

    2. Call SetAttachEndToComponent on the GrappleCable to set the TargetGrapplePoint’s root component as the attachment point.

    C++

    TotalTime = 0.1f + (TargetLocation - StartLocation).Size() / GrappleSpeed;
    
    GrappleDirection = (TargetLocation - StartLocation).GetSafeNormal();
    
    // --- New Code Start ---
    GrappleCable->SetVisibility(true);
    GrappleCable->SetAttachEndToComponent(TargetGrapplePoint->GetRootComponent());
    // --- New Code End ---
    

    Copy full snippet(8 lines long)

11. You’ve finished setting up and validating grappling variables, so at the end of if (!bIsLocationInitialized), set bIsLocationInitialized to true so this code only runs once when the player first enters the Grappling Hook Movement Mode.

    C++

    if (TargetLocation != FVector::ZeroVector)
    {
    	// Initialize grapple state, storing start location and direction to the target
    	if (!bIsLocationInitialized)
    	{	
    		StartLocation = MoverComp->GetOwner()->GetActorLocation();
    		GrappleCable = MoverComp->GetOwner()->FindComponentByClass<UCableComponent>();
    
    		if (!GrappleCable)
    		{
    
    Expand code Copy full snippet(32 lines long)

Implement Grappling-Specific Movement Logic

To advance and track the grapple movement, follow these steps:

1. In the header file, in the public section, declare two more float variables:

   C++

   // How long the current grapple movement has been active
   float ElapsedTime = 0.f;
   
   // Velocity (cm/s) applied after grappling is complete
   UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Mover")
   float GrappleExitVelocity = 2500.f; 
   

   Copy full snippet(6 lines long)

2. In the .cpp file, outside of the if (!bIsLocationInitialized) statement, update ElapsedTime, adding DeltaSeconds (the time that has passed since the last frame).

3. You’ll use linear interpolation (lerp) to move the player from their start location to the grapple point over time. Declare a float named Alpha to represent the blend value of the Lerp. The player is at their start position when the time is 0, and at the grapple point when the time is TotalTime.

   C++

   if (TargetLocation != FVector::ZeroVector)
   {
   	// Initialize grapple state, storing start location and direction to the target
   	if (!bIsLocationInitialized)
   	{	
   		StartLocation = MoverComp->GetOwner()->GetActorLocation();
   		GrappleCable = MoverComp->GetOwner()->FindComponentByClass<UCableComponent>();
   
   		if (!GrappleCable)
   		{
   
   Expand code Copy full snippet(36 lines long)

4. Declare an ^FVector named LocationToPlaceActor. Use the Lerp function from Unreal Engine’s FMath utility library to calculate where the player should be in this frame.

   C++

   // Lerping location based on Alpha (Elapsed Time over Total Time)
   ElapsedTime += DeltaSeconds;
   float Alpha = ElapsedTime / TotalTime;
   // --- New Code Start ---
   FVector LocationToPlaceActor = FMath::Lerp(StartLocation, TargetLocation, Alpha);
   // --- New Code End ---
   

   Copy full snippet(6 lines long)

5. The setup code at the beginning of SimulationTick declared a scene component named UpdatedComponent, which is the component the Movement Mode is responsible for moving (usually the Pawn’s root collision component).

   Call SetWorldLocation() on UpdatedComponent to move it to LocationToPlaceActor.

   C++

   // Lerping location based on Alpha (Elapsed Time over Total Time)
   ElapsedTime += DeltaSeconds;
   float Alpha = ElapsedTime / TotalTime;
   FVector LocationToPlaceActor = FMath::Lerp(StartLocation, TargetLocation, Alpha);
   // --- New Code Start ---
   UpdatedComponent->SetWorldLocation(LocationToPlaceActor);
   // --- New Code End ---
   

   Copy full snippet(7 lines long)

6. Set UpdatedComponent’s ComponentVelocity to GrappleDirection * GrappleExitVelocity.

   C++

   // Lerping location based on Alpha (Elapsed Time over Total Time)
   ElapsedTime += DeltaSeconds;
   float Alpha = ElapsedTime / TotalTime;
   FVector LocationToPlaceActor = FMath::Lerp(StartLocation, TargetLocation, Alpha);
   UpdatedComponent->SetWorldLocation(LocationToPlaceActor);
   		
   // --- New Code Start ---
   UpdatedComponent->ComponentVelocity = GrappleDirection * GrappleExitVelocity;
   // --- New Code End ---
   

   Copy full snippet(9 lines long)

7. Now that you’ve moved the component, you have to report that movement to Mover using the OutputSyncState. The position, rotation and velocity of UpdatedComponent and OutputSyncState must match so the visual component and the Mover system’s internal state stay in sync.

   Call OutputSyncState.SetTransforms_WorldSpace, which has the following mandatory arguments:

   OutputSyncState.SetTransforms_WorldSpace(FVector Location, FRotator Orientation, FVector WorldVelocity, FVector AngularVelocity, UPrimitiveComponent *RelativeBase = (UPrimitiveComponent*)nullptr)

   C++

   // Lerping location based on Alpha (Elapsed Time over Total Time)
   ElapsedTime += DeltaSeconds;
   float Alpha = ElapsedTime / TotalTime;
   FVector LocationToPlaceActor = FMath::Lerp(StartLocation, TargetLocation, Alpha);
   UpdatedComponent->SetWorldLocation(LocationToPlaceActor);
   		
   UpdatedComponent->ComponentVelocity = GrappleDirection * GrappleExitVelocity;
   
   // --- New Code Start ---
   OutputSyncState.SetTransforms_WorldSpace(LocationToPlaceActor,
   
   Expand code Copy full snippet(13 lines long)

   For multiplayer games, OutputSyncState keeps the server synced with clients.

End the Grappling Movement

To finish and transition out of the grapple movement when the player reaches the target, follow these steps:

1. After moving the player and updating OutputSyncState, check if the player has reached the grapple point. Add an if statement that checks if Alpha is close to 1.

   C++

   // Lerping location based on Alpha (Elapsed time over Total Time)
   ElapsedTime += DeltaSeconds;
   float Alpha = ElapsedTime / TotalTime;
   FVector LocationToPlaceActor = FMath::Lerp(StartLocation, TargetLocation, Alpha);
   UpdatedComponent->SetWorldLocation(LocationToPlaceActor);
   		
   UpdatedComponent->ComponentVelocity = GrappleDirection * GrappleExitVelocity;
   
   OutputSyncState.SetTransforms_WorldSpace(LocationToPlaceActor,
   	UpdatedComponent->GetComponentRotation(),
   
   Expand code Copy full snippet(19 lines long)

2. Inside the if statement, reset the following variables:

   • ElapsedTime

   • bIsLocationInitialized

   • TargetLocation

3. Set the visibility of GrappleCable to false to hide the cable in game when the player has finished using it. You only want the cable to be visible when using the grappling hook.

   Normally, you’d also want to stop cable simulations and updates when it isn’t visible to reduce unnecessary calculations.

4. Queue the Falling Movement Mode.

   C++

   //If Alpha is close to 1, Queue "Falling" Movement Mode and reset variables.
   if (Alpha >= 0.99f) 
   {
   	// --- New Code Start ---
   ElapsedTime = 0.f;
   	bIsLocationInitialized = false;
   	TargetLocation = FVector::ZeroVector;
   	GrappleCable->SetVisibility(false);
   	MoverComp->QueueNextMode("Falling", false);
   	// --- New Code End ---
   
   Expand code Copy full snippet(11 lines long)

Your finished SimulationTick_Implementation function should look like this:

void UGrapplingHookMovementMode::SimulationTick_Implementation(const FSimulationTickParams& Params, FMoverTickEndData& OutputState)
{
	/*
	// --- Standard Movement Mode Setup Code STARTS ---
	*/
	UMoverComponent* MoverComp = GetMoverComponent();
	const FMoverTickStartData& StartState = Params.StartState;
	// The component this Movement Mode is responsible for moving 
	USceneComponent* UpdatedComponent = Params.MovingComps.UpdatedComponent.Get();
	UPrimitiveComponent* UpdatedPrimitive = Params.MovingComps.UpdatedPrimitive.Get();

Implement Deactivate()

Deactivate() runs when the Movement Mode stops being active, or when the player switches to another Movement Mode. Use this function to clean up any state or references the Movement Mode was using.

If the game or player interrupts the grappling movement, you want to perform the same variable cleanup you did when the grapple movement finished successfully. 

To implement Deactivate(), follow these steps:

1. Add the function header and call Super::Deactivate(); inside the function.

2. Copy and paste the same four properties you reset at the end of SimulationTick.

   C++

   // Reset variables when Movement Mode stops being active
   void UGrapplingHookMovementMode::Deactivate(const FMoverEventContext& Context, FName NextModeName, const FMoverSimContext& SimContext) // Same thing as if Alpha gets close to 1 - Cleaning references and resetting variables
   {
   	Super::Deactivate(Context, NextModeName, SimContext);
   	
   TargetLocation = FVector::ZeroVector;
   	ElapsedTime = 0.f;
   	GrappleCable->SetVisibility(false);
   	bIsLocationInitialized = false;
   }
   

   Copy full snippet(10 lines long)

Implement OnRegistered() and OnUnregistered()

OnRegistered() runs once when the Movement Mode is connected to the Mover system and ready to use. Use it to perform one-time set up of references like shared settings. 

To implement OnRegistered(), follow these steps:

1. Add the function header and call Super::OnRegistered(ModeName) inside the function.

2. Get a reference to CommonLegacyMovementSettings.

3. Get a reference to the player character’s MoverComponent.

   C++

   void UGrapplingHookMovementMode::OnRegistered(const FName ModeName, const FMoverSimContext& SimContext)
   {
   	Super::OnRegistered(ModeName, SimContext);
   
   	CommonLegacySettings = GetMoverComponent()->FindSharedSettings<UCommonLegacyMovementSettings>();
   		ensureMsgf(CommonLegacySettings, TEXT("Failed to find instance of CommonLegacyMovementSettings on %s. Movement may not function properly."), *GetPathNameSafe(this));
   }
   

   Copy full snippet(7 lines long)

OnUnregistered() runs when the Movement Mode is removed from the MoverComponent, such as when the MoverComponent is destroyed. Use it for final cleanup, such as unbinding events or clearing external references. For example, if this Movement Mode had subscribed to an event on another component, you would unbind it here. The grappling Movement Mode doesn’t require any cleanup here, but this is an example to show the full Movement Mode lifecycle. 

To implement OnUnregistered(), follow these steps:

1. Call the parent function.

2. Reset any references set in OnRegistered() (like CommonLegacySettings).

   C++

   void UGrapplingHookMovementMode::OnUnregistered(const FMoverSimContext& SimContext)
   {
   	CommonLegacySettings = nullptr;
   	Super::OnUnregistered(SimContext);
   
   }
   

   Copy full snippet(6 lines long)

3. Compile and save your code.

Complete Code

Your finished GrapplingHookMovementMode.h file should look like this:

// Copyright Epic Games, Inc. All Rights Reserved.

#pragma once

#include "CoreMinimal.h"
#include "MovementMode.h"
#include "CableComponent.h"
#include "GrapplingHookMovementMode.generated.h"

class UCommonLegacyMovementSettings;

Your finished GrapplingHookMovementMode.cpp file should look like this:

// Copyright Epic Games, Inc. All Rights Reserved.


#include "GrapplingHookMovementMode.h"
#include "MoveLibrary/MovementUtils.h"
#include "MoveLibrary/FloorQueryUtils.h"
#include "MoverComponent.h"
#include "DefaultMovementSet/Settings/CommonLegacyMovementSettings.h"
#include "DefaultMovementSet/InstantMovementEffects/BasicInstantMovementEffects.h"

Add Grapple to the Character Blueprint

Now that you’ve implemented the movement behavior, you can add the Movement Mode to BP_ParkourPawn.

Add the Movement Mode

To add the grappling Movement Mode to the player character, follow these steps:

1. In Unreal Editor, open your Pawn Blueprint.

2. In the Components panel, click Add to add a GrapplingHookActor component.

3. Select the ExtendedCharacterMoverComponent.

4. In the Details panel, in the Mover section, expand Movement Modes.

5. Click (+) next to the Movement Modes category heading to add another map element.

6. Enter GrapplingHook as the mode name. You’ll reference this name in Event Graph logic.

7. In the new map element’s dropdown list, select Grappling Hook Movement Mode.

   

Connect the Grapple Point Class

Your character’s Grappling Hook Actor Component handles finding grapple targets. When you implemented this Actor Component, you exposed a Grapple Point Class property to Blueprints to tell the component what type of Actor and level object to use for grappling.

To tell the Grappling Hook Actor Component to search for BP_GrapplePoint level objects, follow these steps:

1. In the Components panel, select GrapplingHookActor.

2. In the Details panel, in the Grapple section, for Grapple Point Class, select BP_GrapplePoint.

Add the Cable Component

To add the Cable Component to the character, follow these steps:

1. In the Components panel, select the SK_Mannequin component.

2. Click + Add, and select Cable. Name it GrapplingCable.

   

3. With the Cable Component selected, in the Details panel, in the Sockets section, for Parent Socket, click the folder search icon and select the hand_r bone.

   

4. In the Cable section, set:

   1. Cable Length to 300.

   2. Num Segments to 5.

   3. Cable > Advanced > Skip Cable Update when Not Visible to True.

5. In the Cable Rendering section, set Cable Width to 8.

   

6. In the Rendering section, turn off Visible by default.

Queue the Movement Mode

The input action logic in the Pawn’s event graph should search for a valid grapple target and queue the GrapplingHookMovementMode if FindClosestGrappleTarget() finds a target.

To queue the Movement Mode, follow these steps:

1. Go to the Pawn’s EventGraph tab and go to the groups of nodes that capture various movement inputs.

2. Right-click in the empty area of the graph, search for IA_GrapplingHook, and create a new IA_GrapplingHook node (in the Enhanced Action Event category).

3. Click the arrow at the bottom of the node to see more pin options. From the Started exec pin, create a Branch node. You only want to queue grappling if there is a valid grapple point in range.

   

4. Drag off the Condition pin and add a Find Closest Grapple Target function node. Unreal Engine automatically adds the GrapplingHookActor component as the Target.

   You created FindClosestGrappleTarget() in the GrapplingHookActor component class.

5. Drag off the Branch node’s True pin and add a Queue Next Movement Mode node. Unreal Engine automatically adds the Pawn’s Mover Component as the Target.

6. For the Desired Mode Name pin, enter GrapplingHook. This must match the name you entered in the Movement Modes list in the Mover Component’s Details panel.

   

7. Save and compile the Blueprint.

Send Grapple Point Information to the Movement Mode

Your game can now queue the new Movement Mode, but before the first frame of the Movement Mode runs, you’ll need to tell it about the grapple target. Use the OnMovementModeChanged event to set up a Movement Mode instance with the information it needs to perform the movement behavior.

To execute logic when the Grappling Hook Movement Mode becomes active, follow these steps:

1. In the My Blueprint panel, in the Graphs section, expand EventGraph and double-click Event OnMovementModeChanged_Event to go to that node in the graph.

2. Delete all nodes connected to the event node.

   

3. Drag off the event node’s exec pin and add a Switch on Name node.

4. Set up the Switch on Name node to have an output for your Grappling Hook movement mode:

   1. In the node, click Add pin.

   2. In the Details panel, uncheck Has Default Pin.

   3. Expand the Pin Names array and rename the first element to GrapplingHook.

      

   With a Switch on Name node, you can branch off to different configurations depending on which Movement Mode has activated. You’ll add a Wall Running option to this Switch in the next part of this tutorial series.

5. Connect the event’s New Movement Mode Name pin to the Switch node’s Selection pin.

Now that you know grappling is active, first get the character’s Grappling Hook Movement Mode object from the Mover Component so you can access that instance’s TargetLocation and TargetGrapplePoint variables. FindMovementModeByName returns a base class Movement Mode object, so you need to use a Cast To node on that object to treat it as a Grappling Hook Movement Mode object and access variables specific to that Movement Mode class.

To access the character’s Grappling Hook Movement Mode object, follow these steps:

1. Drag off the Switch node’s Grappling Hook pin and add a Cast To GrapplingHookMovementMode node.

2. To the left of the Cast To node, add a Find Movement Mode by Name function node (where the Target is your Extended Character Mover Component).

3. Set up the Find Movement Mode by Name node:

   1. Connect the Return Value to the Cast To node’s Object pin.

   2. For the Movement Mode Name, enter GrapplingHook.

   

To find the closest grapple target and send its information to the Movement Mode instance, follow these steps:

1. Below the Cast To node, add a Find Closest Grapple Target function node (where the target is GrapplingHookActor).

2. Right-click the Target Location pin and click Split Struct Pin.

   

   You’ll need to apply an offset to the location’s Z value to lower the character relative to the grapple point, so split the vector into three separate values.

3. Drag off the Cast To’s top exec pin and add a Set TargetLocation node (under Class > Grappling Hook Movement Mode in the node actions list).

4. Set up the Set TargetLocation node:

   1. Right-click the Target Location pin and select Split Struct Pin.

   2. Connect the Cast To node’s As Grappling Hook Movement Mode pin to the Set node’s Target pin.

   3. Connect the Find Closest Grapple Target node’s Target Location X and Y pins to the corresponding pins in the Set node.

      

   4. Connect the function node’s Target Location Z pin to a new Subtract node, and connect the result to the Set node’s Z pin.

   5. In the My Blueprint panel, create a new float variable named GrappleZAxisOffset. Compile the Blueprint, set its default value to 100, and drag the variable onto the Subtract node’s second input pin.

      

      This offset should lower the target location the character is flying towards so that their head lines up with the grapple point Actor instead of the middle of their body.

5. Drag off the Set Target Location node’s exec output pin and add a Set TargetGrapplePoint node.

6. Set up the new Set TargetGrapplePoint node:

   1. Connect the Cast To node’s As Grappling Hook Movement Mode pin to the new Set node’s Target pin.

   2. Connect the Find Closest Grapple Target node’s Target Grapple output to the Set node.

      

7. Save and compile the Blueprint.

The final OnMovementModeChanged_Event logic should look like this:

Test the Grapple Hook Movement

Play your game, aim the camera at your grapple point, and press G to test the grappling movement. You may need to adjust the size of the floor or height of your walls to keep the character in the level. 

Watch how the cable attaches to the grapple point. You may need to open BP_GrapplePoint, select the mesh component, and translate the mesh up or down the X axis until the grapple cable always hits the mesh. For example, in the sample level shown in this tutorial, the grapple point’s mesh has a Location transform of (60, 0, 0). 

As you test the grappling movement, also pay attention to how the character moves towards the grapple point. Check that the Z offset lines the cable up with the grapple point, and pay attention to the feel of the grappling speed and distance.

Adjust Grapple Hook Behavior

To adjust grapple speed and exit velocity, select your Pawn’s ExtendedCharacterMoverComponent and expand the GrappleHook Movement Mode properties.

Next Up

Next, you’ll create a Wall Running Component and Movement Mode that performs line traces to the right and left of the character to search for walls, checks if the player is approaching a wall at an appropriate speed, and then moves the player along the wall.

• 

  Wall Running Movement Mode

  Build a Movement Mode in C++ that gives a character the ability to run along walls and jump from wall to wall.