Prerequisites

Before starting this guide you will need a working multiplayer Unreal Engine 5 project and a source build of Unreal Engine.

What is a Dedicated Server?

A dedicated server, in game development terms, is a computer that can run a standalone piece of software which only handles the game world and server code.

It does not spawn a player character and does not count as a connected player.

The first method when setting up networking in a multiplayer game for many is a listen server.

A listen server is perfect for many styles of multiplayer games as it works well with games with small player counts per server (2 to 16), keeps costs down for developers and make developing features easier with faster testing between two clients.

For some games this isn’t ideal as players might cheat, have sync inconsistencies between clients that would be game breaking (fighting games over large latency) and larger scale games causing the host machine to slow down impacting other player’s experiences.

Dedicated servers are perfect to remedy these issues. Running the files that we will be creating on its own machine, with ports setup correctly, will only process your game world and keep an server of your game running 24/7.

Automatic Session

We need our server to automatically create a session and then load the map on launch.

In our example project, which can be downloaded in a first person or third person format, we create our MainMenu widget and add it to the screen in our main menu level blueprint.

We need to adjust this so if it is a dedicated server then we ignore the menus entirely and create a session for our players to join!

To achieve this, we simply add a branch and an “Is Dedicated Server” node before our widget creation.

This is then connected together on the False pin as we don’t want the code to run if our platform is “Dedicated Server”.

On the True pin we then add a Create Advanced Session node with our desired settings.

If our session creation was a success we then open our level with the option ?listen so that our server can accept connections to the map.

Lastly, we compile and save our changes!

Choosing the Default Server Map

By default our dedicated server loads into an engine map called “Entry”. We need to change this to our own map to ensure that we can load players into the game.

Firstly, open the edit menu in the top left and then click Project Settings.

We then click the “Maps & Modes” section of the Project Settings.

We then click the Advanced drop down option in the “Default Maps” section.

Finally, set the “Server Default Map” option to the map that you want to start your server on. In this case we are using our “menu” map and making changes later in the guide to add dedicated server functionality.

No Default Character in the Level

As we are using a dedicated server, we no longer need a character spawned for the authority (server host).

Our level has a character blueprint inside of the level that gets controlled by the first player connected.

We need to remove this to prevent a character standing in the level with no player!

The Project Launcher

The project launcher is a built in tool of Unreal Engine that allows you to build versions of your game based on profiles that you can create.

One of the abilities of the project launcher is the dedicated server!

We can open the project launcher by opening the Tools menu at the top of the editor window and selecting the Project Launcher in the tools section of the menu.

You should now see a large empty menu! We now need to add our custom profile for our game!

We need to create our custom profile to specify to the engine that we want a dedicated server build.

Creating the Custom Profile

Firstly, click the Add button in the bottom right, then click “Create Custom Profile”.

You should now see a large menu of options appear.

In the cook section, we need to open the drop down menu and change “On the fly” to “By the book”.

We then scroll down the Cooked Platforms list and find the server platform we want to build for. For this guide we are building a dedicated server for Windows.

You can choose LinuxServer if you need an x86/64 Linux server or LinuxArm64 if you want to host your server on Linux Arm. If you do not understand this, simply choose WindowsServer.

We then scroll down further and select all of the maps that you want to include in your server. In this guide we have selected both of the maps in the Unreal Engine 5

Next in the Package section, click the drop down menu and change “Do not package” to “Package & store locally”.

This then generates you a default path inside of your project folder to build the server. This can be changed to anywhere you want using the directory picker “Browse” button.

Then, in the Deploy section, click the drop down menu and change “Copy to device” to “Do not deploy”.

Finally, we can give our new profile a name to remember what this Profile builds.

Creating the Dedicated Server

Now that we have our profile all setup, we can now build our dedicated server!

Click the back button to return to the main Project Launcher menu.

We can now see our new profile in the list of custom launch profiles.

Building the Files

To build the dedicated server using our custom profile, simply press the launch button (Controller and display icon).

