필수 언리얼 엔진 게임 개발 노드

이 영상에서는 이벤트 시작 플레이, 이벤트 액터 시작/끝 오버랩, 정수 변수, 타임라인 사용법 등 언리얼 엔진의 게임 개발에 필수적인 노드에 대해 다룹니다.

### 초보자를 위한 필수 언리얼 엔진 노드
* 🔵 "**이벤트 시작 플레이**" 노드는 게임이 시작되자마자 트리거되며 일반적으로 초기 조건을 설정하는 데 사용됩니다.
* 🔴 "**이벤트 액터 시작 오버랩**" 및 "**이벤트 액터 종료 오버랩**" 노드는 오브젝트가 액터와 겹칠 때 사용되며, 전자는 겹침이 발생하면 트리거되고 후자는 종료될 때 트리거됩니다.
* - "부울" 변수는 참/거짓 값을 저장하는 데 사용되며, 부울에 사용되는 일반적인 노드로는 **"Branch", "And", "Or", "Not"** 등이 있습니다.
* 🟣 "정수" 변수는 정수를 저장하며, 정수와 함께 사용되는 일반적인 노드로는 **"Switch on Int"** 및 **"Random Integer in Range"** 등이 있습니다.
* - "벡터" 변수는 **3D 위치, 스케일, 회전**을 저장할 수 있으며, 일반적으로 **"액터 위치 설정"** 및 **"스케일 설정"** 같은 노드와 함께 사용됩니다.
* '타임라인' 노드는 시간 기반 애니메이션과 이벤트를 만드는 데 사용되며, **키프레임은 다양한 시점의 값을 정의**합니다.
* '사용자 지정 이벤트'를 사용하면 **선택적 입력 매개변수를 사용하여 자신만의 이벤트를 정의**하고 호출할 수 있습니다.
* ⚫ '**이벤트별 타이머 설정**' 노드는 지정된 간격으로 이벤트를 반복적으로 트리거하는 데 사용되며, '**핸들별 타이머 지우기 및 무효화**'는 타이머를 중지하는 데 사용할 수 있습니다.
* ⚪ "Find Look at Rotation" 노드는 액터가 **목표 위치를 향하도록** 하는 데 사용되며, 시작 위치와 목표 위치가 회전을 정의합니다.

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 notes 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 01 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, 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 boan example is set to be true. If I 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 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 create a new variable and call it location. For the variable type, change it to be a vector. 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. I'm going to set my access 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 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 trigger board 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 allows me to search for specific noes. 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 characters 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 act to 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 retriggerable delay will work is if this is cooled 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 retriggerable delay. And I'm going to have to wait another 2 seconds before this fires. So if this retriggerable delay is cooled again, it's going

to reset it, and we're going to have to wait another 2 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. Noes, 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 vort and I 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 print 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 this color. So let's go compile, click close this, and now we go play. First, it's a 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 want will basically only allow me to file these nodes once. What we can do is reset this do want so we can call it again. So if I just right-click and look for the 2 key, I can make it so when I press two, it will reset this du want. 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 will reset the do want, and then I can press one again. So we can just use the do want if we only want certain event fire once. And if we ever want to reset the do want, we can plug some into the reset value.

next node I want to go over is the branch node. Now we did already go over this when we set up the Boolean variable, but I just want to go with a quick shortcut that you can use to quickly create branches. If you hold the B button on your keyboard and just left click, that will allow you to quickly create a branch. So just a quick recap, the way the branch node will work is if the condition of this branch works, then it's going to fire off true. If the condition of this branch is not met, then it will fire off false. The next nodes I want to go over are event begin overlap and event end overlap. If we just open up our BP example, and I'm just going to go to the viewport and delete this sphere. Instead, if we go over to components and go add and look for a box collision, with it selected, go over to details and in the search look for hidden in game and just make sure that this is unchecked, just so that we can visually see this. Then if I scroll down and I go to on component begin

