Hello, in this video, I will be going over all of the essential nodes that I think everyone should know when making a game in Unreal Engine.

To get started, I'm in the third-person template, and I'm also just going to go over to my content drawer, to the third-person folder, and to the blueprint order, and we're just going to create a blueprint example.

Okay, so let's get started. If I just go over to my blueprint example and go over to the event graph, this is where we write most of the code for how our blueprints will behave.

And one of the most essential nodes is Event Begin Play. So the way this will work is as soon as our game starts, it will fire this node.

So for our sphere, Event Begin Play, we can just drag in our sphere, then drag off here and look for Set Material, and let's set it so it has this basic asset O1 material.

We can connect from Event Begin Play into here and just go compile.

And if I close this and then drag my BP example somewhere into my level, right now we can see it's this white sphere, although if I play my game, we can see it will turn to that basic 01 material.

So that's how the Event Begin Play node works.

It's very simple. Next, if we head back to our BP example, and let's just go over how to use these other nodes. So this Event Actor Begin Overlap, so as the name implies, when something overlaps this actor, it's going to fire this node.

So if we just select our sphere, we just want to scroll down, and right now as collision presets are set to block all dynamic, we just want to change this to be overlap all and make sure that generate overlap events is true.

And what we can do is if I hold the Alt button on my keyboard and select here, this will break the link here, so this node will no longer work.

And if I just connect from event act to overlap into here and just go compile, if I play my game right now, it is white.

If say my player overlaps it, then it will basically turn that color. So when something overlaps this actor, it will turn that color.

And then the final basic node we have is the event tick node. So the way this will work is every single frame is going to fire this node.

So if I just drag off event tick and look for print string, every single frame is going to fire this node.

So I just go compile, close this, and I go play. On the left corner, we can see it's print stringing hello every single frame.

So if you have a computer which is running at 60 frames per second, every single frame is going to be printing that string.

Next, let's go over some variables and some essential nodes you'll use with them. If we just open up the BP example and go over to the variables tab and just go create new variable and just call this Boolean example.

And for the variable type, make sure it's a Boolean.

Just compile this. Now, Boolean can be either true or false. And if I just drag in my Boolean example get it, and then just drag off here and look for branch.

And let's just connect this from event begin play into here and for the event active can overlap, if I just hold Alt to break the link here, and I also break the link here, and then if this is true I'm going to turn this material the basic asset o1 color and if this is false then I'm just going to do nothing.

So if I just compile this right now, um, this is empty, so if I play my game it shouldn't change color. And if I just check this and then I go um play, it should change color.

And one more thing with variables, we can make them instance editable. And if I just compile this, that allows me to dynamically um change the value of it in my game.

So if I just select this um blueprint and I press Alt to quickly duplicate it, right now if I go to default, we can see that for this um blueprint, the Boolean example is set to be true.

If I just just leave this unchecked and for this one if I leave it checked, when I go play the checked one will change color and the unchecked one will not.

There are also a couple more nodes we can use with Boolean.

So right now we just have this um Branch node. So if this is true then we change the color of this to be red.

But with booleans, we can also use the AND node. So if I just drag off here and I look for AND Boolean and I'm just going to create another variable and call this Boolean example 2 and I'm just going to drag this in here, get it, and connect it into here and connect this into here and I'll also make this instance editable.

And the way this will work is Boolean example and Boolean example 2 both have to be true and then it will change the color of this to be red.

So I just compile this and let's just make it true here.

So both of those variables have to be true in order for it to basically change color, we can also use the OR node.

So I just delete this. I can drag off here and look for the OR Boolean, and I can connect from here into here and here into here.

So the way this will work is either one of these variables can be true, and I'll change the color of this to be red.

And we also have the NOT Boolean node. So if I just drag off here and I look for NOT Boolean and connect this into here, the way this will work is it'll do the opposite of this.

So if this is not true, then it's basically going to make my material red.

However, if this Boolean is true, then because this is NOT, this is going to be false, so it's not actually going to change the color of my blueprint.

