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.

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.

Creating the Custom Event

To create a custom event, right click anywhere in your actor’s event graph and write “Custom Event”.

Then click “Add Custom Event”.

Once created, name the new custom event.

It’s good practise to name your custom event based on its purpose.

Your event has now been created!

For this guide we named our custom event “My Custom Event”.

Adding Inputs

Similar to functions, custom events can have input variables attached to them.

These are used to send information to the nodes running from the custom event.

To add an input firstly click your custom event in the event graph and look to the right side of the screen.

Click the “New Parameter” button shown below to add a new variable to the inputs list.

Then change the name of the input. The left side text box is the name that will be displayed inside the custom event.

On the right side we can then change the input variables type.

We are changing this variable from Boolean to String. This means we can use text values in our input.

The finished custom event input should now look like this.

The custom event in the event graph will now look like this.

Using your Custom Event

Now that are custom event is created and the input variable has been setup, we can now create a “Print String” node to display the value of “My New Input” on the screen.

This is the easiest way to test if the custom event is working correctly.

Once the “Print String” node is created, connect the “My New Input” variable from your custom event to the In String pin on the Print String node.

To run your custom event simply create a “Event BeginPlay” node, drag from the execution pin and type the name of your new custom event. In our case this is “My Custom Event”.

As your custom event is connected to an execution pin, it is now being called by the other event.

Now that your custom event is being called by the BeginPlay event you can see the input variable.

This input variable pin can be connected to any variable with the same type.

We can now write any text into the My New Input variable.

Testing the Custom Event

Running the game will now show the text that we wrote in the custom event.

Conclusion

Now you have the knowledge to create and use custom events in Unreal Engine 4!

Custom events are an essential component of Unreal Engine and are especially important for multiplayer game creation using blueprints.

Below are a few links for the full custom event documentation and a guide for using custom events and other Unreal Engine 4 features to make a multiplayer damage and health system.

Click here to read the official documentation on Custom Events in Unreal Engine 4

Click here to see our guide on making a multiplayer ready damage and health system with custom events.

The post How to use Custom Events in Unreal Engine 4 appeared first on Couch Learn.

How a Line Trace Works

A line trace is a way to check if an object is intersecting a line. The hit data is then broken down access more information such as location of hit, normal of hit. the actor that was hit and distance from hit.

Different Types of Line Traces

“Line Trace for Objects” checks an intersection with a specific collision object type. (WorldStatic, WorldDynamic, Pawn, Ragdoll, PhysicsActor, etc)

“Line Trace by Channel” checks for an intersection with a specific line trace collision channel. (Visibility and Camera are the default options)

“Line Trace by Channel” checks for an intersection with a specific collision profile by name. (These can be viewed and created in the collision tab of the project settings)

How to Calculate the First Person Line Trace

All line traces have the same basic setup. The nodes below setup the vector maths required to check for any collisions wherever the camera is located and facing.

Breaking down the Maths

Firstly you use the FirstPersonCamera variable connected to the GetWorldLocation node to begin the line trace from your character’s camera position.

Next using the Get Controller node, get the controller rotation from the Get Control Rotation node. This will get the rotation of your camera and even works multiplayer games.

Afterwards connect the Get Control Rotation node to the Get Forward Vector node. This will get the direction your camera is facing of your camera.

Multiply this Get Forward Vector value by 5000 (Multiple Vector by Float) to get a point in space from 0,0,0 that is 5000 units away facing the direction of the camera.
(This is the distance away from the camera to check fora collision. Change this to whichever distance you need for your project).

Finally add the Get World Location return value of your First Person Camera to the multiplied value. This gets the point in 3D space that you are looking at 5000 units in front of your camera.

Accessing the Hit Data

Connecting the return value to a branch only allows successful line traces to be accessed. Not including this branch will cause lots of console errors when accessing the hit result data.

To access this data click and drag from the Out Hit value and create a Break Hit Result node.

The Complete First Person Line Trace

This is one example of a complete first person line trace.

To use this system simply connect the execution pins to any event you want e.g. Event Tick or an event