You now see the process of your dedicated server automatically building!

Now wait until the process has completed. The first time you run your profile it can take a long time. Leave this to fully complete before moving onto the final step!

Testing the Dedicated Server

Now that our dedicated server has built successfully, navigate to the folder you selected earlier to see the executable.

If you left this option default in the previous step, the folder found in your project folder then Saved/StagedBuilds and then the platform name. In this case “WindowsServer“.

From here we can open our Server.exe to open the server. This will open in the background and is hard to monitor and close.

To make this easier to use, firstly create a shortcut in Windows for your server executable.

We then open the executable and add the “-log” launch option to the end of the target section. This will make the server open as a window and print any logging messages on to the screen.

Now open the shortcut to your server and text will fill the window. This is your server initializing and setting up a session for your players to join!

On the client’s view it now shows the dedicated server session!

Demonstration

With three clients open inside the editor and our dedicated server open, the clients can connect to the session and see each other move without needing a full client open to host the game!

Project Files

Conclusion

You now have a dedicated server of your game building with the ability to be connected to!

With this knowledge, you’re one step closer to launching a fully featured multiplayer game that performs well and delivers a consistent experience to players!

Further Reading

• Click here to read the Unreal Engine Dedicated Server Guide
• For more networking fundamentals click here for the UE Networking Overview
• It’s always great to read up on how to build projects based on our learning of the project launcher, Click here for the UE documentation on Building Projects

The post How to build a Dedicated Server for your Unreal Engine 5 Game appeared first on Couch Learn.

• RPG item data table that contains item stats such as damage, armour etc.
• Subtitles for dialogue that can easily be accessed by character name.
• An enemy data table containing a list of pre made enemy types with enemy health, damage, stamina etc.

In this guide we will be showing you how to use Data Tables in your Unreal Engine 5 game.

Pre-requisites

To use Data Tables in Unreal Engine 5 you will need to know how to create and use structures.
Click here to read our guide on structures.

It would also help to know how to create and use an blueprint enum.
Click here to learn about enums in Unreal Engine and how to create them in your project.

What is a Data Table?

In Unreal Engine 5, a Data Table is an extremely useful tool that allows you to define a list of data and store different values for this defined list based on a key.

This data is stored as an asset in your project which makes it incredibly easy to retrieve and update the data from anywhere in your code.

The data is also remembered inside of the editor meaning you can create your data while you are developing your project, then use the data inside of your project during runtime.

A great example of this is data for items or enemies in your project. This data can be set by you when designing your items and enemies which is then saved and persistent.

Making and using Data Tables in Unreal Engine 5 is easy and requires very little work. In the next section we explain how to make your own data table inside of your Unreal Engine 5 project!

Making our Data Table

Creating an Enum

Before we create our struct, we need to create an enum. This is an item rarity enum which will represent the quality of our role playing game item.

Simply create your enum by right clicking the content browser and clicking Enumeration in the Blueprint category.

Then set the values as shown that you require. If you are following along with this guide, copy the values in the image below.

Creating our Struct

Now that we have our enum created, next we need to create the struct that our data table will use for the types of values it will hold.

Right click anywhere in the content browser, then click Structure in the Blueprints category.

Then set the values as shown that you require. If you are following along with this guide, copy the values in the image below.

Creating our Data table

Finally we can create our data table. This is done exactly the same way by right clicking inside of the content browser and clicking the Data Table option in the Miscellaneous category.

Next there is a popup asking which struct you want to use. In this guide we are using the ExampleStruct we made earlier.

Adding Values to the Data Table

Now that are data table is created and configured correctly, we can press the Add button to add a new row to our data table.

As you can see in the image below, the data table has a new row with some default values from our struct.

We can change the values in the “Row Editor” and the values in the data table will change above.

We can now create as many entries as we want!

Clicking the row name section in the row, we can change the row name. In this example we are using BronzeSword as the new row name.

The Damage, Rarity, and Sell Price values we defined earlier are in the Data Table view, and the Row Editor below.

