What is a Function?

Blueprint Functions are self-contained pieces of logic that you can create once and run from multiple places in your Blueprints. They allow input and output parameters for flexibility.

For example, instead of writing the same logic to calculate damage multiple times, you can create a function called CalculateDamage, call it wherever needed, and update it in one place if changes are required.

Note that a function is created for a specific blueprint actor and can only be used

In this guide we are going to start right from the beginning and create a simple function to help you understand this concept. We then expand upon this and show you more features that functions can have!

Creating a Function

To start, we are going to make a simple function that prints a string to the screen.

Firstly we need to open the blueprint actor that we want to add the function to. In this example we are using the FirstPersonCharacter blueprint from the First Person Shooter template provided by Unreal Engine.

As you can see in the image below, on the left side of the editor window, there is a drop down section named “Functions”. This section is where all of our functions live for this specific blueprint.

We can create a new function by clicking the circle with a plus symbol on the right side of the functions drop down as shown in the image below.

Next, we can then give our function a name. It is advised to give our functions readable and clear names to keep our project clean.

Messy names that are confusing make developing a large project difficult so it is best to keep this in mind.

Once the function is named either press enter, or click anywhere in the blueprint window, then click the “Compile” button as indicated in the image. This then creates our function and compiles it into the blueprint so we can start using it in our project.

Adding Basic Functionality

Now that we have our new function created and compiled, we can see it doesn’t do anything at the moment. We need to add some simple functionality!

In this first example we are printing a string to the screen. To achieve this we need to add that node to our function.

First, click and drag from the white sidewards triangle on our “My Custom Function” node. This is called an exec pin and allows us to add pieces of code together to run one after another (sequentially).

Once we click and drag then let go of the click, anywhere on the grey background grid, we then are greeted with a popup menu showing all of the blueprint nodes (these are functions!) we can add to our own function.

Click “Print String” in the menu, this creates the “Print String” node in our function graph.

As we dragged from the white exec pin, our Print String node is automatically connected to our MyCustomFunction as shown in the image below.

When our “My Custom Function” runs, it will now run the Print String node that is connected to it!

You may also see people talking about “call”, “called”, or “calling” functions. This is the same as running a function!

Testing our Print String

Now that our function is setup to print a string to the output log we need to run our function. The easiest way is to run our function on Begin Play!

Begin play is an “Event”. An event is similar to a function but cannot return values and can run a few special asynchronous nodes that functions cannot.

Begin Play is an event that is called when the actor is spawned into the game world. As our FirstPersonCharacter already is in the game world, this Begin Play event runs code when the game starts.

We first want to click the Event Graph button at the top of the blueprint editor.

Now our main blueprint event graph will appear again on the screen.

Find somewhere free and right click. In the box that appears search for Event Begin Play and click it to create the event.

Unreal Engine will automatically run the Begin Play event as described in the previous section so no setup is required.

Like before, drag from the white exec pin and let go of the mouse click in the grid. In the pop up menu, search for our MyCustomFunction and click it in the list.

Now our MyCustomFunction is connected to our BeginPlay event. The last step is to press the Compile button and save our blueprint.

Clicking play now in our FirstPersonMap will print “hello” in our output log.

Adding more functionality

Now we have text printing on the screen! That’s great for testing but not very useful for gameplay. Lets add some more functionality to our blueprint function.

In this next example we are going to make the CalculateDamage function we talked about earlier!

This function will take in a number called “damage“, seeing how much “armor” our character has, then finally subtract the amount of “armor” from our “damage” number. In short we are calculating how much damage is dealt after our “armor” has absorbed some of the damage.

Notes on advanced functionality

Delay nodes are not supported in functions. If your blueprint needs delay nodes, consider using Custom Events. Click here to read our guide on How to use Custom Events in Unreal Engine.

Making the CalculateDamage function

To achieve this goal of our CalculateDamage function, first we need to input data into our function.

Firstly, click the purple “My Custom Event” node. You should now see in the details window on the right side of the editor sections for Input and Output.

As we are focussing on Input, click the small add button to add a new Input Variable.