overlap. When something overlaps, this will fire. So, kind of similar to the node that we used at the start. So let's make it so if our player character overlaps this, this will basically print string. So if I just drag off other actor element for equal and then if I just right-click element for get player character connect this into here and then I'm just going to create a branch by holding BM my keyboard and left-clicking. If my player character overlaps this box, we can make this print string player entered box. And then if I select the Box again, this time I can select on component end overlap and I can basically fire this um node when something leaves this box. So we can just copy these nodes here and paste them again, connect from other actor into here and from here into here. So when my player character ends overlap with this box, so they leave this box, we can make this print string player left box. Let's compile this, close this, and test this out. Now normally in a game, we wouldn't have the um box cision be

visible, but this is just for testing purposes. That's why I made it so we can see it. And when I enter this box, we can see it says player entered box. And when I leave this box, it says player left box. So that's how the begin and end overlap events work. We also have the on hit event. If I just open up my BP example and I set my box to change its collision presets to be block all, so now my player is not going to basically be able to overlap this box before it was on overlap all. And when we have this set to block, I can go to on component hit, and I can make it so when something hits this box, it will fire this node. So let's just make it print string hit. And then we compile, and I play my game. When the player hits this box, it'll fire. So that's how to use the on component. So normally when I add a box collision, these are the main three nodes that you'll probably use as a beginner. Next, let's go over how to use

the for Loop node. If I just open up my third-person character, I'm just going to delete the nodes that we used last time. And when I press the one button, I'm going to drag off and look for the for Loop node. So, this will basically fire however many times my last index is. So, if I make this five, when I call this for loop, it's actually going to run this six times. Now, the reason it's going to run this six times is because it counts zero as a number. Just to show you what I mean, if I just drag off this Loop body and look for print string, and then connect index into here. If I compile, close this, and then go play, when I press one, we can see it print string six times because it includes zero as a number. So, 0, 1, 2, 3, 4, and 5. So, the for Loop node will basically fire for how many times this last index is, and when it finishes, this completed node is going to fire. So, if I just drag off completed and look for print string

I can make this a completed. Then go compile. And if I just go play and I press one, it will do the for loop. And then when it's completed, it will print string completed. The next note I want to show you is the timeline. We can basically use the timeline to make specific events happen over a specific duration of time. Let's go over how to use it. If I just go back to my BP example, I'm just going to delete all of the nodes I made last time. And I'm also just going to go to my vort and delete this box. Next, let's create a door. So I'm just going to go add and look for a cube. And I'm just going to go select and scale objects and just kind of scale up so it kind of looks like a door. And then I'm also just going to go add and add another cube and just call this the door hinge. And just move this towards a bottom corner of your cube. So somewhere like here. Then just drag the cube into the door hinge. Now, if I select the door

hinge. And let's say I go to select and rotate objects. When I rotate the door hinge, it should rotate my cube with it. So, this will kind of act like the hinge of the door. So, what we're going to do is using the timeline, we can basically make this door hinge move. So, let's go over how we do that. If I just go over to my event CRA, I can just delete this branch and event begin play. I'm just going to drag off here and look for add timeline. We can just call this our timeline. And if I open this up, we can also select how long we want our timeline to be. So, I'm going to make my timeline 3 seconds. Next, we just want to go add track and select add float track. We can just call this our new track. Next, we want to add some points to our timeline line. So, if I just right click and I go add key to curve flat one at a time. Z, I want this timeline to have a value of zero. Then I'm just going to right click

again and add another key to the curve float at time three. So at the end of this timeline, I want this timeline to have a value of one. Next, we can just go back to our event graph. So over the duration of 3 seconds, we're going to make our door open and rotate. So if I just drag in my door hinge, I just want to drag off here and look for set relative rotation. I'm going to right-click on this new rotation value and go split structure pin. If I just go back to my viewport and set my door hinge, we're only going to be rotating our door in one axis, and that axis is the z-axis. So if I go back to my event graph, we're not going to change our door's values in its X or Y. So if I just drag off here and I look for get relative rotation, this will get the rotation values that I have for my door, and we just want to right-click and go split structure pin and connect X.