Changing the values in the Row Editor will affect the values stored in the data table.

Don’t forget to Save often to prevent losing your changes!

Using your Data Table

Now that we have our data table created, configured, and filled with data, we can now learn how to access this data in our code.

We have create an Event BeginPlay node to our level blueprint and have created a Get Data Table Row node.

This Get Data Table Row node asks for a data table asset reference, and a row name.

Data Table reference is our data table we created earlier, and the Row Name is the row we want to try to find the data for.

If the row is found, the Row Found pin will run code and the Out Row will contain our data, if the row is not found, the Row Not Found pin will run code and the Out Row data will be invalid.

We can set the Data Table reference by clicking on the select asset drop down and selecting our data table from the list of assets.

Now we can split the Out Row struct by right clicking and clicking Split Struct Pin in the menu. This will split our struct into all the types and values in contains for easy visibility.

We can also see that our Row Name is now a drop down that contains all the available row names. This can be overridden by connecting a value to the Row Name pink pin.

Now that we have split our Out Row struct, we can see the Damage, Rarity, and Sell Price values we set earlier.

Looping over your Data Table Rows

Now that we can access a specific row in our data table, it is essential to know how to use a loop with a data table.

In the example below we have created a Get Data Table Row Names node. This returns an Array with all of the row names inside of the data table.

We can then connect this to a For Each Loop node. This will now run the Loop Body for each Row Name in the Out Row Names from our Data Table.

Finally connecting our For Each Loop into a Get Data Table Row like before, we can then connect the Array Element pink pin to the Row Name pink pin.

This will now get the data for that row name each time the loop runs.

We can then use the Out Row values however we want in the project!

Conclusion

Now you have learned how to create, configure, populate, and implement data tables in your Unreal Engine 5 project!

Almost every Unreal Engine project benefits from using a data table to efficiently and neatly store data for use within the systems you develop.

Working collaboratively using data tables makes sharing a single source of truth for your projects data simple and does not require any C++ knowledge!

Further Reading:

• A more advanced look into Data Table merging and composite tables from Unreal Engine 5’s wiki
• A great visual guide for Data Tables by Gorka Games (Not affiliated with CouchLearn)
• The official Unreal Engine 5 documentation for Data Tables in Blueprints

The post How to use Data Tables in your Unreal Engine 5 game appeared first on Couch Learn.

Prerequisites

This guide expects a basic level of knowledge of C++ in Unreal Engine 5.

To follow this guide you also need to have one of the following:

• Visual Studio for Windows
  or
• XCode for MacOS

These programs are used to compile the C++ code into your project. If you do not have a IDE installed, the engine will prompt you to install one.

What is a C++ Blueprint Function Library

The C++ Blueprint Library is a built in Unreal Engine class that allows code to be written using the C++ programming language to be used in both C++ code or in Blueprints!

This means we can move our slow blueprints nodes into optimised C++ code then run these functions inside of our blueprint code.

This gives us the power of C++ inside of blueprints in an easily accessible form!

How to create a C++ Blueprint Function Library

C++ Project vs Blueprint Project

Firstly, we need to find out if our project is a C++ enabled project, or only a blueprint enabled project. Luckily this is easy to do!

Click the Tools drop down at the top of the screen, then click “New C++ Class“.

If you do not have one of the preqrequisite programs installed as explained earlier, the engine will instruct you what you need to install.

In our case, for this guide, we used a MacOS machine, and so we installed XCode.

Next, the dialog box will appear asking which type of “Parent Class” you wish to use when creating your new class.

As we are making a C++ blueprint function library, we scroll down near the bottom and click “Blueprint Function Library”. To move to the next section, we press the blue NEXT button.

We then are asked to choose a name for our new blueprint function library class.

In this guide we used the default name “MyBlueprintFunctionLibrary”. You can change this to your choice of name.

We recommend a clear name with capital letters for each word in the name to follow Unreal Engine 5’s naming convention.

