Puzzles: Moving Platforms

In this tutorial, you’ll create logic to power a moving platform, and activate it with the gameplay objects you built in Puzzles: Switches and Cubes. You’ll also incorporate the game mechanic time into your puzzle.

By using a modular workflow, you’ll be able to modify the platform's scale, movement, destination, and speed from the viewport. You’ll also be able to choose which platform any switch activates in a single click. 

With this flexibility, you can make changes to your level and test its functionality on the fly as you design. Efficient and flexible design choices improve the speed and resilience of your development pipeline.

Before You Begin

This tutorial assumes you already have an understanding of the following topics, which are covered in the previous sections of Design a Puzzle Adventure:

• Materials

• Blueprints

• Variables

• Blueprint Interfaces

• Play-In-Editor mode

You’ll need the following assets created in Create a Key and Puzzles: Switches and Cubes:

• BP_Switch

• BP_Cube

• BP_Key

• BPI_Interaction

• M_BasicColor

• M_EmissiveColor

• M_BasicColor_Blue

Create a Moving Platform

By learning how to create a moving platform and activate it with a switch, you can design simple functionality such as transporting a player across a level. The switch, cube, and platform can be combined to create complex functionality such as an entire platforming puzzle — like the one we provide at the end of this tutorial.

To keep your workflow modular, you’ll begin by creating a material instance and a Blueprint class for the platform.

Create a Material Instance

To create a material instance for the platform, follow these steps:

1. In the Content Browser, in AdventureGame > Designer > Materials, right-click M_BasicColor and select Create Material Instance.

2. Name the instance M_BasicColor_Orange. Double-click the instance to open it in the Material Editor.

3. Expand Global Vector Parameter Values, and enable Color to override it.

4. Set the Color parameter to Hex sRGB value F76E00FF.

   

5. Save the instance and close it.

Your Materials folder should now look like this:

Set Up a Blueprint Class

To create a Blueprint class for the platform, follow these steps:

1. In the Content Browser, navigate to AdventureGame > Designer > Blueprints and create a new folder called Platforms.

2. Inside the Platforms folder, right-click and create a new Blueprint Class.

3. In the Pick Parent Class dialog, select Actor and name the new Blueprint BP_Platform.

4. Double-click it to open BP_Platform in the Blueprint Editor.

5. In the Components tab, create a static mesh by clicking Add, search for cube, and select it.

6. Name the mesh Platform.

   

7. In the Details panel, under the Materials heading, set Element 0 to M_BasicColor_Orange.

   

To make your platform’s scale quickly customizable from within the Level Editor and make platforms of different sizes, you can use an editable variable:

1. In the My Blueprint tab, navigate to the Variables heading. Click the + button to create a variable and name it PlatformScale.

2. Set its pin type to Vector and click the eye icon so the eye is open.

   

3. In the Details panel, next to Category, add it to the Setup category.

4. Compile your Blueprint, then set the Default Value of PlatformScale to 2, 2, 0.1.

   

5. In the Construction Script graph, drag off the Construction Script node’s Exec pin and create Set World Scale 3D (Platform).

   

6. Drag off the New Scale pin on the Set World Scale 3D node and create a Get PlatformScale node. This applies new Scale values to the Platform mesh component.

   

7.   Save and Compile.

Your Construction Script graph should now look like this:

If you go back to the blueprint’s Viewport tab, you’ll see the construction script applied to the platform’s new scale values.

From the Content Browser, drag an instance of your platform into your level, or into Room 1 if you’re following along with our provided level. For this tutorial, make sure you also have an instance of BP_Switch and BP_Cube in the level:

Build with Logic

When an object overlaps the switch, the platform should move back and forth between two locations. Before you begin building, let’s draft the logic that powers this interaction by answering the questions: what needs to happen to who — and when?

Here is a breakdown of the platform's logic:

If BP_Platform is active, then:

• If BP_Platform is at its start location, move forward to its end location, and wait for 2 seconds.