into X and Y into Y and from update into here so as my timeline is updating, it's going to basically update these values. Next, we normally use the timeline with the L node. So if I just right-click and I look for L, and the way the SL mode will work is this can go from a value of 0 to one. When the L is at a value of zero, it's going to have value a, and when this L is at a value of one, it's going to have value B. So we just want to connect our new track into the alpha so our track goes from a value of 0 to 1 one way on our timeline at second Z. This has a value of zero, so it's going to be value a, and when we in our timeline at second three, this has a value of one, so then it's going to go to Value B. So if I just select my door hinge, it starts off with a value of zero. So here in a, I'm just going to leave this at zero although I

want my door to rotate to 90°. So here in B, I'm just going to put 90, and we just want to connect this return value into Z, and connect update into here. So as this is updating, it's also going to update our door hinge, it's also going to update the rotation of our door. So I just go compile, we can close this and test everything out. Instead of playing another way, we can just test things inside of on engine is by going here and going simulate. And this will basically simulate as if our game was playing. So as you can see when I clicked play, so when I click simulate, we can see my door slowly rotated. Nice. So that's just an example of how we can use timelines to basically make things happen over time. We could if we wanted to also just make an object become bigger over time. So instead of setting the relative rotation of my daughter Bas ofate, I can just delete all of these nodes, and I can just drag up here and look for set scale, and I'm just going to go for this.

one set world scale 3D. And I'm going to connect from here into here and from update into here. So right now my door hinge starts with a scale of one. And let's make it so it scales all the way over to five. And let's just go compile, close this, and I go simulate. Over the duration of 3 seconds, we can see this will become a lot bigger. Hello, the next node I want to go over are custom events. So if I just go over to my third-person character, we can create custom event nodes. So if I just right-click into some free space and I look for add custom event, and I can just call this swap colors. And when I call this custom event, it's going to run it. So when I call this, I'm just going to drag in my mesh, drag off here and offset material. And let's make it so our mesh will change to be, let's say, this Arrow material. Then anywhere inside of my blueprint, I can call this custom event. So I'm just going to hold alt and break.

the link here. When I press one, I can call this custom event or maybe event begin play. After I do all of this, I can call this custom event. Another thing with custom events is we can make them have inputs. So if I just select this, I can go add input, and I can make this custom event have a variable. Let's just make it have this boolean variable, and only if it's true, we will swap colors. And now if I go over to where I placed my custom event, here I can see the input, and I can just make sure it's checked when I press the one button. And now if I were to test this out and compile, when I play my game, if I press one, I will swap colors. The next node I want to show you is the set timer by event. If we just go back to our third person character, I'm just going to delete this. And when I press the one button, I'm just going to drag off here. And for set timer by event, we just want to right click on this and promote it to

a variable and just call it event. Example for this event, we can just drag off here and look for add custom event. And I'll just call this swap colors flip-flop for the time. Make it one and just make sure that this is looping. So when I press the one button, it's going to call this custom event and it's going to happen every 1 second because we check this looping box. If I did not check this looping box, then this would only happen once. But make sure it's checked and make sure the time is one. Then when we call this event, we can just drag off here and look for the Flip Flop. And what I'm going to do is make My Player character swap between two colors. So I'm just going to drag in the mesh, drag off here and look for set material. And let's change it so our M will change between this basic color. And I'm just going to copy this and it will change between this other basic color. So I'll connect A into here and B into here. So now I go compile and

I close this so if I go play and I press the one button every 1 second, it's going to run my um set Tim by event, and it's going to basically make My Player character swap colors. Although we may want our set timer by event to stop running, so let's go over how we can stop it. If I just go back to my third-person character, if you remember we promoted this to a variable, so if I just right-click and I'll look for the two key again, when my player presses this, we can just drag in the event example get it, then just drag off here and look for clear and validate timer by handle, and this will stop my set timer by event from running, so it'll basically stop it. So I can just go compile, close this, and then go play. When I press one, it'll basically start my um timer, then if I press two, it will stop it. So that's basically how we can use the set timer by event. The next node I want to show you is the find look at.

