• 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

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.

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.

Online and LAN Support

Unreal Engine 5’s NULL online subsystem can not find sessions outside of the player’s local network.

To find and connect to sessions outside of your local network without a direct IP address connection you need to use a different online subsystem such as Steam.

Click here to read the documentation for the Steam subsystem

Creating our Widget

Creating the Widget Blueprint

To allow our players to create their own sessions and join others we need to create buttons and text on screen. In Unreal Engine 5 this is called a user interface widget.

Firstly, right click in the content drawer and create a Widget Blueprint

Click “User Widget” in the menu that pops up.

Now we have to name our widget blueprint. For this guide we named the blueprint “Session Widget”. You can name your widget blueprint anything you like but make sure to remember the name for a later step!

Finally, double click your widget blueprint and you will see the Widget Designer window.

Designing our Widget

When designing widgets, you can find all available widget elements in the left side Palette menu.

To start designing your session widget, simply search for Canvas Panel and drag it into the middle section of the window.

Next, search for Vertical Box and drag it into the middle section of the window. These layout elements will be the main structure of your widget.

From there find the details panel on the right side of the window. Click Anchors and select the center box option shown in the image below.

After setting the anchors correctly we can begin to set the size and position of our widget.

Below the anchors drop down, set Position X, Position Y, Size X, and Size Y to the values shown in the image below.

Now, in the Palette menu, create two buttons. These will be interactable by the user to create and join multiplayer game sessions.

So we can access the buttons in the next step, click the first button and change the name in the details panel to CreateSession.

Repeat this for the next button and name it JoinSession.

To show to the user which button is used for creating and joining we need to add text to the buttons.

In the Palette menu search Text and drag the text onto the button. As you can see the text appears on the button and automatically resizes it so it fits well.

After creating one text element for each button, change the Text value for each Text element in the right side Details panel.

Set the top button to Create Session and the second button to Join Session.

Now to improve the design of our buttons, select both buttons and in the right side Details panel set Padding to 15 and click Fill.

Now our widget buttons are neatly arranged and easy for the players to use.

Once you are done customizing your widget, click Compile and Save to ensure your changes are applied.

Finally, click the Graph button on the top right side. This will switch the Widget Designer to the Widget Blueprint editor ready to give functionality to your widget!

Hosting and Joining a Multiplayer Session

Creating and Hosting our Game Session

Now that we are in the Widget Blueprint editor, you should see your two buttons in the Variables section on the left.

Click the first button in the list.

Below you should now see a Details menu with all of the events available to your button.

We need On Clicked so click the big green box with the plus icon inside to add this event.

You should now see the On Clicked event for your button in the middle editor window.

Right click anywhere and type Create Session. Click the option in the menu that shows Create Session.

Now connect the nodes together using the white arrows as shown below.

Right click anywhere and type Get Player Controller. Click the option in the menu and connect this to the blue pin.

After the blue pin is connected, set the Public Connections number to the maximum amount of players you want per game session.

Opening Levels to Multiplayer

Right click anywhere, type and select the Open Level option and connect this node to the On Success pin.

To create a multiplayer game using your level, set the “Level Name” pin to the level you wish to play on. In our case, this is FirstPersonExampleMap.

Lastly, click the drop down arrow and into the Options text box type:

?listen

With these steps complete, the code should look like this.

This code sets the level up to listen for multiplayer connections as a Listen Server.

Connecting to your Multiplayer Session

Finding Sessions

Finding multiplayer sessions using Unreal Engine 5 blueprints is incredibly simple.

The Find Sessions node searches and finds the active game sessions for your players to join. It outputs different execution pins based on if it succeeded or failed. The session results are returned as an array.

If you aren’t familiar with arrays click here to learn about arrays in Unreal Engine.

Firstly, we need to create the On Clicked button event for our JoinSession button, as we did in the previous step.

From there, right click and create the Find Sessions and Get Player Controller nodes. Connect this node to the On Clicked event, connect the Get Player Controller node to the blue pin, and set Max Results to 100.

Max results is the amount of sessions it will try to find.

Joining the Session

Next, we need to create the Join session node and another Get Player Controller node. We could reuse the previous node but it makes the blueprints easier to read.

The Join Session node should be connected to the On Success pin on the Find Session node.

From the Results square pin, drag and let go to open the blueprint node menu. We can then type get and create a Get (a copy) node.

Finally, connect the Dark blue pin of the Get node and connect this to the Search Result input node.

Adding our Widget to the Screen

To make our widget show on the screen, firstly click the branch icon in the main editor window shown below.

In the drop down menu click Open Level Blueprint to open the Level Blueprint Editor.

Right click anywhere and create the Event Begin Play and Create Widget blueprint nodes.

Connect the white pins together and select your widget in the Class drop down box.