• If BP_Platform is at its end location, move backward to its start location, and wait for 2 seconds.

If BP_Platform is not active, then BP_Platform stops.

The reason for designating wait time is to allow the player time to get onto (or push something onto) the platform. You can scale the wait time depending on how difficult you want this gameplay task to be. Later on in this tutorial, you’ll use time to set the platform’s speed, which can also affect difficulty.

Since you’ve already created BP_Platform, you need a boolean to determine if it’s active or inactive.

To create a boolean, follow these steps:

1. In the My Blueprint tab of BP_Platform, click the + button to create a new variable and name it Active.

2. Set its pin type to Boolean and click the eye icon so it’s open.

   

3. In the Details panel, change the Category to Setup.

4. Compile your Blueprint and verify that the Default Value of Active has a checkmark (true).

   

Next, you’ll define locations for the platform to move between.

Define Locations

Your drafted logic states that the platform requires two locations:

• Start location

• End location

To keep your work modular, you’ll define the start location by referencing the platform's instance. You’ll define the end location by referencing a target point actor.

You’ll also need vectors to store the coordinate data from the platform instance and the target point actor, and implement it within BP_Platform:

To set up your variables, follow these steps:

1. In the My Blueprint tab, click the + button twice to create two new variables.

2. Name the variables  StartLocation and EndLocation.

3. Set the pin types to Vector.

4. Create a variable called TargetPoint and set the pin type to Target Point (Object Reference). This variable type is used to reference target point actors within Blueprints.

5. With the TargetPoint variable selected, navigate to the Details panel. Change the Category to Setup and add a check to the checkbox for Instance Editable.

Your variable list should now look like this:

With your variables created, you can add logic:

1. Navigate to the EventGraph and delete the Event ActorBeginOverlap and Event Tick nodes. You won't need them. Keep Event BeginPlay.

2. From the Exec pin of the Event BeginPlay node, drag out and create Set StartLocation.

   

3. From the Start Location pin, drag out and create Get Actor Location. Verify that the Target field is set to Self.

   

4. From the Exec pin of Set StartLocation, drag out and create Set EndLocation.

   

5. From the End Location Vector pin, drag out and create Get Actor Location.

6. From the Target pin of Get Actor Location, drag out and create Get TargetPoint.

   

7. Save and Compile.

  Your EventGraph should now look like this:

Now you can create a target point actor in your level for the Blueprint to reference:

1. From the editor’s main toolbar, click the Add button.

2. Search for target point and select it to create one in your level.

   

3. Move the target point to where you want the platform to end up. To follow along in the sample level, set the target point’s Location to -6200, 570, -5.5 (at the bottom of Room 1).

4. In the viewport, select the instance of BP_Platform and move it where you want the platform to start from.

5. With BP_Platform selected, in the Setup section of the Details panel next to Target Point, search for the instance of Target Point in your level (or use the eyedropper to select it in the viewport).

   

Next, you’ll build the platform's movement.

Build Movement

Your drafted logic requires the platform to move in four ways: 

• Move forward

• Wait

• Move backward

• Stop

To signal the events forward, backward, and stop, you’ll create custom events. The wait event can be created using a variable, later on.

To create custom events, follow these steps:

1. In BP_Platform’s EventGraph, right-click and create Add Custom Event.

2. Name the new node evMoveForward. You should see the event appear under the EventGraph heading in the My Blueprint tab.

3. Create two more custom events. Name them evMoveBackward and evStop.

   

4. Since you only want the platform to move if the Active boolean is true, drag out from the Exec pin on the Set End Location node and create a Branch node.

   

5. On the Branch node, drag out from the Condition pin and create Get Active.

   

6. From the True pin of the Branch node, drag out and create EvMoveForward to trigger that event.

   

7. Save and Compile.

Your EventGraph should now look like this:

If you test your platform in PIE mode, the platform won't do anything. This is because custom events only signal an event; they need further logic to describe the platform’s movement.

Create Forward Movement

To power your custom events, you’ll use a Timeline node. Within a timeline, you can create two keyframes that represent the platform’s start and end locations.