Conclusion

Your project now is setup to use a basic First Person Line Trace in Unreal Engine 4!

Your project can now detect when objects are in front of the camera. Many use this system for weapons, interacting with objects such as doors, pickups and much more!

Further Reading:

Combine this line trace system with our easy AI movement guide to create computer controlled character that can interact with objects! https://couchlearn.com/easy-ai-movement-in-unreal-engine-4/

Unreal Engine’s documentation on single line traces: https://docs.unrealengine.com/en-US/Engine/Physics/Tracing/HowTo/SingleLineTraceByChannel/index.html

Unreal Engine’s full documentation on traces: https://docs.unrealengine.com/en-US/Engine/Physics/Tracing/Overview/index.html

The post Basic First Person Line Trace in Unreal Engine 4 appeared first on Couch Learn.

What is an Enum?

An Enum (also known as Enumeration) is used to give names to integer values.

For example, a basic game menu state can be represented as names and programmed as integer numbers.

– 0 = Mainmenu
– 1 = Game
– 2 = Pause
– 3 = Gameover

All game engines can use enums as they are a basic programming feature. Unreal engine can use enums in c++ and blueprints.

In the next section we will be creating our own Enum in Unreal Engine 4 Blueprints.

Creating the Enum

Firstly, right click the content browser and hover over the blueprints tab.

Click the Enumeration button to make the enum.

Secondly, add the names that you need for your enum.

In this example we will be using mainmenu, game, pause and gameover.

Using the Enum

Lastly, with your new ENUM we can trigger different logic based on the value.

This can be done easily using a switch node.

Right click in any blueprint class and type “Switch on YOUR-ENUM-NAME”. In this case the node is called “Switch on gamestate”.

If you don’t know how to use switch nodes check out our guide here.

Conclusion

Now you have a working blueprint enum in Unreal Engine 4!

Even though this guide is short, We felt it was essential as there are very few guides for creating and using enums in blueprints.

Enums are extremely useful and most projects have many uses.

In future guides we will be using enums frequently which is why this guide is important for the future content of the site!

If you have any suggestions for future guides and projects, let us know by sending a comment below or by contacting us.

Further Resources:
Unreal Engine 4 official enum video (2014)
Our guide on Switch nodes in Unreal Engine 4

The post Enums in Unreal Engine 4 Blueprints appeared first on Couch Learn.

Updating the Project Settings

Firstly, open the project settings menu found in the Edit tab of the editor.

Once the project settings menu is open, click the general settings option.

Now you can access the framerate options.

Fixed Framerate

To make sure that the frame rate can go above the limit, disable Use Fixed Frame Rate.

FPS Smoothing

Smooth Frame Rate will try to make your FPS consistent in the range that you set.

Disabling this will prevent UE4 from adjusting your frame rate.

Console Commands and Game Settings

These settings can be changed in any blueprint. In this example we used the level blueprint.

Disable VSync

Using Unreal Engine 4’s game user settings, VSync (vertical sync) can be disabled.

Vertical sync locks the frame rate of the game to 60fps.

Set Max Framerate

Using the Execute Console Command node we can enable the console command t.maxfps.

This command tells the engine what the maximum frame rate cap should be.

The number after the command is the frame rate cap.

This can be as high or as low as your project requires.

Conclusion

With these settings enabled, your project can now reach the maximum performance without limits or frame rate locks.

For more information on this topic, read the documentation linked below from the official Unreal Engine site.

Further resources:
Smooth frame rate documentation from Unreal Docs
Performance and profiling documentation from Unreal Docs

The post How to Unlock FPS in Unreal Engine 4 appeared first on Couch Learn.

Framerate in the Editor

To show the fps counter inside the editor, firstly press the small arrow button on the top left of the viewport.

On this new menu, in the viewport options section, tick the “Show FPS” box.

In the top right of the viewport, the fps counter is now displayed with the frame time below it. Frame time is the time taken to produce one frame.

16.6ms is 60FPS

Framerate Counter in Game

To show the fps counter inside your game, we will firstly add the F3 keypress event to our character blueprint.