In our case we named the widget SessionWidget to make it easy to find in the drop down box.

Lastly, create an Add to Viewport blueprint node and connect the blue pins together. This will create our widget and then add to the game screen.

The final level blueprint should look like this.

Opening the Game Clients

For the last step we need to test our blueprint logic!

Unreal Engine 5 makes testing multiplayer in the editor extremely simple.

First, click the three dot button and, in the drop down menu, set Number of Players to 2. After that click New Editor Window to launch two windows of your game.

Once the two clients have loaded, click Create Session on one and Join Session on the other. After a short amount of time they will connect together in a multiplayer session!

As you can see in the demo below, the players can move around and see each other moving without any additional work! The template character in Unreal Engine 5 have multiplayer movement support out of the box.

Connecting to Sessions Outside your Local Internet Network

The session and listen server created in this guide can be connected to inside your local network by default and world wide through the internet with a few additional steps.

If you wish to host your session to global internet users, you need to port forward UDP/TCP 7777. Setting up port forwarding is different per router so check your specific router instructions.

If you don’t know what port forwarding is click here.

Download the Project Files

We create these free guides and resources on Game Development to give anyone the knowledge to make their own games. If you find these guides helpful please consider supporting us by purchasing our project files.

To improve your multiplayer sessions gameplay, we have bundled a session browser into the project files!

Conclusion

Your project can now create and join multiplayer sessions!

This guide was created to make the initial multiplayer setup as easy as possible. Unreal Engine 5 has extremely robust and powerful multiplayer tools to make any multiplayer game you want!

To learn more about replication and the session system, the Unreal Engine documentation is the best place to improve your knowledge about multiplayer development.

Click here to read more about Replication.

Click here to read more about the session system nodes.

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

What are LODs?

LOD (Level of Detail) is a technique found in all game engines that switches between different complexities of a 3D mesh over distance to reduce the amount of polygons that are needed to draw the scene.

These LODs, when setup correctly, will improve your games GPU performance!

Creating Levels of Detail

Firstly, to automatically generate different LODs for your skeletal mesh, open the mesh from the content browser.

Once the mesh is shown find the LOD Settings tab in the details section on the left.

Increase the “Number of LODs” slider to the amount that you want, then press the “Regenerate” button.

For this guide we chose four LODs. You can create and setup as many levels of detail you need for your specific mesh.

Setting up the Level of Detail

Firstly, inside the LOD drop down box, select the LOD level you wish to adjust.

Then, as LOD 0 is our full detail mesh, we want to change LOD 1 first.

Changing the LOD Distance

Inside the LOD Info drop down adjust the screen size value to the size we want for this LOD to be visible on the screen.

For this mesh we used these screen size values:

• LOD 0: 1.1
• LOD 1: 1.0
• LOD 2: 0.75
• LOD 3: 0.2

These values give the model a high quality look then quickly drops the mesh detail down over longer distances.

Reducing the Triangles

Inside the “LOD Info” drop down find the “Reduction Settings” section and adjust the “Percent of Triangles” value to what ever you require.

0.85 (15% reduction in triangles) works well for this skeletal mesh at LOD level 1.

For this guide we used these percent of triangle values:

• LOD 0: 1.0
• LOD 1: 0.85
• LOD 2: 0.45
• LOD 3: 0.1

Demonstration

Finally, with the settings used in this guide, the skeletal mesh will change between these LOD states based on the distance from the camera.

This reduced the complexity of the model, boosted your game’s performance whilst maintaining a high level of detail and quality at shorter distances.

Conclusion

Now your skeletal meshes are setup to dynamically change in quality over distance!

This simple setup drastically improves performance for lower end machines as is essential for an optimised game.

This technique is not a silver bullet for performance, but if implemented correctly, will increase the performance on many PCs when using high poly meshes.

This technique in conjunction with the static mesh level of detail setup will allow your game to contain more meshes and allow higher detail scenes without affecting performance heavily!

Click here to read the official documentation for the skeletal mesh reduction tool in Unreal Engine 4

Click here to setup automatically generating levels of detail for your static meshes in Unreal Engine 4

The post Easy LODs for Skeletal Meshes in Unreal Engine 4 appeared first on Couch Learn.

Smoothing the Turning

Firstly, click the top section of the character in the top left side of the editor window.

In our case this is AITestCharacter(self).

This will now show the character and actor information in the details section on the right.

In the Pawn section, Untick the “Use Controller Rotation Yaw”

Next, click the “CharacterMovement (Inherited)” section to show the character movement settings on the right.

In the top right search box type “rotation” to show the related options.

In the Character Movement Rotation Settings tab, change the Z Rotation Rate value to 180 and tick the “Orient Rotation to Movement” box.

Demonstration