We now see a new input parameter for our function.

In this example we want to pass in a number so we change the “Boolean” to “Float”.

Next in the left text box give our new property a name. We are naming this “Damage”.

So far the function should look like this.

Now we are adding some other nodes to calculate our damage value.

To do this first, drag from the green Damage pin into the grid and let go of the mouse click. In the popup search “-” or “subtract” to find the subtract node.

Next we click and drag from the bottom subtract node pin and let go, in the menu we then click “Promote to variable”. This will create a new variable that we name “Armor” to store our character’s armour number.

Next, click the new armor variable in the graph and on the right side details panel and set the armor value to any number you want. In this example we set armor to 15.

Our MyCustomFunction now takes in the Damage value and subtracts Armor from itself, this is then printed into the output log.

Returning our value

Our function now calculates values but does not send those values anywhere! We need to “return” this value out of our new function.

Returning a value is the word used to describe the output of our function. In Unreal Engine Blueprints we can have as many input and output values as we like.

First click our MyCustomFunction and look to the details panel on the right side of the editor again.

This time we are clicking the plus button on the Output section.

In the newly created Output result, change the type to Float and set the name to Result.

After creating the new output parameter a “Return Node” will be created automatically in the graph.

This Return Node result pin is where we can “return” our values out of the function.

We then delete the print string from the function as we no longer need it inside the function.

Our final function now looks like this.

In the event graph our function now looks like this. We can give it a “damage” value and get a “result” value out from the function!

To test this is working we set damage to 20.0 and connect our returned result value to a print string node.

Demonstration

Finally, with our damage set to 20 and our armor set to 15, when we call our MyCustomFunction we get the value 5!

20 – 15 = 5

In the output you can see that our returned value of 5 is printed to the log!

Conclusion

You’ve now taken the first steps in getting started with Blueprint Functions in Unreal Engine 5! These essential aspects of programming allow you to separate logic into reusable nodes, cleaning up your blueprint actors and making your dream game easier to manage.

The basic concept and example covered in this guide provides a foundation to build upon. Whether you’re building gameplay mechanics, working on core technology, or cleaning up your existing code, Blueprint Functions are a fundamental aspect of Unreal Engine development.

Further Reading:

• Click here to read the official blueprint function unreal engine documentation
• Click here to watch Mathew Wadstein’s in depth blueprint function guide on YouTube (Not affiliated or associated with CouchLearn)

The post Getting started with Blueprint Functions in Unreal Engine 5 appeared first on Couch Learn.

Before we Start

This guide continues on from the CouchLearn guide “Setting up a NavMesh in Unreal Engine 5”.

Our previous guide explains how to set up a basic NavMesh and AI character in your Unreal Engine 5 project. Follow the previous guide found here or download the project files here.

Chasing the Player

In the previous “Setting up a NavMesh in Unreal Engine 5”. guide, we finished off with these blueprint nodes to move the AI character around the level.

Firstly, delete the “Get Actor Location” and “GetRandomReachablePointInRadius” nodes from the graph.

These nodes are currently trying to find a random position around the AI. We want the AI to use the player’s location so it is safe to delete these two nodes.

Next, add a new “Get Player Character” node to the blueprint graph.

Then, connect the blue “Return Value” pin to the blue “Target Actor” pin on the “AI MoveTo” node.

This will now get our “Target Actor’s” location for the AI movement.

As our AI might fail to move, if the player isn’t reachable in the navmesh, we now connect the “On Fail” pin to the “Delay” node.

This now retries the movement if the player is unreachable or the AI fails the nav mesh movement for any reason. This step will keep the AI following the player no matter the situation.

Lastly, make sure to Compile and Save the blueprint editor. This will ensure the changes are applied when we play in the editor.

Use Cases

Even thought these steps are easy and only a few blueprint nodes are used, this basic system can enable many types of AI in modern games.

A few examples of this could be:

• Companion AI following the player around an open world like Skyrim (Using the Unreal Engine dynamic open world navigation).
• Zombie AI chasing the player (Using the Unreal Engine damage system).