This can be any key you want

From the pressed execution pin, create a new “Execute Console Command” node.

Inside the Execute Console Command node, type stat fps into the command box. This is the command which will be sent to the game to toggle the frame rate counter on and off.

Demonstration

In this demonstration we show the third person example project turning the fps counter on and off during the game.

Conclusion

Your project now has access to the fps counter during editing and when you package your game into a standalone executable!

This fps counter will work correctly for all builds of the game including shipping builds.

There are many different stat commands that can display debug information to the player or tester.

Below are some links to further reading if you would like to look into the stat system further.

Further Resources:
Improve this system with our guide on input actions and input axis.

Official Unreal Engine Statistics documentation.

The post Show FPS Counter in Unreal Engine 4 appeared first on Couch Learn.

In this guide we will be going over what Switch Statements are in Unreal Engine 4 and how they are used in engine.

Switch and Case

The switch statement takes in an input runs different code from that value.

The default value will run if the value doesn’t match.

In this example we will setup the simplest switch node; Switch on Int.

Setting up a Switch Statement

In Unreal Engine 4, new execution pins can be added by clicking on the node and looking in the details panel (on the right by default).

Adding Functionality

Once you have added the new pins we can attach blueprint nodes.

This blueprint code below will print different numbers on the screen based on the random integer.

If the random integer is 6 the code will output “Default”.

Demonstration

Examples of Other Switch Nodes

Switch on String

This node allows you to set the output pins with a string. The output pin will fire if the selection string matches the pin name.

This can also be case sensitive.

Switch on Enum

This node fires different output pins based on the custom enum value of selection.

In this example, I created a new enum named “Example Enum”.

A common use for this node would be for switching between states in your game e.g. Game, Main Menu and Credits shown below.

We are working on a guide on Enums in Unreal Engine 4. It will be linked here on completion.

Download the Project Files

Conclusion

Now you can organize and optimize your blueprints with switch nodes!

Even though this is a simple topic, it is extremely important for improving your overall blueprint code quality.

Extra Reading:

Click here for more information on switch statements in Unreal Engine 4.

Click here for more information on flow control in Unreal Engine 4.

The post Switch Statements in Unreal Engine 4 appeared first on Couch Learn.

When we are finished, our FPS example template character will print the ammo after shooting an will remove one ammo after every shot.

What is a Structure (Struct)

In Unreal Engine 4, the struct is an easy way to create your own variable type, giving you the ability to substantially improve the organisation and access of the data in your blueprints.

One example of using a struct in your UE4 game would be to have a single struct that contains your player’s position, health, ammo and lives.
This then can be saved and loaded as one variable therefore streamlining the process as your game gets more complicated.

In this guide we will be learning how to create a structure and how to use structures in Unreal Engine 4.

Creating the Struct

To create your struct, firstly right click in the content browser and in the bottom section click on the Blueprints tab.

Once in the Blueprints tab, find and click on the option named Struct.

Rename this new file something suitable and save. In this example, I named mine PlayerInfo.

Setting up the Struct

Before we can start to use our new struct we need to fill it with variable types and give them the names that we want that data to be known as.

In my case, I have added a Vector named ‘Player Location’, a Float named ‘Player Health’, an Integer named ‘Player Ammo’ and another Integer named ‘Story Progression’.

This struct can now be added as a new variable in our main character blueprint.

Creating the Struct on our Player Character

To access the struct, simply create a new variable in our main character blueprint and set the type to the name of your struct created earlier.

Compile and save your blueprint to show the values of the struct.

I have set the initial values to 100 for the player’s health and 25 for the player’s ammo.

Accessing the Struct on our Player Character

Getting the Values

To get the values inside our struct, simply type get and then the struct variable name. In my case I typed ‘get PlayerValues’.

From this new get node, right click the pin and click the split struct pin button. This will now expose the values inside the struct.

From this get node, I access the PlayerAmmo value and can then print it to the screen using the Print String node.

This will now display my ammo on screen when the Left Mouse Button is pressed.

Setting the Values

