Hello, this is Yeong-hoon Lee
Today we will work on a shooter game using Blueprints
First, we will learn about Unreal Blueprint
And then we will be creating a simple shooter game with it
In this chapter, we will learn about a node-based interface of Blueprint
A visual scripting system at Unreal Engine
And in order to run attribute and method of a Blueprint Class
We will be dealing with its basic grammar as well
Coding and Visual Scripting
Let's first learn about Blueprints
Blueprint literally means a blueprint-outline
So what is its role at Unreal Engine?
On the screen, this is a Level
And those that are on a Level are Actors
These are also Actors here
We could create our own Actors to place them
As of now, all the content in the right, at Outliner is
Coming from the content at Place Actors
So they are coming from here to be placed there
Let's now create a new one
Here, at Content Browser, use Ctrl Space
To slide up this Content Drawer
We see the menu here, so right click on this and we see
A Blueprint Class
Let's create this
Now we get all the options such as Actor, Pawn, Character and more
Let's choose Actor here
I will add a prefix 'BP_' standing for Blueprint
And the name, 'TestActor'
Shall we save here?
You can click on this button, 'Save All'
Or you could simply Ctrl S
See how there are options for saving at File
It will be convenient to use these hotkeys
Now, let's bring out this 'BP_TestActor'
Now, this Actor that we created
We can place it at our Level, or on our screen
So here at Ourliner, we see 'BP_TestActor'
And notice how we have a new button called 'Edit'
Click on this, or simply double click on this
And we get the Editor Window
So here, Blueprint is simply
A necessary tool in order to create things such as this Actor
To clarify, this is a Blueprint Class
See how this is saying 'Blueprint Class'
So it's a Blueprint Class
And this to the right, at Outliner is called an Instance
So this has been moved out here
Let's double click and go to our Editor Window
What we can do with a Blueprint is
Because this is a Class, we have Class Defaults
And Class Settings
And we have Components to the left
At 'My Blueprint' we see things like EventGraph under Graphs
We also see Functions and Variables
So this is how a Class is visualized
Let's say we're drawing a circle
This will contain its attributes and methods
And this is called a class
This class is a type
In other words, a user-defined data type
So in a class are its properties
And these are its methods
Attributes are what we usually call as variables
They are created through variables
And a method, through functions
We will learn more about these later
For example, let's say this is a class called human
This is a human
What attributes does a human have?
We could say, the age
The name, and things like this
And its method, to walk
To sit, and so many more possible methods
So this thing that we created, a human class
What would be its name? Let's say Lee Young Hoon
This is the actual being that has been created
And these beings are called objects
So this is an object
We call it an object and
We could also call it an instance
Object is more catering to its certain role
And when we are creating variables in a memory space
This class-making is a variable-making in other words
And then with this, an instance is
This being that physically exists in the memory space
So, as we just looked at, a class is composed with
It's attribute and method, or variable and function
And in the end, see here
See how there is the function part at Functions
And then the variable part at Variables
And we could code them
The coding space is here, at Event Graph
So this is how Event Graph looks like
And here, right click on this space
Right click and drag, and you can move this around
And using the mouse wheel, you can resize the space
So this is at 100%, and to make it bigger
Press Control and use the mouse wheel
Now you can see it bigger
This is the basic control
Whenever we learn a new language
The first task is to print 'Hello World'
So let's try and print 'Hello World' here
Right click here
And we see a menu like this
Look for 'Print String'
Click on this
And let's connect them
And we see how it has these things
And now click on 'Compile'
And save here
We usually compile and then save
And that's a lot of work, clicking two buttons in a row
So go to this menu
And for 'Save on Compile', try 'Always'
And this will automatically save the work
I will go with 'Always'
This means whenever I click on 'Compile' it also saves
And let's move back to this 'Untitled' area
And let's run this
This button here lets you run it
Click on this, and we get a new window
Do you also get this window?
This is like a pop up window
It's called a PIE Mode (Play In Editor Mode0
Here on the right, we have a menu
Here at 'New Editor Window' we see PIE Mode
I will change it back to 'Select Viewpoint'
So this will run this within the Viewport area
Let's run it
Now, to the right, we see 'Hello'
And it quickly disappears
It says 'Hello' because this here asks for 'Hello'
So this is a gist of how you code for a Blueprint
And this is called a node
And a node looks like this, with some menu options
These on the left are called pins
This has no Output Pin, so let's look at something else
Let's try a node called 'Set Actor Location'
So this rectangular box is called a node
And each node has some pins
The first pin is an Execute Pin
So this Execute Pin
It moves from left to right, like this
So the control flow is from left to right
So after running this, it moves rightward
And then it runs the next node
That's the flow here
And whenever we run this node
This Input Node comes in as helpful
So to the left is the Input Pin, and to the right is the Output Pin
So for this node called Set Actor Location
When this location node runs
We need the value at this Input Pin on the left
And we have some default values
We could run it with its default values
This node has something to do with the location, as its name states
So this will specify the location of the Actor
So once we add the value for the new location
This instance created with this 'BP_TestActor' Blueprint Class
This instance will move to this location
And it will show us the result of that movement
Such as what the instance has bumped into along the way, for example
And this is how we control a Blueprint
Blueprint Scripting: Basics
Let's now talk about data type and variables
First, data type
Data type and variable
In this system of programming here
There is a concept of an object
What we are doing is an Unreal programming
Unreal uses an object-oriented programming
Or OOP (object-oriented programming)
'Object-oriented' means that we created things in objects
And actualize or process them through their interactions
Among the objects themselves
And what is an object again?
It's a variable created with a data type called class
That's what we call an object
And here, we create such objects
For example, data type includes integer, float or double
So an integer is that divides wholly
Such as -10, 5, or 0; these whole numbers
Natural number without decimal point is called an integer
It could have a sign, such as plus or minus
And the other most widely used data type is float
So for integer, we say int
So this is integer
And this is float
Yes, and then
Let's say this is, for example, -10.5
Or -5.1; something with a decimal point
0 can also be a float, because it could be a 0.0
Of course 0 can both be an integer or a float
And another example, something like 1.2
And there are two types of float
Float is something smaller in scale
And double is another type, that has double the scale
So double is the name for this other data type
So in order to differentiate them
We add an 'f' in the end, like this
Of course with Blueprints we don't really use this
But this is an important concept for coding at C
So with an f, it becomes a float; if not, a double
And there is also a logical data type
We are familiar with the concepts of true and false from our math classes
Hope you remember them
Even at programming, we have True or False for the logical type
This is called a Boolean
Boolean, and in a short form, 'bool'
For C we call it a 'bool'
And for Unreal it just says Boolean
And this data type has two values, True or False
So True and then False
Should I do it again? False; True and False
And we have some texts, such as string
Unreal also has string
String meaning text characters
And there are some more data types
So these are the four representative data types
Shall we move on?
Let's create a variable
To the left, at this window called 'My Blueprint'
We have Variables with a plus sign
Let's click on this
And we get something here
This here says 'Boolean'
Click on this, and we see these data types
It has Byte, Integer64, and much more
These data types allow for integers
The only difference is their sizes
We also see Float here
And then Boolean
As well as String
So these are the different types
And we also see things like Vector or Rotator
Transform, these are also widely used data types
These are some popular data types we see here
And other than these, let's expand on this
We have so many more data types at the bottom
As we see here
Let's start simple, with Integer
Click on Integer
I will name it 'Number'
At Unreal, it's recommended to write the name
Starting with a capital letter for the coding
Of course, this is not mandatory
But we could follow it like this
So the name is 'Number'
Now, let's print it
I'll delete this part, because we already covered this
Let's bring in our Number to Print String
Let's add it like this
See how it is being added like this
And we see some converting nodes in between as well
So this converts an integer value to a string
So we could convert it using these before we add it in
So that's how it works
First, let's compile
And when you select on Number
At the very bottom of Details, we have Default Value
Where we can add some numbers
Let's say that we add 100
This is a value, called 100, added into our variable called Number
That's how it works
Let's come back here and run this
And now we see the number 100 being printed here
Here, the Duration option is only two seconds
Let's make it longer, say 10 seconds
And run it again
We can now see it for 10 seconds here
There could be much more variables
Shall we make something else?
Let's created a float type
So let's select Float
For a float, I guess PI is a float
PI, which is 3.14...
So let's write it here
So right after we create it
And notice how it doesn't have Default Value as it did before
It just says 'Please compile the blueprint'
You need to compile it once before adding any values
Let's just say 3.14
And let's minimize this
Now, let's print this PI
So it changes like this; notice how the converting node changes as well
And the colors; each data type has its own color
So there is a certain color coding system
It this called teal?
And for integer, this is the color
And the green is our float type
And then, for this burgundy type
Or string type, we can add it
And let's run it
We can see it printed here
Let's try a logical type
Here, click on Boolean
And then
How should we name it?
A Boolean basically asks whether it's right or wrong
So we usually use the praxis 'b'
For C too, 'b' is used for Boolean
So we could say 'b' here too
But another way is
We also use 'Is' for Boolean
So 'b' and 'Is' are the two popular ways
I'll go with 'Is'
IsInAir, let's try this
'InAir' as in having jumped, as we will learn later
Jumping up means it is in the air
Are you in the air right now?
That could be the question
So the question will be this, 'IsInAir?'
Let's compile
But we're standing on ground, right?
So for IsInAir, it will be a False
Let's ask, 'IsInAir?' And let's bring it in
And let's add it back here
And notice how the converting node changes too
This converting node here
It changed into red and burgundy
The colors are all different
Let's run it
We see how it prints 'False'
Let's now try a string type
Do this
And choose String
For the name, let's say 'Name'
Compile
Maybe add your name for this Name
I'll use my name here
Compile
Before that, we need to connect it
Bring it in here
You can do this and choose Get
Notice how there are Get and Set
This is how Get looks like
Get is just to bring it in, so it looks like this
Set, meanwhile, looks like this
So for Set, we are adding some extra control for running it
And only when we run it
We add the values in this, which will
Fill the value in this variable called Name
That's what this Set node will do
So we can choose between Get and Set for the node
Let's now print our Name
Name is a string, so it prints right away
And now, run this
We see how it prints the name well
Simple, right?
That's how we create variables
And, if this was a class
This variable would be its attribute
We could also disconnect the node
For example, to disconnect this
If you try this, it would not disconnect
This wouldn't do it
So here, click Alt when you click on it
And this will disconnect it
Or, if you'd rather connect it to something else
For example, to connect Name with Set
Let's say, for this Name
We could add the name directly here
But we could also use this node
To add the name
For which we can simply connect it like this
And with this connection
Later, when the work becomes very complex
You may forget what this is connected to
So for that, go to this connecting part
And while pressing Ctrl
Left-click and drag
And you can move it around like this
Again, with this, press Ctrl
And left click to drag
And you can move it around like so
This is what I recommend you to do
This is a way to do it
And now, let's make this function
This is called function
And for the word function
You can search it up later
Because function is often translated as literally function
While some translations give you the Korean word for function
So function is what acts with a purpose
So let me explain what a function is
Let's move over here
So this is called a function
We are familiar with it from our math classes
It used to be difficult because
We had to deal with some numbers
And it must've been a difficult concept
A function is simply a set which
Transforms an input value
To give you a different output value
That's a simple version of it
We also have in our reality
Something that is similar to a function in how it works
For example, let's say we have
Something like this
I don't know if I'm doing it well
Let's say that we have this thing
Does thie look any familiar?
So let's add an orange here
Let's squeeze this orange in
Then something will come out of this
Some droplets
And what do we call this?
A squeezer
Just like so, a function has
The same form as this squeezer
So that's how a function looks like
So a function has this input area
Input
That's how we write it
There's the input
And over here we have an output
Like so, input an doutput
So with these concepts of input and output
Inside, something is going on
It could be some calculation
Some algorithm, or something else
And after that work, it will return the result
Or there may not be an input
Or there may not be an output
Input and output may or may not be there
So something that looks like this is called a function
Here's how you write the word function
Like so
And now, shall we make a function ourselves?
Let's make a plus function
Come over here
At Functions, we have a plus button
Click on it, and it looks like this
Now we have a function
It's called My Function...
I mean, New Function
Let's make the name for this 'MyAdd'
This will have two integer inputs
And then one integer
It will return an integer, a sum of these two
Let's make this function
See here
This Add function looks like this
And look to the right here
It has the concepts of Input and Output
For Input I will take two
First, an integer
Let's call it 'A'
With that 'A', let's make another one
After you create one, click on the plus sign
And it will create another one with the same type
Let's make an input value called 'B'
These things we add to an input are usually called arguments
This is a function too
So, in eseence, a function is
Something that realizes a particular action
Which uses it by calling it
Now, we're at the creation stage
It doesn't automatically work after we create it
In order to make it work, we need to call this function to use
That's only when this works
So to call it, we add a value
That value is called a parameter
That's what a parameter is
The value, the parameter
And a variable that takes it
This is called an argument
An argument
Left click at 'A'
And drag it out to get this line
And let go to see this menu
Here, search for ' ' and here's 'Add'
There's that node
Click on it, and it looks like this
Notice how this node looks a bit different
This node doesn't have the top area
So it lacks its Execute Pin, right?
This is called a Pure Node
So we can make this a Pure Node as well
At MyAdd, we have this option for 'Pure'
If you click on it, though we don't see it now
It will look a little different when we call it later
I will show you how it works later
And then
Drag out 'B', to mean that we add 'A' and 'B'
Hover your mouse and it says 'Addition' and 'A B'
Meaning, add A and B
And the result will return over here
Click on 'Add pin' and this will add another Input Pin
To delete it, right click and choose 'Remove pin'
That wil delete it
And now we need to print it, but
There is no node that prints it
This is because we haven't done anything to our Output
So let's set Output with Integer
Now we get a node
This is called Return Node
And let's say 'result' here
I keep using small letters for the names
Let's make this a capital letter
Now we connect this
Now we have created a function
We can also add a Comment here
To do so, you can either click on the background
Anywhere you want, click on it
And press 'C' on your keyboard
This will create a Comment
That's how you can group them together
Now they move together like so
This is a useful thing to use as well
And here, let's write
This function adds two integers'
This part is optional, I just did it
So let's compile
To go back
You can click on this Event Graph
And you may make a mistake and close this window
In that case, go to this 'EventGraph'
Double click on this to open the tab again
That's how you get here again
This looks like this for now, and let me move this a little
And let me disconnect this
We only had that to see what a variable is
And for our function, like so
Here we have MyAdd
Click on it, drag and drop here to have it here
Now click on this, and to the right, we have 'Pure'
Click on 'Pure' and it changes like this
'Pure' decides whehter to have its Execute Pin
Or to not have its Execute Pin
I will keep it here
And now we connect it and add the value
You can write it directly here
You can add thing slike 10, 20
Or, since we have a variable called Number
We can bring this in here like so
That will add the values
And let's print it here
We will use this Print String
Let's copy this in
Select our Print String
Ctrl C and Ctrl V to copy and paste
Ctrl D is for duplicate
So Ctrl D will duplicate it
You can choose whichever is more convenient for you
Let's print it now
Connect it like so
And connect our Result part to this
Now, as we have seen before
Like so, the converting node is automatically created
Now compile and run
Now we have this value 120 printed here
Remember, we added 100 for Number
So 100 plus 20 equals
This printed value, 120
That's what a function is
Now, I have this red 'Event Begin Play'
So this is
An Actor is actually born
Right over here
So everything over here
In a way, I mean, they are not living beings
But you can consider them as one
Meaning, an Actor is something born in a Level
And this is what I made, a Blueprint
But I can take another out
Now we have two of this
When I was talking about Class
I said one is Hong Gil-Dong, another Lee Young-Hoon
So this is Hong, and this is Lee; that's how it works
Meaning, even on the same Class, there can be different objects
That's how it works
So this instance is now born here
Notice how I'm using 'object' and 'instance' to mean the same thing
They are interchangeable
So do not be confused
Object and instance, they are similar
They are not exactly the same
But they are referring to the same thing
So anyways, they are born, and they die
Something may collide into it
And basically, what we have is after they are born
So it's called an event
When it is born, an event occurs
So this event is called 'Begin Play'
And the event during its life, we have Event Tick
Tick repeats itself every time
While this is only called once, when it is born
This keeps getting called in
And then, though we don't have it here
We also have something called 'End Play'
Event End Play, this is
This node, or event, is called when it gets destroyed
We also have 'Destroyed'
Something called 'Event Destroyed'
So this node is also called in when it is destroyed
There's that
And we also have 'Event ActorBeginOverlap'
This is used when
You know, we bump into many things in real life
Right? We would bump into many things
Just like that, this Actor can bump into some other Actor
And this node will capture such things
That's what it is
And I just want it printed once when it is born
So these are printed here
If this is printed here, at Tick
If it is printed at Tick, this is how it looks like
It will keep getting called in
So to go back, this is how we create a function
And we can call this in order to use it
So this is how we create functions at Blueprint
This is their mechanism
And then we call it in
So here, we have created this function
Which looks the same as these other nodes
So a node is, in a way
Very similar to a function
Of course, these nodes are not a function
We have a variable node, and then a function node
That's a way to distinguish them
But to be exact, they are the same nodes
Let's now move on to conditional statement (Branch/Switch) and iteration (Loop)
Let's do it together
Now, let's undo BeginPlay
Let's move it over here
Let's start with the conditional statement
So, conditional statement
This is what it is
If, and then
This is the condition
And if that condition is met, this will happen
And it may not be met
If so, then so happens
Or, if not so, then so happens
This can work as well
Or we can also do this
While this has two conditions
We can also have three
If not so and instead so, then so happens
There can be two conditions like this
Or more than three can work
Yet Blueprint has different categories for this
So a node can handle two conditions
And another node can handle three or more
That's how it works
Of course, if you have experience in coding
You know, there's the 'if statement'
If, else
If and else statements
And we also have 'else if' as well
So with these keywords
We can run a branch statement
But at Blueprint, this part is a little different
When we get to C later, it will work like so
But at Blueprint, it is run a bit differently
So let's now
Learn about how we do it
Let's type in 'if' here
And we don't get 'if', instead 'Branch'
See how a node branches into two
So this is a Branch
We can connect it like this
Meaning, every time it is born, it checks for the Branch condition
Condition is what makes it conditional
And it says 'True' for all conditions
So Condition is obviously a Boolean
Now, shall we do this?
Let's use this
We can simply drag it in like this
'Is in Air', if it's True, it signals this way
If False, it signals this way
Let's make two different Print Strings
Like so, and like so
Here, 'It is in air' and here, 'It is on the ground'
These are the conditions
Here, what is 'Is In Air'?
It is False
Now let's run this
We see 'It's on the ground'
Because 'Is In Air' is False, it's not in air
But if 'Is In Air' is True
It branches instead into 'It is in air'
And, I'm going back and forth
And you may be thinking
That I could just work on it here
I can do that
So, with this varibale 'Is In Air'
To its right, there's an eye icon
And once we open this eye
To the right, under Details, 'Instance Editable' is now on
See that? It is synced
Instance is, I said this here is the Instance
So it means that we can directly edit it at Instance
Let's now open this eye here
And click on this 'BP_TextActor'
At Details, 'Is In Air' is right here
See? Let's try turning it off
Turn it off, and now compile it
Compile, and we don't see it here
Like that, we can use our thing at Instance directly
Through thi smenu
Anyways, that was conditional statement
But instead of branching conditions into two
For multiple conditions, we use a Switch
Then, for this particular logical type
A Switch may not be appropriate
Instead, this is how we use a Switch
Let me try it with Number
With Number, let's look for Switch
Here's 'Switch on Int'
And we have it like this
And we have a Pin here
Click it, and this Pin changes
It multiplies itself like this
So, if I have 0 for Number
Or 1, or 2, or 3
According to this value at Number
We can make it switch
So for three or more options
We use Switch
So at Blueprint, we use Branch for two conditions
And Switch for multiple
It's simple
That was conditional statement
And, I'd rather leave it here
Now, let's go up, and finally
Le'ts now talk about iterations
So we have iterations
That literally repeat the same thing
So it repeats
It has a beginning and an end
So between its start and its end
Something must go on here
And for that progression, there is a concept called Index
Index is usually written as 'i'
Its 'i' is increased by one
So when it starts, there's the starting value for 'i'
And then the ending value
For example, if it starts at 0 and ends at 9
Is there too many? Let's say it ends at 3
From 0 to 3
Then it starts with 0, 1, 2, and 3; it repeats four times and it ends
That's an iteration
So how does this work?
Here, search for 'for' and we have it here
Let's go for 'For Loop'
And we have these things
We have 'Each Loop' as well as 'For Loop'
And so many more
Basically, 'For Loop' is the index-based repetition I just talked about
We have First and Last Index
If we want to repeat it 10 times, it will be from 0 to 9
From 1 to 10 is 10 times, and if we subtract one for each
It is from 0 to 9
Let's now print it
Let's use the same Print String
And this will print it
At Output Pin, it has Loop Body,
Index, and Completed
Completed is, of course, called in after this Index is run
From 0 to 9; it's the result
Loop Body is, every time it increases, it gets into this one
Meaning, it calls 10 times
Meaning, it prints 10 times
So for example, let me connect it here
And it now prints the Index value
And then, let's try this
Then it will print from 0 to 9
Let's run it here
Here, let's now...
Let's increase its Duration a little
And here, let's run it
0 is at the bottom, and 9 at the top
It's because the most recently printed one is at the top
So 0 is what started with
And 9 is the last one
That's how it works
And let's say I now connect it to Completed
Then it will only print this 10
Because, until 9, this Index will be printed through Loop Body
And Completed is what comes after 10
It doesn't count that, so
We can say it has repeated 10 times
So for Completed, this Index is
Last Index 1, that value is printed here
This can show us the acts that have been repeated
Now let's use this for a simple example
Something very simple is
We can only print even numbers
So for now, it is printing all numbers
But let's make it only print even numbers
Meaning, we need some filtering
Based on the number of Index now
It should decide whether to print the value
Let's keep this
In between here, if the current Index value is even, pass
And if not, don't pass
So the signal at Loop Body, the input control should
Reach here to be printed
So we can just stop it here
And this will only allow Index to pass if it is even
The difference between an odd and an even number is
When divided by 2, if it has 0 remainder, even and if it has 1 remainder, odd
Let's do some division
There's an algorithm for remainder
Called %, divided by 2
So dividing Index by 2, if this shows 0
It's asking here, 'is this equal to this?'
Then here, we need a Branch
Let's use a Branch
And this is how it can work
So let's disconnect it, and connect it here
And then here, let's add it here
Now, this only prints the value if it is even
Let's compile and run it
Now, 0 is also an even number, so this works
So that was on conditional statements and iterations
In fact, there are more operators
This is called Comparison Operator
A Comparison Operator asks, 'equal to or bigger?'
Or 'equal to or smaller?' or 'smaller?'
Less, Less Equal, and we have Greater, Greater Equal
We are familiar with these, less, less or equal to, and so forth
That's a way to compare
And, we could also make it work if two conditions are met
That's an option
If it extends until 9
We can only print those smaller than 5
Then this needs two conditions
This condition for even numbers
And we have another condition here
This, 'Less' compared to 5
Less, and the condition, 'is this less than 5?'
These are the two conditions needed
So if both conditions are true, that's True
And if either is false, this is False
And we can use an operator here as well
This is called Logical Operators
Let's use that
So for operators
Let's say this
We have two set groups
And if we limit the result to 'only when both are true'
It's this central part
For the two conditional statements, A and B
If it is only true when both are true
Then for the group, this is the place
This is called a union
I mean, an intersection
Intersection is what we are familiar with
Remember this sign? This is an intersectino
And in order to memorize this sign, I learned to
Make this look like 'and' in Korean, like this
So I did this to memorize this 'And'
'And' as an intersection
It uses two ampersands as its sign, like so: &&
And a union
So for two groups, we fill it all
Meaning, it's all true if at least one is true
That's a union
And this is the sign for a union
For this, I memorized it like this
'Or' in Korean, to memorize 'or'
For the sign, it looks like...
Do you see the sign right above your Enter on your keyboard?
On your keyboard, there's your Enter
And right above that, though it may vary
There's this button that looks like this
Which has this sign like this
This is the sign for 'or'
It is not a straight line like this
It's actually two line with a space in between
So that's the 'or' sign, ||
We use two
So for this example, we are using an intersection, an 'and'
Meaning, it's only true if both A and B are true
That's what we're making here
So when divided by 2, the remainder is 0
And it is smaller than 5; that's the condition we have
So let's choose 'And Boolean'
Complete it like this
And adding this as the condition will
Only print it when both are true
Let's compile and run
See how it doesn't print anything bigger than 5
Today we looked at Blueprint
Let's sum what we've learned today
Coding and Visual Scripting Create Actor Blueprint to set in World
Create Printstring node, connect Output Pin to Event Beginplay node to print HelloWorld
Basics of Blueprint Scripting Pin of Blueprint Node Execute Pin, Input Pin, Output Pin Variable Attribute of a Class
Use Variable to declare a variable Connect to PrintString Node to print on screen Variable Method of a Class
Use Function button to add Add function, set Input and Output At Event BeginPlay Node, connect Add function and print
Basics of Blueprint Scripting Conditional Statement Compare two values and print or print after checking if the values are the same
Iteration Create For Loop Node, connect to Event BeginPlay Node, set Index value
Connect Add function node and variable node, use Print String node to print