In this demo we show AI smooth rotation in Unreal Engine 4 that use the Troll mesh and animations from the Troll Pack PBR asset pack found on the Unreal Marketplace by InfinityPBR.

Instant AI Rotation

Smooth AI Rotation

Conclusion

Your AI characters now rotation smoothly and can be customised based on the agility of your game characters!

Let us know in the comments or contact us directly if you have any problems or want to request new Unreal Engine 4 topics.

Further Reading:

To enable your AI characters to roam large open worlds, check out our guide on enabling dynamic nav mesh generation.

To read more about AI in Unreal Engine, click here to read the official documentation on Behaviour Trees.

The post How to Smoothly Rotate AI Characters in Unreal Engine 4 appeared first on Couch Learn.

Prerequisites

This guide expects that you understand how to use basic nodes such as branch, get player controller and input actions / events.

If you do not know how to use input actions in Unreal Engine 4 click here to read our guide.

This guide also expects that you know what a line trace is and how to set them up for a first person style game.

If you do not know how to setup first person line traces click here to read our guide.

How Unreal’s Damage System works

How to Deal Damage

The most basic way to deal damage to another actor is to use the “Apply Damage” node.

Here are the important variables to set:

Damaged Actor – The actor that you want to damage
Base Damage – The amount of damage to apply to the damaged actor
Damage Causer – The actor that applied the damage to the damaged actor

How to Detect Damage

When added to any actors event graph, the “Event AnyDamage” event node runs every time the actor is damaged.

Here are the important variables to use from the event node:

Damage – The amount of damage that is detected
Damage Causer – The actor that dealt the damage

Creating the Weapon Damage Nodes

We recommend using the default First Person Shooter template for this guide.

This damage system works will all game types but when learning a new system it is easier to have a template that works well before you start.

The First Person Shooter template has a player character setup with movement, mouse aiming, arm and gun models and animations.

Requesting to Shoot to the server

Firstly, to make the weapon damage run correctly on multiplayer, create a new custom event called “Net Shoot Weapon”.

Then click the new event (Net Shoot Weapon) and in the detail panel on the right of the screen change the “Replicates” drop down box to “Run on Server”.

Changing this setting will now run this event from the client to the server. This prevents cheating as all damage and collision checking will be done server side.

Next create an InputAction Fire event (included in the first person shooter template) and create a Net Shoot Weapon node to the Pressed pin.

This will send a message to the server to shoot your gun and calculate the

Finally for this section to be complete, connect the animation and sound effect blueprint nodes from the template to the Net Shoot Weapon execution pin.

This complete section will look like this:

Syncing the Animation and Sounds

The animation and sound effects running on the previous step don’t currently run for other players.

To play the animation and sound for this player on everyone else’s screens we need to create a multi cast event.

Firstly, add a new custom event named “Multi Weapon Animation”.

And change the “Replicates” to “Multicast”.

Create a branch node, a Get Player Controller node and a Get Controller node.

From the Get Player Controller node create an equals node and connect the “Get Controller” node to the bottom pin as shown below.

The last nodes required for this step can be copied and pasted from the step above.

The complete section looks like this:

Server-side Weapon Shooting

Firstly, from the “Net Shoot Weapon” event created earlier in this guide, we need to create a “Multi Weapon Animation” node and connect it together.

This will sync the animation and sound to all clients on the server whenever a player shoots.

To damage another actor when the request is received, we first will need to use a Line Trace for Objects node.

If you do not know how to setup a line trace click here to read our guide on first person line traces in Unreal Engine 4

From the line trace we need to create an “Apply Damage” node and connect the “Hit Actor” pin from the “Break Hit Result” node to the “Damaged Actor” pin on the “Apply Damage” node.

Set the “Base Damage” value to the damage that you want your weapon to deal. (We used 15.0 in this case)

Lastly, create a Self node and connect it to the “Damage Causer” pin.

After all these steps, the line trace connections should look like this:

And here is the complete Net Shoot Weapon event blueprint nodes:

Receiving the Damage

Firstly create an AnyDamage event in the actor that you want to receive damage.

Create a new variable named “Health” with the type of float. This will be used to store the amount of health the actor has.

Set the default value of the “Health” variable to 100 (or whichever you want your actors max health to be)

Next create a Get node for Health, subtract Damage from Health and then set Health to this new value.

From the Set Health node create a “Less than or Equal” node, create a branch node and connect them together. This checks if the player’s health is less than or equal to zero after taking the damage

Finally, on the True execution pin create a “SetActorLocation” node and set the New Location value to where you want your actors to respawn when they run out of health.

Here is the complete Event AnyDamage blueprint nodes:

Demonstration

To visualise the health of the hit player easier we added a “Print String” node here:

Download the Project Files

Conclusion

Now your game or project has a fully multiplayer compatible damage system all using blueprints!