After naming our class and clicking the Create Class button, our project then compiles the new files for us to use. Wait for this to complete before moving on the next section.

Inside your Code IDE

Now that our new class has been created, we can now open our IDE of choice and look at the files Unreal Engine has created for us.

As we chose “MyBlueprintFunctionLibrary” as our class name, we can see that we have two files. A .cpp file for our code, and a .h header file for our declarations both with our chosen name.

Add functions

Now we are ready to add our C++ code to add functionality to our Blueprint Function Library.

For this guide we are making a simple read and write system for strings. This will take our string and save it to a specified file, and can also read a file into a Unreal Engine string.

For your project, you can write the C++ code necessary for your required features.

First in our header file we can see that the engine has generated us a basic file with the correct includes and inheritance for our class.

Next we add our function declaration. We have added a basic function that returns a true or false bool based on if we can save the string to the file or not.

The most important part is to use the static keyword. This makes our function accessible anywhere without an object reference!

We then must add our UFUNCTION macro to make our function visible inside of our blueprint editor.

Next, we repeat the same as before with our loading string from file function. As before it is static with a UFUNCTION macro for blueprint compatibility.

Lastly, we open the .cpp file and add our function code.

This is a simple use of the FFileHelper library in Unreal Engine 5 to allow us to read and write strings to files.

Our Blueprint Function Library is now a powerful example of what we can do when we need access to C++ functionality inside of our blueprints!

Once you have completed this step, compile your project and relaunch the editor.

How to use the C++ Blueprint Function Library in Blueprints

Finally, we can open any blueprint editor and type the name of our new blueprint function libary.

We can see in the actions pop up box that our two “Load String to File” and “Save String to File” C++ functions are now exposed to the blueprints system!

Demonstration

To demonstrate our functions working, we opened the level blueprint, created a BeginPlay event, and connected our new Save String to File C++ Blueprint Library function to it.

We can specify any string to save, and choose a file name.

After running this with “Save Test” as the String to Save and textfile-test.txt as the File Name, we can see in the project /Saved folder our file and string!

Lastly, we can test our Load String from File function inside of the editor the same way.

We have created the loadtest.txt file in the /Saved folder of our project, and written the string “Loading Test” into it and saved.

Inside of the level blueprint we then add our Load String from File C++ Blueprint Function Library function and connected it to a print string node.

This will load of text file into a string and print it to the screen.

As you can see, after playing our project in the editor, our string from inside our file is show on screen!

Conclusion

Now you understand how to use C++ Blueprint Function Libraries in Unreal Engine 5!

The use of these function libraries gives tangible performance improvements and also unlocks the hidden functionality inside of the engine; exposing this to your blueprint code!

Further Reading

Official blueprint function library documentation from Epic Games
Click here to read more of our C++ guides for Unreal Engine

The post How to use C++ Blueprint Function Library in UE5 appeared first on Couch Learn.

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.

Prerequisites

To follow this guide you need to understand the basics of Unreal Engine, working with blueprints inside the editor and using a custom Game Instance. We have linked guides below to these topics.
The basics of blueprint actors.
Adding variables to blueprint actors.
How to use custom Game Instances.
Custom Events in Unreal Engine.

It would also be beneficial to understand how Input Actions work in Unreal Engine:
Click here to learn how to use input actions and axis.

How it Works

SaveGame is a class in Unreal Engine that is preconfigured to save and load the data contained in the variables you add.

The variables you set are then saved to a file stored on the user’s machine. This is then read and the variables can be accessed in your game.

The save file is located in these locations:
Windows: Local Appdata folder
MacOS: Library/Application Support
Linux: /home/username/.local/share

Almost every variable type can be saved and loaded using the SaveGame class.

Creating our Save Class

Firstly, create a new blueprint class from the content drawer.

Next, in the popup window, click the drop down arrow at the bottom. In the search bar type “SaveGame” and click the option from the list.

Then, give your new SaveGame blueprint a suitable name. We need to remember this as it is used later. In our case, we used the name DemoSaveGame.