To create a timeline, follow these steps:

1. Right-click in the EventGraph, search for and create Add Timeline.

   Make sure you don’t select Add Timeline Component.

2. Name the timeline node TM_MovePlatform.

   When you created the timeline node, a TM_MovePlatform reference appears in the Components list of the My Blueprint panel. Similar to other components, you can use this reference in the graph to get or set its properties.

3. Connect the Exec pin from evMoveForward to the Play pin of TM_MovePlatform.

4. Connect the Exec pin from evStop to the Stop pin of TM_MovePlatform.

5. Connect the Exec pin from evMoveBackward to the Reverse pin.

   

6. Double-click on TM_MovePlatform to open the Timeline Editor. Your timeline is currently blank, so press the Track button and select Float Track as the track type.

   

7. Name this new track Alpha.

8. Set the Length of the track to 1.00. This is how many seconds the timeline plays from start to finish.

   

9. To add a keyframe, right-click in the timeline and select Add key to CurveFloat_0.

   

10. Set the keyframe’s Time and Value to 0.0.

11. Right-click the key and change the Key Interpolation to Auto. This adds easing to the graph curves; making your platform move slower at the beginning and end of its movement.

    

12. Add a second keyframe, but set the Time and Value to 1.0, and set the Key Interpolation to Auto.

13. Save and Compile.

Your Timeline should now look like this:

To create movement, you’ll instruct the platform to incrementally set itself a new location per each game frame, along a linear path, between the start and end locations. If you’re familiar with animation software, you can think of this as tweening. To do this, you’ll use a Lerp (linear interpolation) node.

To create a lerp and connect it to your existing logic, follow these steps:

1. Go back to the EventGraph tab. Drag from the Update pin of TM_MovePlatform and create Set World Location (Platform).

   

2. From the New Location pin of Set World Location, drag out and create Lerp (Vector).

   

3. From the A pin of the Lerp node, drag out and create Get StartLocation.

4. From the B pin of the Lerp node, drag out and create Get EndLocation.

   

5. To utilize the alpha you created in TM_MovePlatform, connect the Alpha pin of TM_MovePlatform to the Alpha pin of the Lerp.

   

6. Save, Compile, and close the Blueprint Editor.

Your EventGraph should now look like this:

Now you have enough logic to test your platform. In the editor’s main toolbar, click the Play button to enter PIE mode. At runtime, your platform should move to the end location. The platform moves fast right now so it might be hard to observe. Next, you’ll add backwards movement so the platform moves continuously when active. Later, you’ll add a variable to slow it down. 

You can experiment with moving the target point around your level to see the effect. 

The timeline you made is one second long, so the platform always takes one second to move from its starting location to the Target Point. The further you place the platform from the Target Point, the faster it needs to move to cover that distance. 

So far, the platform only moves in one direction. Next, you’ll build its backwards movement.

Create Backward Movement

To reverse the platform’s movement, you’ll need logic that checks which direction its timeline is moving. If it’s moving forward, the logic should call evMoveBackwards. If it’s not moving forward, the logic should call evMoveForward. You can use a branch node to handle this check.

To create a branch node and connect it to your existing logic, follow these steps:

1. From the Finished pin of the TM_MovePlatform, drag out and create a Branch node.

   

2. From the branch’s Condition pin, drag out and create Equal (Enum).

   

3. Connect the Direction pin of TM_MovePlatform to the A pin of Equal.

   

4. Verify that the condition is set to Forward.

5. From the True pin of the branch, drag out and create evMoveBackwards.

6. From the False pin of the branch, drag out and create evMoveForward.

   

7. Since you only want movement to occur if the Active boolean is true, check this first with another branch:

   1. To add a new node between TM_MovePlatform and the Branch node, drag from the Finished pin and add a new Branch node. This keeps the existing connections and adds the second Branch node in between.

      

   2. From the Condition pin on the new Branch node, drag out and create Get Active.

      

8. Save and Compile.