Demo Video

Download the Project Files

Conclusion

Now your AI character / enemy is following and chasing the player character around the level in Unreal Engine 5!

As explained in the previous step, this basic system can be expanded to implement many modern game AI behaviours into your Unreal Engine project. To learn more about the capabilities of AI and Navigation in Unreal Engine, consider reading further using the links below.

Further Reading:
How to smoothly rotate AI characters in Unreal Engine
Open world navigation in Unreal Engine
Dynamically generated navigation in Unreal Engine
Official Unreal Engine Navigation documentation

The post AI Following the Player in Unreal Engine 5 appeared first on Couch Learn.

Setting up the NavMesh

Firstly, click Window, then Place Actors. This will show the Place Actors window in the editor. This window allows you to spawn basic objects and volumes into your Unreal Engine 5 level.

Then, add a NavMeshBoundsVolume actor to your level. This can be found in the Modes panel under the “Volumes” category.

Scale and position the NavMeshBoundsVolume to fit around the area that you want the AI to be able to navigate.

This can be as large or as small as you require. Bigger nav meshes take longer to generate unless you use dynamic generation. Click here to read about dynamic nav mesh generation.

Now to confirm your Nav Mesh is setup correctly for your level, Press the “P” key on your keyboard to see the mesh visualized in the level.

Moving the AI Character

For this guide we are using the third person template that Unreal Engine 5 provides.

This means we can have an animated character to test the AI Navigation.

To enable our third person character blueprint to navigate the level, first drag your character into the level.
This can be found in the “Third Person / Blueprints” folder in the Content Drawer if you created your project using the Third Person Template.

In the blueprint editor of the character, create a “Begin Play” event and connect the “AI MoveTo” node as shown in the image below.

Next, create a “GetRandomReachablePointInRadius” node and connect the output yellow vector pin to the yellow “Destination” pin on the “AI MoveTo” Node.

Then create and connect a “Get Actor Location” node to the “Origin” yellow vector pin. This Origin position is where the random movement is calculated around.

Set the green “Radius” pin value to the distance you want your AI to roam around. In this guide we are using “2000”.

Create a “Reference to Self” node and connect this to the blue “Pawn” pin of the “AI MoveTo” node.

Finally, create a “Delay” node then connect it to the “On Success” pin. Connect the end of the Delay back into the AI MoveTo node. This will continuously navigate the AI character around the Navigation Mesh.

Now you can click “Play” and the character will then begin moving towards random locations in your level using the NavMesh.

Demo Video

Download the Project Files

Conclusion

Now your character is moving around the level all by itself! This AI behaviour is very basic but can be expanded upon greatly using many of the great AI features in Unreal Engine 5. To learn more about AI and Navigation in Unreal Engine consider reading further using the links below.

Further Reading:
How to smoothly rotate AI characters in Unreal Engine
Open world navigation in Unreal Engine
Dynamically generated navigation in Unreal Engine
Official Unreal Engine Navigation documentation

The post Setting up a NavMesh in Unreal Engine 5 appeared first on Couch Learn.

Accessing the MetaHuman Library

Firstly, click the Window tab in the Unreal Engine editor and click “Quixel Bridge”.

Once the Quixel Bridge has opened in the editor, click the MetaHumans tab.

Now you see all of the preconfigured MetaHumans available to download and add to your project.

Before you can download your chosen MetaHuman to the opened project, click one of the avatars in the grid. You should see the Sign In button on the bottom right of the window.

Continue logging into your Epic Games account to access the full Quixel Megascans and MetaHuman library.

Adding the character to your Project

Now that you are fully logged into the Quixel Bridge tab, click one of the MetaHuman avatars and click Download. Once the MetaHuman is downloaded successfully, click the Add button.

The editor will now be importing your chosen MetaHuman into the open project. If any notifications pop up in the bottom left of the editor, press “Enable Missing” to allow the editor to configure your project for MetaHumans.

Once you have enabled the missing settings and plugins, press the “Restart Now” button to restart the editor with the new settings applied.