rotation node. This could be helpful if you want an actor to face your player character. So let's just go over to our BP example. I'm just going to delete the door hinge and this Cube. And I'm just going to go add and look for a cone. And then another thing, if I just go add and look for an Arrow, this will let me know the forward direction of my object. Just select your cone and rotate it so it's facing the arrow. I'm just going to delete this Arrow now. Then if I go over to my event C, and I'm just going to right click for event tick. And event tick, I'm going to use the find look at rotation node to basically make this actor face my player character. So if I just right click and for find look at rotation, we can use this node to basically make it face a certain object like our player character. This has two inputs, start and target. Where this is going to start, we can just right click and for get actor location. And the target, this is where

want it to look at. I want it to look at my player character so I can just right-click and will get get player character. Then I can just drag off here and forget actor location. Then I can just drag off here and set actor rotation and connect this into here. So event tick I'm going to basically be making my BP example face my player character. Let's compile this and test this out. Okay, looks like I'm having an error in Target. Okay, so that is to do with the thing that I deleted last time. So I'm just going to delete this and go compile. And I close this when I go play. We can see the cone is facing me. And as I kind of move away and around it, it continues to face me. And as I move up, it will move up. And as I move down, it move down. And if you wanted to, you could make it so it only rotates towards the player in a specific axis. So I just press alt to break this link. I can right-click here and split the share pin. I can also

right-click here and split the structure pin. And maybe I'll just make it face my player in the z-axis. Then go compile and it'll only face my play character in The zxs. If I jump up, it won't basically move with it, okay? So sometimes you just need to do that. So, those are all of the essential notes that I think um you should know when you're starting un engine. If you want to continue learning unal engine and want to learn how to create full games in unal engine, make sure to check out my website unal engine University. I have courses which will teach you how to make full games like a 2d platformer, an FPS game, a melee combat system, and I'm always working on adding more courses, so make sure to head over there and subscribe to access all of my courses there. If you enjoyed this video, make sure to like and subscribe. It really helps me out and I'll see you guys in the next one. Bye.

All Unreal Engine Nodes You Need To Know About

Unreal University 

언리얼 엔진의 게임 개발을 위한 필수 노드

이벤트 시작 플레이 노드는 게임이 시작될 때 블루프린트의 초기 동작을 정의하는 데 필수적이며, 초기 조건이나 동작을 설정하는 데 자주 사용됩니다.

이벤트 액터 시작 오버랩 노드는 액터가 겹쳤을 때 동작을 트리거하는 데 중요하며, 일반적으로 오브젝트가 접촉할 때 동작을 정의하는 데 사용됩니다.

이벤트 틱 노드는 매 프레임마다 액션을 실행하는 데 필수적이며, 일반적으로 게임의 지속적인 업데이트나 변경에 사용됩니다.

부울 변수를 생성하고 사용하는 것은 브랜치, 및/또는, 와 같은 필수 노드와 함께 언리얼 엔진에서 조건부 로직을 구현하고 참 또는 거짓 조건에 따라 다양한 동작을 정의하는 데 매우 중요합니다.

언리얼 엔진에서 부울, 정수, 벡터 변수 사용하기

부울 변수는 머티리얼 색상 변화를 제어할 수 있으며, "not Boolean" 노드는 참일 때 반대 효과를 제공합니다.

정수 변수는 오브젝트의 색을 결정하는 "switch on int", 난수 생성을 생성하는 "random integer in range" 등의 노드와 함께 일반적으로 사용됩니다.

벡터 변수는 'set actor location' 같은 노드와 결합하면 게임 내 오브젝트의 위치를 설정하는 데 사용할 수 있습니다.

언리얼 엔진에서 특정 변수 및 노드 사용하기

언리얼 엔진에서는 변수를 사용하여 값을 저장하고 오브젝트를 조작하는 것이 일반적입니다.