To set the values inside our struct, simply type set and then the name of your struct variable. In this case I typed ‘Set PlayerValues’.

From there, right click the left pin of your Set PlayerValues node and click split struct pin. This will then expose the values of your struct variable which then can be set however you want.

For my character, I access the struct variable and set the Player Ammo value when I have fired my weapon using the Left Mouse Button.

When setting your values make sure to never leave any empty as they will be overwritten!

In the example above I set the location, health and story progression values to the values it already stored.

Example

Every time the player presses the left mouse button the bullet is shot and one bullet is taken away from the ammo. The remaining ammo is then printed on the screen.

Conclusion

Now you have a fully working struct in your project that can now be used to store your player’s current status and progress.

This setup makes your general player variables much more organised and prevents data from being hard to track down.

The struct is a key part of shrinking large areas of blueprints into compact and efficient systems.

With this setup and working you can now create your own new structs for other gameplay tasks and uses.

Further Examples

Structs are great for creating a quest system. Each quest uses the struct for its location, enemies to spawn/ be defeated, gold reward and more.

This then can easily be added to a UMG widget to display the info on screen. Furthermore this can then be saved easily to preserve the player’s progress through the quests in your game.

One essential use for structs is to create an utilize Data Tables.

To read the Unreal Engine 4 documentation on Structs click here.

The post How to use Structs in Unreal Engine 4 appeared first on Couch Learn.

What is the Game Instance

The game instance is a manager class that is not destroyed when changing levels in your game.

This means data such as player health, score, ammo and more can be stored between levels.

The data is kept as long as the game is running.
Once you close your game the data is lost!

Creating your Game Instance

Creating the Class

To create the Game Instance class, right click anywhere in your content browser at the bottom and click ‘Blueprint Class’.

A new dialog box will show and ask which parent class you wish to make.

To create the Game Instance class we need to click the ‘All Classes’ drop down at the bottom.

Clicking this will now show all the classes we can create.

In the search box type Game Instance, click the GameInstance text and then click select to create our new Game Instance.

Now after naming your new Game Instance, it will be shown in the content browser.

Adding Variables

Firstly, to add variables to your new Game Instance, simply double click to open the blueprint editor.

On the left hand side click the + Variable button to add a new variable.

For this example I have created a Float variable called Health that has a default value of 100.

When you are done creating your variables make sure to compile and save!

Accessing your Game Instance

Configuring the Project Settings

Firstly, before you can access your game instance, you will need to configure the game to use the new Game Instance that we just created.

This is a very simple step and only takes a few clicks.

Click edit in the top right, then click on Project Settings.

Once the Project Settings window opens, search for the Maps & Modes option and click on it.

At the bottom of the Maps & Modes section look for the Game Instance Class drop down box.

Click this box and select your new Game Instance class. In my case, I named mine GameInstanceDemo in the previous step.

Accessing and Setting the Variables

To start using your Game Instance right click in any of your blueprints (characters, actors etc) and type get game instance.

This will retrieve the game instance with your set variables.

From the pin of the Get Game Instance node create a cast node to your newly created Game Instance Class.

This cast node is named the same as your Game Instance set earlier.

From this new cast node you can set and get the values of your Game Instance variables.

In this example I will set the health value to 50 and load a new level which will print out the value. This value will stay the same as the Game Instance values are kept over different levels.

Loading the second level will print out the value of Health from our Game Instance. As this value was set to 50 in the first level the print string node will print the value 50 on the screen.

Conclusion

Now that you have the knowledge to use the Game Instance in your Unreal Engine 4 game, you can now adapt this to your user interface through the widget system or onto your player character.

Doing so will give you the ability to switch levels without losing player values such as health, ammo and quest progress.

Those are only a few examples of what the Game Instance can do but there are many more ways to use saved values.

More Complex Uses

Using Discord Rich Presence in your game can be easily accessed by storing the Discord object in the Game Instance.

Click here to learn how to add Discord Rich Presence into your Unreal Engine 4 game.

The post How to use the Game Instance in Unreal Engine 4 appeared first on Couch Learn.