Saving the variables

Now that your SaveGame class has been created, you can add any variables you need for your project.

For this demo we create a new Vector variable called “PlayerPosition”.

Once you have created the variables you need for your project, click Compile and Save to ensure your changes are applied and saved.

Adding Save and Load Functionality

Firstly, in our Game Instance, add two new custom events. “Save” and “Load”.

We also need to add a new variable on the Game Instance. Name this variable SaveGame and set the type to the class you created in the previous step.

Loading our Variables from the Save File

Now that our Game Instance is setup, on the Load event, create a new “Does Save Game Exist” node. The “Slot Name” pin needs to be given a name. This can be set to anything you want. Each different name you use saves to a different file.

In our case we just named this “savegame”.

Next, add a branch to the output pin of the “Does Save Game Exist” node. This will branch if our save file exists or not.

If the Save File Exists

From the “True” pin, create a new “Load Game From Slot” node with the same “Slot Name” as before.

Next, from the blue output pin, create a “Cast to” node. This should cast to the class you created in the first step. For us this is “Cast to DemoSaveGame”.

Then set the Game Instance’s Save Game variable we created earlier to the output of the “Cast to” node.

From there, we create a “Set Actor Location” node. This will be used to move our character to the saved location.

From the variables list on the left of the editor, drag the “SaveGame” variable and drop near the the nodes. This will show a list of options. Click the “Get SaveGame” option to allow us easy access to this variable for the next few steps.

Dragging from the “Save Game” blue pin then typing “get player position”, we can see our “Player Position” Vector variable that we created earlier. Click this option in the list to add it to the blueprint graph.

Next, connect the “Player Position” vector pin to the “New Location” option on the “Set Actor Location” node.

Lastly, create a “Get Player Character” node and connect this to the “Target” pin of the “Set Actor Location” node. This now gets our saved player position and moves the player character to it.

If the Save File doesn’t Exist

If the save file does not exist then we need to create a new file. From the “False” pin create a new “Create Save Game Object” node. Then set the “Save Game Class” purple pin to the custom SaveGame class we created earlier.

Then, set the Game Instance “Save Game” variable to the blue output pin value.

Lastly, connect the “Set Save Game” node to the blueprint nodes above. This can be done by double clicking the white lines to create points.

Connect the blueprints nodes together as shown in the image below.

Saving our Variables to the Save File

Now that we can load saved variables, we need to save the variables!

Firstly, drag and drop the SaveGame variable and click “Get SaveGame” next to the Save event.

From there, we create an “? Is Valid” node. This allows us to branch the code if our save file has been loaded or not.

If the Save File is Valid

From our “Save Game” blue variable, create a “Set Player Position” node and connect it to the “Is Valid” pin.

Next, create a “Get Player Character” node and from the blue output pin, create a “Get Actor Location” pin.

Lastly, connect the yellow output pin of the “Get Actor Location” node to the yellow input pin on the “Set Player Position” node. Now if our save game object is valid we will save the player character location to the save file on disk.

If the Save File is not Valid

If the save game object isn’t valid, we need to create it before saving any data.

Firstly, create a “Create Save Game Object” node, set the purple input value to our previously created save game class, then connect this to the “Is Not Valid” pin as shown below.

Next, set the Game Instance SaveGame variable to the blue output pin of the “Create Save Game Object” node.

Then, connect the “Set Save Game” node to the “Set Player Position” node as shown below. This will save the player character’s position after the “Save Game” object is valid.

Finally, create either a “Save Game to Slot” or “Async Save Game to Slot” node from the blue SaveGame variable.

If your game needs to save lots of information, use the “Async Save Game to Slot” node.

If your game only saves a small amount of data, use the “Save Game to Slot” node.

Make sure to set the “Slot Name” variable to the name you used earlier. In our case this was “savegame”.

Saving and Loading the Player Position

Now that your Save and Load system is complete, we need to trigger this functionality.