We can just compile this and test this out. So for this one, let's make it checked. So for this one, if I leave it checked, then it should remain white.

And for this one, if I leave it unchecked, then it should turn red.

So if I just go play, we can see this one's white and this one's red. So that's the Boolean variable, and those are some of the most common nodes which are used with it.

The next common variable that you're probably going to use is going to be the integer variable. So if I just create a new variable, and I'm just going to call this number.

If we go over to variable type, change this to be an integer, then just go compile.

Now, an integer has to be a whole number. So if I drag in this variable and try and set it, if I try and make this something like 54.5, it's not going to work because integers need to be a whole number.

Next, let's go over some common nodes which are used with the integer. So if I just drag in my number, I can get it.

Then if I just drag off here and look for the switch on int, I'm just going to delete the booleans and branch I made earlier.

And if I just add three pins, then connect from event can play into here and from zero into here, and I'm just going to copy this two more times.

So I'm just going to copy this and paste two more times. I'll connect from one into here and from two into here.

And I'm going to change this to be the basic asset 2, and I'm going to change this one to be the basic asset 3.

So depending on what number this is, will depend on what color my sphere will change to. Let's make sure to make this instance editable so I can change it dynamically in the game.

And let's just go compile and let's just make it so this has number zero and this has number one.

And now if I go to play, we can see they'll change to their relevant colors.

So like I said, we can use integers to store whole numbers. Another common node which is used with integers is the random integer in range. So it's good to use integers for creating RNG in your game.

So RNG is random number generator, if you don't know that. And if I just right click and I go random integer in range, and I can make this go from a minimum value of zero to a max value of two, and event plate is going to randomly select one of these three colors to be my sphere.

So if I just go compile and we go play, it's just going to randomly, um, choose a color for our spheres so that time they were both the same color, although this time they're different colors.

The next variables and nodes I want to show you have to do with the vector variable.

For this example, if we just open up the third person character and just create a new variable and call it location, for the variable type, change it to be a vector and then find some free space and I'm just going to right click and make it so when I press the one key, I will drag off here and look for the node set actor location and I'm going to set my actor's location to be whatever this location variable is.

So if I just drag it in, get it and connect this into here, when I press one, I'll go to wherever this location is.

I'm just going to compile this and I'm just going to get the location of the sphere, so it's 1,000 in the X, 1,290 in the Y, and 200 in the Z.

I'm just going to copy all of these values into this variable here and just go compile and I'm just going to delete this.

And now if I go play, let's say I move away and then I press the one button, it will transform me to that location.

We can also use the vector variable to basically change the scale of an object. So if we just go back to our BP example, I'm going to create a new variable and just call this scale and let's just change this to be a vector and I'm just going to press Alt to break the link here.

And to event begin play, I'm just going to drag in my sphere and drag up here and look for set scale and we want this one, set wild scale 3D and connect from event begin play into here and then for my scale, we can just drag it in, get it, and then connect it.

And now a good comp let's give this a scale of five in all its axes, and now if I go compile and I play my game, when I play my game, we can see my sphere now has a scale of five in all its axes.

So those are some specific variables and nodes that you'd probably use together. Next, we're going to go over some specific nodes that you may use.

If we just open up the BP example and we can just delete everything so far, the first node I want to show you is the delay node.

So the way this will work is after the delay node has fired, it's going to perform a certain action. So we just drag off event play and look for delay, and let's just make it 2 seconds.

So after a delay of 2 seconds, it's going to now fire this completed node.

So after 2 seconds, let's just make it say print string, and let's make it say hello. So I just compile this and I play my game.

After 2 seconds, it'll print string hello. There's also another type of delay, which is called the retriggerable delay, and I just want to showcase how this works.

So if I just go over to my third person character and we just want to look for event begin play.

So if I go crlf that allow me to search for specific nodes and I'm just going to look for event begin and I want this one, event begin play.

So here in my character it adds my player character's controls.