In the Content Drawer, click the “MetaHumans” folder and find the folder name of the MetaHuman you chose in the previous step. Your downloaded MetaHuman can now be found setup in the asset starting with “BP_”.

Conclusion

Now your project has a ready to use MetaHuman blueprint! As you can see in the blueprint, there are multiple meshes that make up the full character. These meshes can be used as your player character as they are fully rigged!

In the future you will be able to make your own custom MetaHumans using the MetaHuman creator tool.

Further Reading
Custom MetaHumans using the MetaHuman creator

Official MetaHuman Unreal Engine page

Unreal Engine 5 MetaHuman documentation

The post How to add MetaHumans into your UE5 project appeared first on Couch Learn.

Before we Start

To make this guide easier to understand for new developers, we are using the Unreal Engine 5 Third Person template which is found in the New Project window.

If you already have your project setup with a Character blueprint, skip to the “Adding our Double Jump” section below.

Creating our template project

Firstly, we want to click Third Person, choose a project location on your computer in the bottom left, then give the project a name in the bottom right. Once this is done, click the blue “Create” button in the bottom right of the window.

Once the Unreal Engine editor has opened your new project, open the “Content Drawer” in the bottom left of the editor and find the BP_ThirdPersonCharacter object in the Content/ThirdPerson/Blueprints folder.

Adding our Double Jump

The first step to add double jump functionality is to open our Character blueprint and select the name.

In our case this is the text labelled “BP_ThirdPersonCharacter (Self)”. Once this is selected the text will go blue as shown below.

On the right side of the blueprint editor you will find the “Details” tab. Look through the details tab until you find “Character” and the “Jump Max Count”. This value is set to 1 by default.

Now as we want to have our character double jump, change this value to 2. If you require more than 2 jumps for your character, change this value to whichever suits your needs.

Once this is done, remember to click the “Compile” and “Save” buttons in the top left of the blueprint editor.

Simple Double Jump Demo

Your character is now able to double jump! As you can see in the demo video below the character is double jumping successfully.

However, one problem you can see is the animation only plays once. In the next section we will be fixing the animations so they play correctly for all jumps.

Animation Improvements (Intermediate Difficulty)

As the double jump doesn’t look right in the previous demo, we now are fixing the animations.

Firstly, open the “Content Drawer” and find the ABP_Manny object in the Content/Characters/Mannequins/Animations folder.

Now the animation blueprint editor is open, find and double click the AnimGraph text in the left of the editor window.

Next, with the animation graph now open, click the “Main States” state machine. This is where all of the animation transitions are held for our character.

Inside the Main States state machine, drag from the state named “Fall Loop” to the state named “Jump” as shown in the image below. If done correctly you should see an arrow and text stating “Create a transition”.

With our transition now created, click the icon to open the transition editor.

Finally, in the transition editor add the blueprint nodes shown in the example image below.

These nodes allow the animation state to return back to the jumping animation once you trigger the double jump.

Advanced Animated Double Jump Demo

Your improved double jump is now complete! As you can see in the video below, the animations are much better and the player now gets visual feedback when they double jump.

Download the Project Files

Conclusion

Your Unreal Engine 5 project now has a double jump capable character! For a challenge, do try to follow the optional animation improvement steps as it really make a difference to the experience!

Further Reading:
Official blueprint guide to setting up a new character mesh in UE5
Full ACharacter documentation for advanced jump settings in C++

The post How to add Double Jumping in Unreal Engine 5 appeared first on Couch Learn.

Prerequisites

To understand this guide and implement timers into your project, you will need to know how to use custom events and functions in Unreal Engine 5 before starting.

Click here to read our guide on custom events.

How to create Blueprint Timers

Basic Timer Settings

Before we create our timer, we will look at the basic timer settings that all timers have. These allow us to set the frequency of the timer and if the timer repeats or not.

The green Time pin is the time Unreal Engine will wait to call your event. If this value is less than or equal to 0, the timer will be cleared and will not call the event.

The Looping check box will repeat the timer if set to true and only run once if set to false. Ticking this box is best for functionality that you want to run repeatedly.

Timer by Event