"스케일 설정" 노드는 오브젝트의 스케일을 쉽게 변경하는 데 사용할 수 있으며, 지연 노드는 액션 사이에 시간 간격을 추가하는 데 효과적입니다.

리트리거 가능한 지연 노드는 액션의 빠른 실행을 방지하는 데 유용하며, 플립플롭 노드는 이벤트에 반응하여 두 액션을 순차적으로 전환할 수 있습니다.

언리얼 엔진에서 메시 머티리얼 변경하기 단계별 가이드

B 버튼을 사용하여 메시 머티리얼을 변경하려면 이벤트 그래프에서 설정된 머티리얼 노드와 요소 인덱스를 조정할 수 있습니다.

시퀀스 노드를 사용하면 지연이 있는 일련의 동작을 생성하여 메시와 머티리얼 변경 간에 부드럽게 전환할 수 있습니다.

do once 노드는 특정 이벤트가 한 번만 트리거되도록 하는 데 유용하며, 2 키와 같은 다른 입력을 사용하여 재설정할 수 있는 옵션이 있습니다.

언리얼 엔진에서 브랜치, 오버랩 이벤트, 포 루프 노드 사용하기

B 버튼을 누른 상태에서 왼쪽 클릭으로 분기를 빠르게 생성할 수 있으며, 분기 노드는 조건에 따라 참 또는 거짓을 발동합니다.

이벤트 시작 오버랩은 무언가가 겹칠 때 트리거되고, 이벤트 종료 오버랩은 무언가가 지정된 영역을 벗어날 때 발생합니다.

for 루프 노드는 지정된 횟수에 따라 일련의 작업을 실행하는 데 사용할 수 있으며, 0이 숫자로 포함되므로 루프가 한 번 더 실행됩니다.

언리얼 엔진에서 타임라인을 사용하여 문 애니메이션 만들기

타임라인을 사용하여 특정 기간 동안 문 경첩을 움직이게 할 수 있으며, 일반적으로 두 값 사이를 보간하기 위해 "Lerp" 노드와 함께 사용됩니다.

타임라인에 키 포인트를 추가하여 회전의 초기 및 최종 위치를 설정하여 도어 힌지의 움직임을 제어할 수 있습니다.

'상대 회전 설정' 노드는 도어 힌지의 회전을 업데이트하는 데 사용되며, 타임라인은 회전을 초기 값에서 최종 값으로 보간하는 데 사용됩니다.

언리얼 엔진에서 타임라인, 커스텀 이벤트, 타이머 사용하기

타임라인을 사용하면 예시의 문 회전 및 크기 조정에서 볼 수 있듯이 오브젝트를 원활하게 애니메이션하는 데 도움이 됩니다.

사용자 지정 이벤트를 사용하면 메시의 색상 변경과 같은 특정 동작을 만들 수 있으며, 이벤트 발생 시기를 제어하기 위한 입력을 지정할 수도 있습니다.

이벤트별 타이머 설정은 1초마다 색상을 바꾸는 예시와 같이 일정한 간격으로 이벤트를 트리거하는 데 유용하며, 이벤트를 반복하는 옵션이 있습니다.

언리얼 엔진에서 이벤트별 타이머 설정 및 회전 보기 찾기 사용

이벤트별 타이머 설정은 플레이어 캐릭터가 일정한 간격으로 색을 바꾸도록 하는 데 사용할 수 있으며, 핸들별 타이머 지우기 및 무효화 노드를 사용하여 중지할 수 있습니다.

회전에서 찾기 노드는 특정 축의 회전을 제어할 수 있는 기능을 통해 액터가 플레이어 캐릭터를 향하게 만드는 데 유용합니다.

이러한 필수 노드는 언리얼 엔진 초보자에게 유용하며, 정식 게임 제작에 관심이 있는 분들을 위해 2D 플랫포머, FPS 게임 등에 대한 강좌를 제공하는 언리얼 엔진 유니버시티도 있습니다.