After we do this, I'm just going to drag off here and look for a retriggerable delay, and let's just make this two seconds.

I'm also just going to drag my one key and move it up here. We can delete the set actor location node and connect from one into here and I'm just going to drag off here and look for print string.

So the way the retriable delay will work is if this is called again then it's going to stop it from firing.

So event play, after 2 seconds it's going to print string hello.

However, if I press one, this is going to fire on the retriable delay and I'm going to have to wait another 2 seconds before this fires.

So if this retriable delay is called again, it's going to reset it and we're going to have to wait another 2 seconds.

So if I go compile, I close this and let's just delete the sphere and if I go play, if I keep on tapping one then I'm going to be calling my retrial delay, so it's not going to basically be able to print string hello.

If I stop pressing one after 2 seconds it's going to print string hello. So that's the way the retriable delay works.

The next node I think you should know about is the flip-flop node. So if we just open up our third person character and I'm just going to delete this.

When I press the one key, I'm going to drag off and look for the flip flop node.

So the way this will work is first it's going to do A then that's going to do B. So when I call this flip-flop node first I'm going to drag in my mesh then drag off here and look for set material and connect A to here and let's just change it so our mesh will change to the basic one material, and when I press the B button, I'm just going to copy this.

We'll make it so our mesh will change to the basic two material. So now I go compile, close this, and I go play.

Inside of my, um, game, when I press one, I'll change red, then when I press one again, I'll change the other color, and I can just press one and one to flip-flop between those two nodes.

One more thing, since we're here, we're using the Set Material node, and right now we're changing element zero on our mesh.

If I just go to the viewport and my mesh right now, this has two materials. Element zero is this one, and element one is this one.

So if I go over to my event graph, if I change the element index to be one, it's going to be changing this material instead of that material.

So now if I compile, and I close this, and I go play, when I press one, it's going to change element one on my mesh.

So that only basically applies if your mesh is using multiple material slots. The next node I want to show you is the sequence node.

If I just close this and we go over to our BP example, we can just delete these nodes and event. We can play it.

I'm going to drag off here and look for sequence. So the way this will work is first it's going to fire this node, then it's going to fire this node.

Let's just add another pin, and that basically allows us to add more pins to our sequence.

If you want to remove a pin from our sequence, we can just right-click and go remove execution pin. So inside of our BP example, first let's make it prints string hello then we can change our sphere so if I drag in my sphere I'll drag off here and look for set mesh and we want this one set static mesh and I can change the mesh of this to be something else so let's change it to be a cone and then I want to change this material so I can just drag off my sphere again and look for set material and I'm just going to change it to be basic asset 3 and I'll connect from here into here and now if I go compile when I play my game it's going to do all of those changes that happened a bit fast so what we can do is add our delay node so first we'll print Shinko and then I'm going to have a delay of 1 second then I'll change it to a cone and then let's have a delay of 2 seconds and then we'll change it to be um this color so let's go compile click close this and now we go play first it's a um sphere then it changed to be a cone then it changed to be green so that's how the sequence works.

The next node I want to cover is the do once node. If we just open up our third person character and go over to the bit where we make it so when we press the one button it will change the color of our player character if we just drag off here and look for do once then compile if I close this and then go play when I press one to swap the color of my character if I try and press one again it's not going to happen.

I can only basically fire this node once so if I just go back to my third person character, the Do Once will basically only allow me to fire these nodes once.

What we can do is reset this Do Once so we can call it again.

So if I just right click and look for the two key, I can make it so when I press two, it will reset this Do Once.

Then I can press the one key again. So if I just go compile, close this and I go play, when I press one, if I try and press one again, I can't swap colors.

Although, if I press two there, it will reset the Do Once, and then I can press one again.

So we can just use the Do Once if we only want certain event fire once, and if we ever want to reset the Do Once, we can plug something into the reset value.

All Unreal Engine Nodes You Need To Know About

All Unreal Engine Nodes You Need To Know About