When you want to create a timer that uses a custom event in the event graph, you need to use Set Timer by Event.

As shown below, your custom events can be connected using the red event delegate square. Any custom event are connected to this pin to trigger on the time set. Only one event is connected at a time.

Timer by Function

If you want to use a function instead of an event delegate, we have the Timer by Function Name blueprint node. This has function name and object pins replacing the red delegate pin.

Object is the reference to the object that you want to run the function on (e.g. FirstPersonCharacter or your own custom actors). If you want to run the function on this actor, you can leave this pin empty.

“Function Name” is the name of the function found in the function list in your object.

In this example we have created a new function in the My Blueprint panel on the left of the blueprint editor. Our new function is called MyCustomFunction.

Now our function has been created, we then add the functions name into the Function Name pin.

The blueprint node above now run MyCustomFunction after 5 seconds without looping.

Saving the Timer

If you want to change any properties about a timer, you need to save a reference to the return value. The easiest way to do this is to drag from the return value and click Promote to Variable.

Pausing and Unpausing Timers

Now we have a reference to our timer, we can pause and un-pause the timer. The nodes below show the handle and function versions of pausing and unpausing your timer.

Function timers can be paused and unpaused using the function name and do not need a timer handle.

Removing a Timer

When you need a timer to stop, use the clear and invalidate timer blueprint nodes. These nodes will stop the timer and destroy the specified handle object.

When using a Function Timer, you will need to clear and invalidate the timer separately if you want to use a function name.

Checking a Timer’s Status

With the handle or function name, you can check various properties about a timer.

Firstly we have Does Timer Exist. These nodes check if the timer exists in memory. If the timer is cleared and invalidated this value is false.

Is Timer Active will return true if the handle or function name has a timer that is actively running and exists.

“Is Timer Paused” returns true if the timer is not actively running but does exist.

Conclusion

Now you have all the knowledge to use timers in your blueprint code in Unreal Engine 5!

Having all of these nodes at your disposal allows code and functionality to run at specific times and at certain frequencies. This will overall improve the readability of your code and can bring great performance gains. We recommend setting the Time value to 0.1 or 0.05 seconds instead of running every frame on tick.

Further reading:
In depth use of timers with gameplay example from Unreal Engine documentation
Click here to read how C++ Timers work in Unreal Engine

The post How to use Timers in Unreal Engine 5 appeared first on Couch Learn.

Inheritance is an important feature in many object oriented programming languages. It allows programmers to create variations of an object and communicate with them as if they are all the same original type.

Blueprints also have the ability to have child classes and have parent classes that they inherit from.

If you want to learn more about the theory behind inheritance, click here for a tutorial from w3 schools showing inheritance in C++.

Parent Class

Creating the Parent Class

To start, create a new blueprint actor and name it ParentActor.

This actor can now be filled with events, input actions, variables, functions and more. All of these attributes will be shared to our child actors.

If you don’t know how to use input actions and input axes click here for a detailed run down on how to include these powerful events into your project.

Setting up the Parent Class

To demonstrate, I have created two keybinds, an event, a function and a float variable.

Pressing 1 will set this float value to 1 and pressing 2 will set the float value to 2.

Child Class

Creating a child class

Creating a child class from your chosen parent class is very easy.

To create a new class based on a previous simply right click your chosen class in the content browser and click create child blueprint.

Accessing the parent

Variables

Inside the child actor there are no visible variables of the left side.

Right clicking and searching for your parent variables will reveal them in the default section.

Events and Functions

Right clicking inside your child blueprint class and typing the name of your functions and events will give you access to them.

Key events will override any code that is on the same parent event. This child class will now print 10 on key press 1 and 20 on key press 2.

To make sure the parent code runs as well as the child code on these key inputs, click on the input and look to the right of the details panel.

Un-checking the “Override Parent Binding” box will run both sections of code. If you want your child to have different behaviors on the same key presses you can leave this checked.

Running Parent Code

When accessing parent functions and events you are stopping the parent code from running. This is called overriding.

To make sure the parent code runs during the event, right click the specific event and click Add Call to Parent Function.