Expanding this System

To improve this system you could add a widget to the screen showing when a player is defeated and with what weapon they were defeated by.

Another way to improve this shooter style game would be to add attenuation to the shooting sound effects.

This would reduce the volume over distance and make the game more realistic. Click here to check out our guide on attenuation in Unreal Engine 4.

Lastly, try expanding from this guide by creating AI character with health and damage with our easy AI movement guide. https://couchlearn.com/easy-ai-movement-in-unreal-engine-4/

Further Reading

Unreal Engine’s blog post on their damage system: https://www.unrealengine.com/en-US/blog/damage-in-ue4#:~:text=Damage%20support%20is%20a%20feature,your%20damage%20model%20when%20needed.

The full damage blueprint node documentation can be found here: https://docs.unrealengine.com/en-US/BlueprintAPI/Game/Damage/index.html

The post Multiplayer Damage and Health System 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 are LODs?

LOD (Level of Detail) is a technique found in all game engines that switches between different complexities of a 3D mesh over distance to reduce the amount of polygons that are needed to draw the scene.

These LODs, when setup correctly, will improve your games GPU performance!

Creating Levels of Detail

Firstly, to automatically generate different LODs for your static mesh, open the mesh from the content browser.

Once the mesh is shown find the LOD Settings tab in the details section on the right.

In the LOD settings section, increase the “Number of LODs” section to the amount of different levels of detail you want Unreal Engine to automatically generate.

Before we start, untick the Auto Computer LOD Distance box.

For this guide we are using four levels of detail.

Once this is done, press the Apply Changes button.

Reducing the Triangles

Underneath the LOD Picker section of the detail menu, you will see the current selected LOD.

As the LOD is set to AUTO the current LOD visible is based on the distance to the camera in the editor’s viewport.

To change which LOD you are adjusting, press the LOD drop down and select which LOD distance you want to edit.

To change the reduction amount for the selected LOD, simply open the reduction settings tab.

To lower the quality of this LOD, change the “Percent Triangles” to a smaller percentage.

The best method is to lower the percentage slowly over the different LODs.

For this guide I have setup the Percent Triangles like so:
LOD 0: 100.0
LOD 1: 85.0
LOD 2: 65.0
LOD 3: 35.0

Setting the Distances

To switch between the different LODs, the engine uses the screen size setting. This determines how big the object is on the screen before it changes LOD state.

To change this value, select the LOD that you want to edit in the LOD Picker above and find the Screen Size box. Change this value to what you think is best for your meshes.

Its best to tweak these values and test until you find a sweet spot for the asset that you are configuring.

For this guide I have setup the distances like so:
LOD 0: 1.0
LOD 1: 0.55
LOD 2: 0.175
LOD 3: 0.035

Demonstration

Creating a blueprint that uses the newly adjusted mesh or just dragging in your new mesh into the level will automatically switch between the LODs.

As you can see in the video below the triangles used to render the object is heavily reduced.

Conclusion

Now your meshes fade between LOD states improving performance for your game!

This technique is essential for creating games that will perform well on many different power of PCs and other platforms.

To improve on this, enable LOD dithering to fade between LOD states smoothly. Click here for a link to our guide on using LOD Dithering in Unreal Engine 4!

For more information on LODs in Unreal Engine 4 click here for the official documentation: https://docs.unrealengine.com/en-US/Engine/Content/Types/StaticMeshes/HowTo/index.html

The post Easy LODs for Static Meshes in Unreal Engine 4 appeared first on Couch Learn.

Before we Start

To enable these features, dynamic pathfinding must be enabled to allow the navigation mesh to generate during runtime.

To learn how to enable dynamic generation during runtime click here for our guide.

Only the areas of the level that possessed pawns are near will be generated.

Enabling Generation around Nav Invokers

To enable this setting we must firstly go to the project settings.

Once the project settings are open, click on the Navigation System tab.

Tick the checkbox named: Generate Navigation Only Around Navigation Invoker.

This tells the engine to only generate around actors that have the navigation invoker component.

Nav Invoker Component

To enable navigation generation on an actor, we first need to add the Navigation Invoker Component.

To add this to your actor, click the Add Component button in the top left of your blueprint editor and search for Navigation Invoker.

Once this component is added, setup the radius that the navigation mesh will be generated and removed.

From my testing, the default values work well for open world landscape levels.

When creating a procedurally generated indoor level, I recommend slightly higher values.

This prevents the actor from being trapped in their current room or area.

Demonstration and Example Files

Conclusion

That is all for enabling open world navigation in Unreal Engine 4!

Characters and pawns can now traverse large open or procedurally generated levels.

For further reading into the navigation functions in Unreal Engine, click here for the official documentation.

The post Open World Navigation in Unreal Engine 4 appeared first on Couch Learn.