Your EventGraph should now look like this:

However, your draft logic states that the platform must wait for a duration of time before changing direction. Next, you’ll build this delay.

Create a Delay

You can use a delay node to instruct the platform to wait, and a float-type variable to define the amount of time you want it to wait for. 

To create a delay node and a float, follow these steps:

1. In the My Blueprint tab of BP_Platform, click the + button to to create a new variable and name it WaitDuration.

2. Set its pin type to Float.

3. In the Details panel, add it to the Setup category and enable Instance Editable.

4. Compile to access the variable’s Default Value and set it to 2 seconds. This is the time we’re using in the sample level.

   

5. To add the delay before the platform changes directions, drag from the Finished pin on TM_MovePlatform, and create a Delay node.

   

6. From the Duration pin of the Delay, drag out and create Get Wait Duration.

   

7. Save and Compile.

Your variable list should now look like this:

Your EventGraph should now look like this:

Test your platform in PIE mode. It should move forwards, wait, then move backwards, wait, and repeat indefinitely.

Finally, you need to activate your platform through BP_Switch.

Connect the Switch to the Platform

The platform should only move when BP_Switch is activated by a player or other object. You’ll use the Blueprint interface functions you created in Puzzles: Switches and Cubes, and your Active boolean, to signal when the platform should move forward and stop.

To make the switch’s BPI_Interaction messages start and stop the platform’s movement, follow these steps:

1. In BP_Platform, in the Blueprint Editor’s menu bar, click Class Settings.

   

2. In the Details panel, under the Interfaces headings, click the dropdown menu next to Implemented Interfaces. Search for and add BPI_Interaction.

   

3. This creates a new Interfaces heading in the My Blueprint tab.

   

4. In the Interfaces heading, right-click fnBPISwitchOn and select Implement Event to populate it to the EventGraph as an event.

   

5. Do the same for fnBPISwitchOff.

6. From the Exec pin of fnBPISwitchOn, search for and create Set Active. Select the checkbox next to Active to set its value to true.

7. From the Exec pin of the Set node, search for and create EvMoveForward.

   

8. From the Exec pin of fnBPISwitchOff, search for and create Set Active.

   

9. From the Exec pin of the Set node, search for and create EvStop.

10. Save and Compile.

All of the logic that powers BP_platform is complete. Now that you’ve done the heavy lifting, you can modify which platform(s) a switch activates, where the platform travels to and from, and the platforms scale — all from the viewport. With these settings readily available from the viewport, you can design and test your level without continuously needing to edit the Blueprints.

Next, you’ll populate the switch’s array that you created in Puzzles: Switches and Cubes.

Populate the Interact Object List

You can populate the switch’s Interact Object List array with any object in your level that you want the switch to activate, so long as it has logic to power it. In this case, you’ll select the instance of BP_Platform in your level.

To populate the array, follow these steps:

1. Select your platform in the viewport. In the Details panels, set Active to false (unchecked). This will stop it from activating at runtime and wait for the switch’s signal.

2. Select your switch in the viewport. In the Details panel, under Setup, next to Interact Object List, click the Add Element (+) button to create a new index in the array.

3. In the dropdown, search for BP_Platform or use the eyedropper tool to select it in the viewport.

   

Enter PIE mode to test out your final gameplay object. When you, or a physics cube, overlap the switch, the platform should move back and forth (and stop when you or the cube moves away).

Try enabling ActivateOnce on the BP_Switch. You’ll notice that because the switch stays active, the platform continues to move even if you step away from the switch.

Depending on where you’ve placed the target point in your level, you might notice a problem. If you place the physics cube on the platform and step on the switch, the platform moves so quickly that the cube falls off. Impractical physics can frustrate players and stop them from completing your puzzle.

In the next section, you’ll debug this problem.

Debugging

In this section, you’ll make adjustments and add additional functionality to your physics cube and platform to mitigate issues which might cause frustration for your players while solving your puzzle.

Adjusting Damping