In your Player Character class add an Key Press Event. For this guide we used the number 1 key from our ThirdPersonCharacterBP class.

From there, create a “Get Game Instance” node and a “Cast To” node to your custom game instance. Connect the two as shown below.

Next, from the blue “As Game Instance” pin, call the “Save” event we created earlier. Now when we press the number 1 key, our game will save the current player character’s position to the save file.

Repeat the previous step for the number 2 key as shown in the image below.

Finally, call the “Load” event from the “As Game Instance” blue pin. This will now load our saved player position from the save file and teleport our player to that position.

Demo

Download the Project Files

Conclusion

Now your project has saving and loading capabilities!

This is a very basic implementation but allows you to expand this further. Any data you want to save and load can be implemented into the events we created during this guide.

An example of this would be the player’s health. This variable could be created on the SaveGame, saved and loaded onto the character with minimal setup.

Further Reading:
Official UE4/5 documentation for the Saving and Loading in the engine.
Tom Looman’s great guide for implementing Saving and Loading for C++ classes

The post How to Save and Load in Unreal Engine 5 appeared first on Couch Learn.

Unreal Marketplace Plugins

Firstly, open the Epic Games Launcher and navigate to the Unreal Marketplace.

Next, in the “Browse” tab, click the “Code Plugins” option.

Then, choose the plugin you want to install. For this guide we are using the VaRest network plugin.

If you do not already own the plugin, click add to cart and complete the purchase.

Free plugins still need to be “purchased” but you are not charged.

As these plugins are installed to the engine, we need to click the “Install to Engine” button.

Then, choose the engine version you would like to install the plugin to.

Lastly, the plugin is now shown in the downloads tab of the Epic Games Launcher. Once the plugin has been successfully installed continue to the final step.

Enabling the Plugin

New plugins are not enabled in the project by default. This is to prevent all projects building unnecessary code and increasing your executable size. In this final step we need to enable the plugin on your project.

Firstly, to enable the plugin, click “Edit” then “Plugins”.

Once the Plugins tab has opened, type the name of the plugin in the search box to find the newly installed plugin details.

Finally, click the check box for the plugin, then click the “Restart Now” button. This will restart the editor and allow use of the plugin in C++ and Blueprints.

Manually Installed Plugins (Advanced)

Disclaimer

BE CAREFUL when downloading untrusted files and code online.

Only download Unreal Engine plugins from trusted sources.

CouchLearn is not responsible for any damage caused by downloading unknown files.

Make sure the plugin you are downloading is compatible with the version of Unreal Engine 5 that you have installed.

Installing the Plugin

To demonstrate the steps of installing a UE5 plugin manually, we will be using the Victory BP plugin by Rama.

Firstly, we need to make sure your project folder contains a “Plugins” folder.

If this folder does not exist, simply create a new folder named “Plugins”.

Then, copy your plugin’s folder into the Plugins folder shown above.

For example we copied the VictoryPlugin folder compatible with Unreal Engine 5.0 into the Plugins folder of the project.

Inside this folder is the plugin files downloaded from the Victory Plugin Unreal Engine forums page.

Enabling the Plugin

Plugins are not enabled by default. This is to prevent all projects building unnecessary code and increasing your executable size. In this final step we need to enable the plugin on your project.

Firstly, to enable the plugin, click “Edit” then “Plugins”.

Once the Plugins tab has opened, type the name of the plugin in the search box to find the newly installed plugin details.

Finally, click the check box for the plugin, then click the “Restart Now” button. This will restart the editor and allow use of the plugin in C++ and Blueprints.

Conclusion

Now your Unreal Engine 5 project has new functionality!

Plugins can infinitely extend the functionality of your project, the engine, and even the editor itself! The Unreal Engine Marketplace has hundreds of quality plugins that can give your project the features you need to realize your vision!

Further Reading:
Click here to read the official documentation for making your own plugins in Unreal Engine
Click here to see the code plugins on the Unreal Engine Marketplace

The post How to Install Plugins for 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.