Now when custom parent event is fired the child code will run and the parent code will run. The expected output is “Hello From Parent Class” on screen.

Conclusion

That is the basics of parent and child classes in unreal engine 4!

Designing your code to utilize this powerful technique will improve the readability and efficiency of your game development processes.

The post Parent and Child Blueprints in Unreal Engine 4 appeared first on Couch Learn.

In Unreal you can create Arrays which give you the ability of storing as many pieces of information together within one variables as long as they are the same variable type (Float, Integer, Vector, Actor, etc.).

A few real game uses for arrays are storing items inside their backpack and location way points for your AI characters to navigate to.

Loops are used to navigate through your arrays and access individual data. This then can be used to effect your game based on this data.

Arrays

What is an Array?

An array is a sequence of objects that are all of the same type.

For a further theory dive into arrays using C++ click here.

Creating an Array

Firstly create a variable of the type you want. In this case I used a float.

Create the variable, press the button to the side of the variable type then select the array button to convert this variable to an array.

Populating the Array

Now you can populate your array with the plus button. Separate floats have now been created and can be changed independently of each other.

Your array is now fully setup!

Accessing your Array

Below are the main blueprint nodes that you will be using when accessing your arrays. For the complete list of array nodes click here.

Accessing a specific index in your array uses the GET node:

To add an element to the end of your array use the ADD node:

Removing a specific index in your array uses the REMOVE INDEX node:

Setting a specific array element to a new value uses the SET ARRAY ELEM node:

To check if your array contains a specific element/value use the FIND ITEM node:

When you need to remove all array elements use the CLEAR node:

Loops

Loops iterations are slow to process so use them sparingly!

While Loop

The simplest type of loop is the While Loop. This executes while the input Boolean is true.

Be careful when using While Loops as they can easily cause the engine to detect and infinite loop. Make sure to use delays inside the loop to prevent the maximum iteration counter from stopping your game running.

For Loop

The next type of loop is the For Loop. This will execute your desired blueprint nodes X amount of times based on your settings.

The ForLoop node gives you the choice of which index to start at and which to end at. The loop will execute and add 1 to the index value, returning this value in the index pin on the right.

Loop body is the pin in which you connect the code you wish to loop through.

Once your loop has finished the completed pin will execute.

For Loop with Break

The For Loop with Break node gives you the option to end your loop early if required. This is especially useful when optimising loops as many loops don’t need to be fully run through if your code has done what it needs to do.

For Each Loop

The for each loop takes an array as an input and gives easy access to every element inside such array.

For Each Loops are especially slow to process in blueprints compared to C++ so try not to use them very often in your blueprint classes.

When working with your arrays, these are the most useful as it gives easy access to current array elements and its respective index.

For Each with Break

The for each node has a variety called for each with break. This gives you the option, similar to the For Loop with Break, to end the loop at a certain point if your required condition is met.

An example of this is looking for a specific item inside your player’s inventory.

You would loop through every index until you found a stack of this item, check if this stack is not full then break the loop as no more processing is required.

Reverse For Each Loop

The last type of For Each loop is the reverse for each loop. This differs from the original loop by starting at the end of the array and working backwards towards the start.

Conclusion

Now you have the knowledge on how to use arrays and loops in Unreal Engine 4!

For a more detailed breakdown of flow control and the blueprint nodes featured in this guide click here for the Unreal Engine documentation page.

The post How to use Loops and Arrays Unreal Engine 4 appeared first on Couch Learn.

Why bother?

Hard coded keys or buttons limits the gameplay of some players as they prefer their own custom layouts. Swapping the jump input, the sprint input or the crouch input fixes this for most.

Giving your players access to this feature will improve the quality of life your players will have throughout the entire experience.

Improving the User Experience

The first step to having fully bindable key inputs is to use Input Actions and Input Axes for your game.

These features can inform the engine exactly which feature you wish to rebind e.g. Shoot or Reload. Saving this to the Input configuration file is then easy so remembering your custom settings after your players reload their games.

Finding the Input Settings Window