As you push the cube, you might notice that it feels very light and easy to push. This sensitivity to force can pose problems when players maneuver the cube through a puzzle or as it travels on a platform. 

To increase the damping on the cube, follow these steps:

1. Open BP_Cube in the Blueprint Editor and select the Cube static mesh.

2. In the Details panel, under Physics, set the Linear Damping 0.7 and Angular Damping to 0.8. This is a suggested amount and might vary depending on your project’s needs.

3. Save and Compile.

Test the cube again. If it’s still falling off the platform, move on to adjusting the platform's speed.

Adjusting Velocity

Since the velocity of the platform affects the physics cube, slowing down the platform’s speed can help the cube stay onboard. 

To adjust the platform’s speed, follow these steps.

1. In BP_Platform’s EventGraph, create a new variable named TimeToTarget.

2. Set its pin type to Float.

3. Compile your Blueprint.

4. In the Details panel, enable Instance Editable, add it to the Setup category, and set the Default Value to 2.0. This is a suggested amount that will vary depending on your level.

5. Go to the group of nodes near the top of your graph that starts with Event BeginPlay.

6. Drag out from the Exec pin of the Set End Location node. Search for and create Set Play Rate (Timeline).

   You may need to uncheck Context Sensitive to find this node.

   

7. From the Target pin of the Set Play Rate node, search for and create a Get TM Move Platform node.

   

8. From the New Rate pin of Set Play Rate, drag out and create a Divide operator node. Set its A value to 1.0.

   

9. From the B pin of the Divide node, drag out and create Get TimeToTarget.

   

10. Save and Compile.

Your EventGraph should now look like this:

Test your level in PIE mode and see how that changes the interaction between the platform and the cube. The cube should now stay on the platform when it moves. 

Because you included the TimeToTarget variable in the Setup category, you can easily adjust the platform’s speed and test it from the viewport as you design your level.

Example Puzzle

We created a puzzle for Room 1 using the switch, cube, platform, and key assets described in this tutorial. If you’d like to copy our puzzle instead of creating your own, the sections below describe how to place assets exactly where we put them. Each section highlights an insight that we uncovered during playtesting that influenced our design choices.

The Obstacles, Cubes, and Key

During playtesting, we discovered that players were struggling to control the physics cube’s movement. We added walls to guide the cube as the player pushes it around the room, and damping to reduce the cube’s reactivity. This mitigates frustration and avoids unfairly punishing the player for unusual physics behavior.

We also discovered that we needed a way to reset our puzzle if the player failed. Since players are likely to knock cubes off of platforms while they play, we populated key locations with more cubes to reduce the amount of backtracking needed to reset the puzzle and replace destroyed cubes.

Room 1 Development Sequence

To copy the obstacles into your level follow these steps:

1. Copy the snippet below by clicking Copy Full Snippet.

   Command Line

   Command Line Snippet

   Begin Map
      Begin Level
         Begin Actor Class=/Script/Engine.StaticMeshActor Name=StaticMeshActor_32 Archetype="/Script/Engine.StaticMeshActor'/Script/Engine.Default__StaticMeshActor'" ExportPath="/Script/Engine.StaticMeshActor'/Game/AdventureGame/Designer/Lvl_Adventure.Lvl_Adventure:PersistentLevel.StaticMeshActor_32'"
            Begin Object Class=/Script/Engine.StaticMeshComponent Name="StaticMeshComponent0" Archetype="/Script/Engine.StaticMeshComponent'/Script/Engine.Default__StaticMeshActor:StaticMeshComponent0'" ExportPath="/Script/Engine.StaticMeshComponent'/Game/AdventureGame/Designer/Lvl_Adventure.Lvl_Adventure:PersistentLevel.StaticMeshActor_32.StaticMeshComponent0'"
            End Object
            Begin Object Name="StaticMeshComponent0" ExportPath="/Script/Engine.StaticMeshComponent'/Game/AdventureGame/Designer/Lvl_Adventure.Lvl_Adventure:PersistentLevel.StaticMeshActor_32.StaticMeshComponent0'"
               StaticMesh="/Script/Engine.StaticMesh'/Game/LevelPrototyping/Meshes/SM_Cube.SM_Cube'"
               StaticMeshImportVersion=1
               StaticMeshDerivedDataKey="STATICMESH_FD1BFC73B5510AD60DFC65F62C1E933E_228332BAE0224DD294E232B87D83948FQuadricMeshReduction_V2$2e1_6D3AF6A2$2d5FD0$2d469B$2dB0D8$2dB6D9979EE5D2_CONSTRAINED0_100100000000000000000000000100000000000080FFFFFFFFFFFFFFFFFFFFFFFF000000000000803F00000000000000803F0000803F00000000000000003D19FC1626C9B248DECA64C7201D34D790CF7B09D3C0873700000000010000000100000000000000010000000100000000000000000000000100000001000000400000000000000001000000000000000000F03F000000000000F03F000000000000F03F0000803F00000000050000004E6F6E65000C00000030000000803FFFFFFFFF0000803FFFFFFFFF0000000000000041000000000000A0420303030000000000000000_RT00_0"
               RelativeLocation=(X=-5940.000136,Y=1669.999995,Z=-400.499900)
   
   Expand code Copy full snippet(573 lines long)

2. In the Unreal Editor, click Edit > Paste or Ctrl + V in the viewport.

The Platforms

In the same way that adding more physics cubes acted as a puzzle reset, we added a platform that lifts the player back up to the room’s starting position. By using the Active variable, this reset platform activates at runtime.

To copy the obstacles into your level follow these steps:

1. Copy the snippet below by clicking Copy Full Snippet.

   Command Line

   Command Line Snippet

   Begin Map
      Begin Level
         Begin Actor Class=/Game/AdventureGame/Designer/Blueprints/Platforms/BP_Platform.BP_Platform_C Name=BP_MovingPlatform_C_16 Archetype="/Game/AdventureGame/Designer/Blueprints/Platforms/BP_Platform.BP_Platform_C'/Game/AdventureGame/Designer/Blueprints/Platforms/BP_Platform.Default__BP_Platform_C'" ExportPath="/Game/AdventureGame/Designer/Blueprints/Platforms/BP_Platform.BP_Platform_C'/Game/AdventureGame/Designer/Lvl_Adventure.Lvl_Adventure:PersistentLevel.BP_MovingPlatform_C_16'"
            Begin Object Class=/Script/Engine.SceneComponent Name="DefaultSceneRoot" Archetype="/Script/Engine.SceneComponent'/Game/AdventureGame/Designer/Blueprints/Platforms/BP_Platform.BP_Platform_C:DefaultSceneRoot_GEN_VARIABLE'" ExportPath="/Script/Engine.SceneComponent'/Game/AdventureGame/Designer/Lvl_Adventure.Lvl_Adventure:PersistentLevel.BP_MovingPlatform_C_16.DefaultSceneRoot'"
            End Object
            Begin Object Class=/Script/Engine.StaticMeshComponent Name="Platform" Archetype="/Script/Engine.StaticMeshComponent'/Game/AdventureGame/Designer/Blueprints/Platforms/BP_Platform.BP_Platform_C:Platform_GEN_VARIABLE'" ExportPath="/Script/Engine.StaticMeshComponent'/Game/AdventureGame/Designer/Lvl_Adventure.Lvl_Adventure:PersistentLevel.BP_MovingPlatform_C_16.Platform'"
            End Object
            Begin Object Class=/Script/Engine.TimelineComponent Name="TM_MovePlatform" ExportPath="/Script/Engine.TimelineComponent'/Game/AdventureGame/Designer/Lvl_Adventure.Lvl_Adventure:PersistentLevel.BP_MovingPlatform_C_16.TM_MovePlatform'"
            End Object
            Begin Object Name="DefaultSceneRoot" ExportPath="/Script/Engine.SceneComponent'/Game/AdventureGame/Designer/Lvl_Adventure.Lvl_Adventure:PersistentLevel.BP_MovingPlatform_C_16.DefaultSceneRoot'"
   
   Expand code Copy full snippet(280 lines long)