To find the input settings window, click on Edit and find the Project Settings option.

The Project Settings window will open up and look like this:

On the left hand side we can see all of the settings we can change in our project. Input contains what we need.

On the right section of the Project Settings window we will now see all of the input settings that we can change in our project.

At the top you can see the two lists for Input Actions and Input Axis under the Bindings category

Action Mappings

What are Action Mappings?

Action mappings are inputs that only output execution pins. Triggering these events can run new lines of blueprint code.

Examples of Action Mappings

Action Mappings are perfect for single fire events such as reloading, jumping, crouching or shooting. Most inputs should use Action Mappings.

Creating your Action Mappings

To see the list of current Action Mappings, press the triangle to the left of the Action Mappings text.

Here we can see all of the Action Mappings that my project uses. These are the defaults that come with the FirstPersonShooter template.

To create a new Action Mapping press the + icon next to the Action Mappings list.

Give the new Action Mapping a name that relates to what you want to use it for. In this case I named mine LightToggle as I am going to use this input for toggling lights in my level.

From here you can now click the drop down box that current says None and select the key that you want this Action Mapping to use.

Shift, Control, Alt and or Command have modifier boxes to the right that can also be ticked to make your input only work if they are pressed at the same time.

To add multiple input keys you can press the + symbol next to the name of the Action Mapping. This adds one extra key that will cause this event to trigger

Adding Functionality

Now your Action Mapping’s are fully setup. Type the name of your Mapping inside your character or pawn blueprint event graph to get an event.

To use your new mapping in a non character or pawn blueprint, you will need to use the enable input node on begin play for that actor.

This is due to actors not receiving input events by default

This fires when your custom input is pressed or released.

Input Action Event Testing

To make sure that this input works I have attached two print string nodes to the InputAction. This prints “Light Toggle Pressed” when LightToggle input is pressed and “Light Toggle Released” when LightToggle is released.

Axis Mappings

What are Axis Mappings?

Axis Mapping’s outputs a single execution pin every frame and also outputs a float value that is set by specific keys/buttons, control sticks or mouse inputs.

Different code can be run on the Axis value as each axis value is assigned is set to a different key.

Examples of Axis Mappings

One example of this is the first person character template movement code.

Pressing no keys outputs 0.

Pressing the A key sets the float output to -1 and moves the player left.

When the player presses D the player moves right due to the float output being 1.

This output sets the scale of the add movement input function.

The axis value is used for the mouse input to control the camera of the first person character.

The horizontal movement of the mouse is converted to a float based on the direction and speed of the mouse and is sent to add controller yaw input to rotate the character.

Creating Axis Mappings

To see the list of current Axis Mappings, press the triangle to the left of the Axis Mappings text.

Here are all of the Axis Mappings that my project uses. These are also the defaults that come with the FirstPersonShooter template.

To create a new Axis Mapping press the + icon next to the Axis Mappings list.

Axis Mappings contain a float which outputs when your specific key is pressed.

I have assigned O to -1 and P to 1 in my Axis Mapping named KeyAxis.

Adding Functionality

Axis Mapping are now setup. Typing the name of the newly created Mapping, inside of any blueprint event graph, shows an event that will fire your custom float value when your specified input is pressed.

As a result we can now see two different blueprint nodes when looking for your InputAxis.

The first in the list gives you the event execution pin that fires every frame and the output float called Axis Value.

The second in the list gives you just the output float.

Input Axis Event Testing

To test, add a print string node to the execution pin of the KeyAxis event. Set the string value to the Axis Value from the output float from the event.

Without pressing O and P the print outputs 0 every frame.

Holding O prints this result:

Holding P prints this result:

Conclusion

Unreal Engine’s robust input now is fully working. Therefore, in the future, input can be rebound to different keys based on the users preference.

Hard coding input causes difficulty down the road with every blueprint. Hard coded binds cannot be changed during runtime.

It’s worth getting into the habit of settings these up for every input you want to use for your games.

The post How to use Input Actions and Input Axis Mappings in your Unreal Engine 4 Game appeared first on Couch Learn.