2. In the Unreal Editor, click Edit > Paste or Ctrl + V in the viewport.

3. Connect the platforms to the corresponding target point:

   • BP_Platform1 references TargetPoint1

   • BP_Platform2 references TargetPoint2

   • BP_Platform3 references TargetPoint3

   • BP_Platform4 references TargetPoint4

   • BP_Platform5 references TargetPoint5

The Switches

We used the InteractObjectList array to connect some switches to multiple platforms. This way, we kept the puzzle concise and challenging, avoiding extra steps that might bore or frustrate the player.

To copy the obstacles into your level follow these steps:

1. Copy the snippet below by clicking Copy Full Snippet.

   Command Line

   Command Line Snippet

   Begin Map
      Begin Level
         Begin Actor Class=/Game/AdventureGame/Designer/Blueprints/Activation/BP_Switch.BP_Switch_C Name=BP_ActivationPlate_C_9 Archetype="/Game/AdventureGame/Designer/Blueprints/Activation/BP_Switch.BP_Switch_C'/Game/AdventureGame/Designer/Blueprints/Activation/BP_Switch.Default__BP_Switch_C'" ExportPath="/Game/AdventureGame/Designer/Blueprints/Activation/BP_Switch.BP_Switch_C'/Game/AdventureGame/Designer/Lvl_Adventure.Lvl_Adventure:PersistentLevel.BP_ActivationPlate_C_9'"
            Begin Object Class=/Script/Engine.SceneComponent Name="DefaultSceneRoot" Archetype="/Script/Engine.SceneComponent'/Game/AdventureGame/Designer/Blueprints/Activation/BP_Switch.BP_Switch_C:DefaultSceneRoot_GEN_VARIABLE'" ExportPath="/Script/Engine.SceneComponent'/Game/AdventureGame/Designer/Lvl_Adventure.Lvl_Adventure:PersistentLevel.BP_ActivationPlate_C_9.DefaultSceneRoot'"
            End Object
            Begin Object Class=/Script/Engine.StaticMeshComponent Name="Switch" Archetype="/Script/Engine.StaticMeshComponent'/Game/AdventureGame/Designer/Blueprints/Activation/BP_Switch.BP_Switch_C:Switch_GEN_VARIABLE'" ExportPath="/Script/Engine.StaticMeshComponent'/Game/AdventureGame/Designer/Lvl_Adventure.Lvl_Adventure:PersistentLevel.BP_ActivationPlate_C_9.Switch'"
            End Object
            Begin Object Class=/Script/Engine.BoxComponent Name="Trigger" Archetype="/Script/Engine.BoxComponent'/Game/AdventureGame/Designer/Blueprints/Activation/BP_Switch.BP_Switch_C:Trigger_GEN_VARIABLE'" ExportPath="/Script/Engine.BoxComponent'/Game/AdventureGame/Designer/Lvl_Adventure.Lvl_Adventure:PersistentLevel.BP_ActivationPlate_C_9.Trigger'"
            End Object
            Begin Object Name="DefaultSceneRoot" ExportPath="/Script/Engine.SceneComponent'/Game/AdventureGame/Designer/Lvl_Adventure.Lvl_Adventure:PersistentLevel.BP_ActivationPlate_C_9.DefaultSceneRoot'"
   
   Expand code Copy full snippet(115 lines long)

2. In the Unreal Editor, click Edit > Paste or Ctrl + V in the viewport.

3. Connect each switch to the correct platform:

   • BP_Switch1 references BP_Platform1.

   • BP_Switch2 references BP_Platform2 and BP_Platform 3.

   • BP_Switch3 references BP_Platform5.

Now, test your level to make sure it’s working properly and see if you can beat the puzzle. You can check your work against the complete level we provide at the end of this tutorial series.

Next Up

Create a Trap and Apply Damage