00:00In this video, I'm going to show you how to make an enemy AI using state trees, an AI controller, and AI perception
00:00We will make an enemy that can follow a set patrol path
00:07They will chase the player upon seeing them
00:07If they hear a sound or get damaged, they will move to the location of sound or damage to investigate
00:12That means check if there's a player
00:12They will start punching the player if they catch you
00:19And if you hide from the enemy, so go somewhere where the enemy can no longer see you, then they will return to their patrol route
00:25I'll walk you through each step so you can easily follow along
00:25But if you would like to just access the complete project files, including bonus content and an 800word document explaining state trees, you can get that on my Patreon
00:35Unlike most following tutorials out there, I will take regular short pauses to explain key concepts
00:41So without further ado, let's get started
00:46We're going to make a new project in the third person template
00:46Just call it something like state tree project or whatever you want to call it
00:52but it's very important do it in the third person template so you can properly follow along
00:52Once we've opened the project, we're going to go to plugins and we're going to search for state tree
00:59The normal statry plugin is enabled by default, but we need to add the gameplay statry plugin
01:06So add that, then restart your computer
01:06The next setup thing to add is the nav mesh bounds volume
01:11We're going to add this to the world and we're going to expand it so it covers the entire map or the entire area that we're going to use
01:16And what a nav mesh bounds volume does is it defines the area in which the enemy AI can perform calculations
01:22If you want the enemy to move to a location, it has to be within this nav mesh bounds volume because otherwise the computer can't do calculations to find out how to get there
01:35If you press P on your computer, you can see all the debug areas where the enemy can move
01:41Obviously, if it's green, it means it's good and the enemy can do calculations there
01:46Now, we're going to create the enemy
01:46So go ahead, search for a character, just a normal character class, call it BP enemy
01:53Then we're going to make a AI controller
01:53So if you go to your content browser, go to blueprint classes and search for an AI controller
01:58Just choose the normal one
02:05We don't need any others
02:05The default AI controller, call it AIC enemy
02:05The AI controller is the brain that controls the AI character, the body
02:11The character handles the movement, animations, and physical presence, whereas the AI control handles decisions like choosing where to move or when to attack
02:22This separation makes it easier to manage and reuse AI logic across multiple characters
02:29Next, we're going to make a state tree
02:29We're going to go to artificial intelligence, then just click on state tree
02:35Make sure it's the state tree AI component
02:35We want that one, not the normal one because it has some extra features
02:40Then we're going to open up the enemy and we're going to add some of the default features we need
02:46So go to the skeletal mesh and give it the manny mesh
02:46Then we're going to give it the abp manny for the animation class so it has a little bit of movement
02:52Then on the location give it minus 89
02:52And on the rotation give it - 90
02:59This puts it into the proper location in the capsule
02:59Then search AI in the defaults panel
03:06Make sure you click on class defaults so everything pops up
03:06Then scroll down to where it says pawn
03:06Then change from auto possess AI to place in world or spawned and change the AI controller class to the one we just made AIC enemy
03:20Now go to the AIC enemy our AI controller and add a state tree AI to the components class
03:26Change this to st_ene enemy the state tree we just made
03:26This will run the actual state tree for us
03:32Now we go to our enemy class
03:32We just spawn it into the world
03:32Nice and easy
03:39We just place it
03:39We're going to add an actor
03:39We're going to call it bp patrol path
03:45This is going to be how we're going to define where the enemy goes on his patrol route
03:51So, open that up and add a spline component
03:51This is like a line that you can drag along the ground, which is basically a line that the enemy can follow for his patrol
03:58Add a variable to the BP enemy, call it patrol path, and make it of type BP patrol path
04:04This is how we're going to set it so the enemy knows which patrol path to use
04:11Place the patrol path into the world
04:11And you're just going to drag the points at the end
04:17Just click on it and drag
04:17And then you can see how the spline moves
04:17If you hold alt and left click, it duplicates the point and drags it even further across the floor
04:23Make sure to press alt and left click because if you don't, it will just drag the same point
04:28And we want to duplicate and make a new point
04:28It has to go in a loop
04:28It doesn't need to exactly touch, but it's ideal that it goes in a loop because, you know, you want your enemy to go in a loop around his patrol path
04:41Interfaces in Unreal Blueprints
04:41Let different blueprints communicate without knowing what the other blueprint is
04:46This is extremely useful in modular systems like AI or state trees
04:52Let's say you have a state tree task that needs to make the player take damage, but the state tree doesn't know what kind of actor the target is
04:58It could be a player, enemy, or dummy
04:58By using an interface, for example, take damage interface with a function called apply damage, you can call apply damage on any actor that implements the interface and avoid casting to specific classes like BP player, which keeps your system flexible and reusable
05:18Now, we're going to add a new interface
05:18So, search for interface, call it in int for interface
05:25Then, go into the functions and change the function to called get patrol path
05:32with an output of the patrol path
05:32So, call the output patrol path
05:32Give it a variable type of bp patrol path
05:32This is how we're going to pass the information of what patrol path to use from the enemy to the AI controller
05:40So, the AI controller can make the enemy move along the patrol path
05:46Go to the enemy, go to class settings, go to implemented interfaces, and add the new interface we just created
05:52You'll see a grayed out function pop-up
05:52Just double click on that and input the patrol path to the output
06:03Now go into the level, go to your enemy
06:03Um, first you'll actually have to make sure the variable is instance editable and exposed on spawn, which I didn't do
06:09But now if you go to the enemy, you'll see in his default classes a patrol path variable, which you can set to the patrol path in the world
06:20Instance editable means that you can change the variable's value in the details panel of the placed blueprint
06:26Expose on spawn means that you can set the variable's value when the object is created using spawn actor
06:32This gives you control of a blueprint settings when creating or editing instances
06:37So now our enemy knows what patrol path to use
06:45So if we go to a AIC enemy, we can search for event possess promote the possess pawn to a variable
06:52Now, as soon as we possess that enemy, we can say get patrol path because we just gave the enemy what patrol path it is
06:59Now, the AI controller knows what patrol path to use
06:59So, we can do some variables on it
07:04So, promote that to a variable
07:04Search for get spline because the variable in itself isn't a spline
07:10It's an actor and we added a spline to the actor
07:10So, you'll have to get the spline from it
07:17Search for get number of spline points
07:22Then promote this to a variable
07:22Call it something like total patrol points
07:28Duplicate that to create a new variable called current patrol points
07:28And just set that to zero
07:28This is how we're going to find all of the patrol paths we have
07:34And we're going to move from one to the other
07:42Go to the content browser
07:42Search for interface
07:42We're going to make another one for the enemy controller
07:48Call it in AIC IC for controller and just call it patrol
07:48Make that function patrol
07:54No inputs, no outputs
07:54We just need the function called
07:54We need to add the interface
07:54Go to implement interfaces
08:01Add it
08:01Now you'll see the key on the side called patrol
08:01Double click on that to get the event
08:06We're just going to print a string to say patrol just for testing
08:06So we can see that it's actually working
08:19Go to the state tree
08:19Make a new state called patrol
08:19Now we need to make a new task
08:26So the task that will run when we hit this state
08:26So click on new task
08:26Put it wherever you want
08:26Call it st patrol
08:33Now in this we need two things
08:33Every single time we need event state and we need a finish execute
08:33On event execute this is what runs when the task starts
08:40It's where you put the AI's action
08:40For example, move to a location
08:40Finish execute is where the task ends
08:48You tell the system whether it succeeded or failed
08:48That I used to structure the logic in a behavior tree task node
08:54A very important distinction though is that finish task doesn't just finish the task, but it finishes the entire state
09:01Now, we just can have the event state and then make a variable called AIC and then put it of type AI controller
09:08drag that into the world and just fire that patrol event we just created on that interface
09:15Now we're going to say finish task which finishes not just the task but actually the entire state
09:15So that's going to say we get to the patrol by fire patrol then we end the state
09:21But now we need to call the task from this state
09:29So just click on that plus button next to task
09:29Search for that task we just made
09:29ST patrol
09:29give the context um of AI controller
09:38In state trees, a context is a reference to an external object or system that the state tree can use during execution, specifically the AI controller context
09:51When setting up a state tree for AI, Unreal will pass in the AI controller as the context
09:51This allows the state tree to access the pawn, blackboard, or world via the controller
10:04This matters because many tasks or conditions need to know what AI is running the state tree, where the controlled pawn is, or what perception or data is available
10:10Instead of getting these manually in every task, Unreal injects the AI control as a default context so all state trees so all state tree tasks can access it
10:23In short, a context is a way for tasks to access external information or systems safely and consistently
10:35And on the state transition, just say as soon as it finishes uncompleted, go back to [Music] patrol
10:43Now, when you run it, you can see he keeps saying patrol over and over again
10:49This is because we're hitting the patrol task
10:49We do it, we fire this event, then we finish the task, and it keeps repeating
10:56Now we're going to make another custom event called increase patrol point
11:02This is what we're going to run after we've done our patrol to know to move to the next patrol point
11:09Search for AI move to off of the event patrol and implement the enemy that we made as a variable from earlier on event possess
11:16Now we get the patrol path
11:16We search for get spline because it's not a spline in itself
11:21Remember it's just an actor
11:21So we get the spline
11:21Then we want to get location at point or get location at spline point
11:33Change the coordinate space to local and plug it into the destination
11:38Sorry to world and plug it into the destination
11:38Implement the current index
11:46Then on success, we're going to trigger the increase patrol point
11:46Now, when an increased patrol point fires, we want to increment the current patrol point
11:52And we're going to check is it greater than the current is it greater than the total patrol points
11:58If it is, then we're going to set current patrol point back to zero
12:04Then we're going to trigger patrol again
12:04What this does is it makes sure that every time we move to a patrol point, we're going to move to the next one
12:10But if we're at the last patrol point of the entire path, we're going to go back to zero, which is a start
12:16And that's why it's important it's a loop because it just means we go from the end of the loop to the start of the loop
12:23He's not actually moving there, which means I made a little bit of an oopsy
12:29So, let's see what I did or didn't do rather
12:35I didn't check the patrol points
12:35I had greater than zero
12:35So, go back
12:35Just make sure you're saying greater than zero
12:40Now, he will move around the patrol path
12:50Now, we're going to open ABP_Manny, the default animation blueprint, because there's a little problem
12:55We're going to go to locomotion, and we're just going to remove the idle state because, as you could see, he's just gliding around the patrol path
13:01We don't want that
13:01I want him to actually look like he's walking
13:01There's a little bit of problem with the default one
13:06So, if we just remove the idle state, now he'll actually be running
13:13Great
13:13An enumeration is a list of named values you can use to make your code easier to read and manage
13:19For example, you could have an enumeration for movement activities such as idle, walking, or attacking
13:25You can use it to switch AI states, select behaviors, or organize game logic clearly
13:30We're going to create an innumeration
13:35We're going to call it e_ene enemy senses
13:35This is how we're going to start making the enemy actually interact with the player
13:42Notice the place
13:42So go into this enumeration, add three, and call them sight, hearing, and damage
13:48These are the three senses we're going to test for when we add AI perception
13:48Right here, we add AI perception under components on the AI controller
14:01AI perception is a system that lets AI characters sense things like seeing a player, hearing a sound, or feeling damage
14:07It gives the AI the ability to react based on what's happening around them
14:13Go to sense config, add three senses, add AI sight config, AI damage sense config, and AI hearing config
14:18And set the and set the dominant site to AI site
14:24The dominant sense to AI site
14:30We're going to give the site a site radius of 750 and a lose sight radius of 1,250
14:35We're going to put detect to all three of the boxes
14:35The age doesn't matter in this situation
14:42The other two are fine
14:42The other two are fine as the default settings
14:42So, we're going to click on on perception updated and we're going to get returned a list of updated actors
14:49We're going to say for each loop and this means that every single one of the actors that we've just changed something we know about, we're going to check over it
14:54Now, because we're checking three senses, we're going to make a function so we can reuse it
15:01Make that function, call it can sense actor
15:06add two inputs
15:06One of them is going to be the actor of type actor and the other one's going to be the sense of type ecore enemy senses or whatever you called your [Music] enumeration
15:25Drag in the AI perception and search for get actors perception
15:25This gives us all the returned information that we know about the actor that we input
15:36break off the info value and do a for each loop on the last sensed stimulus
15:42We're going to get class sense for stimulus and we're going to say equals to check if it's the same as the sense that we input
15:49So we do a branch afterwards and then a return
15:54But now we're going to come back and we're going to get the sense we input
16:00We're going to do a select
16:00We're going to plug it into the equals and we're going to choose the class
16:07Here I'm doing it slightly wrong
16:07I'll come back and correct it in a sec
16:07I'm going to play
16:07There's going to be a little error
16:12I'll come back and then I'll correct it
16:12So, for now, just leave those empty
16:12We'll come back and sort them properly
16:18But you do need to do this next part
16:18You need to return that array element as an output of the function
16:23Break off it
16:23And then we're also going to return successfully sensed
16:29So now we know, have we successfully sensed the enemy or not? This basically means have we seen them for the first time or have we lost sight of them? Have we heard them for the first time or have we stopped hearing them etc
16:42We're also going to output the actor
16:42Now off the sequence we're going to do three times
16:42We're going to do three cans sense actors and we're going to change the first one to sight on the enumeration input, the second one to hearing and the third one to damage
17:04We're going to input the actor
17:04Just have a little branch to check off the end
17:04Can we see the player? Can we not see the player? This is where we're going to change it
17:10Change those selected senses to AI sense sight, AI sense hearing, and AI sense damage
17:22Make sure you input the actor for all three of those functions
17:29Now if we play you can see every time we go into the enemy's vision he will say can see player
17:29Every time we leave the vision he'll say can't see player
17:35This is the difference between the true and the false
17:35If we return true for successfully sensed it means we've entered his vision
17:42If this is false it means we've left his vision
17:42It's the same for hearing and damage
17:42We're just going to close some of those tabs to make it a little bit cleaner
17:53Then we're going to if you press Ctrl P it will give you a way to search for any of the items
17:53You could search it manually control in the content browser but this is a little bit quicker
17:59So search Ctrl P open your third person character then get the keyboard event for N and get the keyboard event for M
18:04We're going to set up some default practice demos for how we can send damage and send and send noise
18:10So search for report damage event
18:16Give the instigator a self
18:16And we're just going to say get actor location and put that in
18:21That's where we're damaging from
18:21We need to put in a damage amount
18:21Put it to 100
18:26And for the damaged actor, we're just going to say get actor of class and then search for BP enemy
18:26This is not the best way to do it
18:33And in a game, you wouldn't do it like this
18:33But this is just for testing because we're not we're not caring about how we're doing the damage
18:39We just want the enemy to detect the damage
18:39If you get my Patreon version of this, I implemented a feature where you can drop a bomb which will explode and it will have a hearing radius around it
18:46So the enemy will hear the bomb going off
18:46And if you also get that, you will see that the player can punch the enemy, which will then trigger the damage
18:51So instead of these default events, you get a little bit extra off, and we're going to say report noise event, get active location, put in self, make sure there's a loudness, and make sure there's a range
19:04We're going to print just to make sure it's firing
19:04And by the way, report noise event and report damage are not the same as play sound and apply damage
19:10If you try and use apply damage and play sound, the enemy will not detect them
19:16It's not the same thing
19:16Report damage doesn't actually do damage
19:16It just tells the enemy to react as if there's been damage
19:22It's the same for hearing
19:22So, if you want to actually apply damage, you need to still call the applied damage event because they're not the same and they serve different purposes
19:27One is just to say, hey, you've you've heard something or hey, you know, react to this damage and the other one say you've actually been damaged
19:34Reduce your health
19:40We're going to fire two branches off both ends of these canens actors
19:47And we're going to add print print strings just to debug and make sure they're actually firing
19:57Compile
19:57Save
19:57Play the editor
19:57Now you can see if we press N, he's going to say damage received
20:04If we play M, we're making a noise
20:10Now damage is working right now
20:10Every time we press N, he can hear the damage
20:10He's not detecting our noise
20:15And I'm going to fix that in just a moment
20:15But if you look, every time it says damage received, that's because I've pressed N, we've applied some damage, and he's detected the damage
20:30To fix the hearing, go to the AI perception, go to the hearing config, and make sure you check all three of those boxes
20:37Make sure you're testing for enemies, neutral, and friendlies
20:37Now when we press M, we're playing a noise and it was heard
20:44As you can see in the top right corner, every time we press M, we're saying we see printed noise was heard
20:50That means the enemy has detected some of that noise
20:50So again, to fix that little issue, just make sure you go to AI senses, go under your hearing config, go to the detection, and check all three boxes for detect, player, detect, enemy, detect, friendly
21:03If you can't see it, just go under and scroll down the list and just go through each of the categories
21:09It's there
21:09It's quite obvious here
21:15I'm just tuning down the max range because 500 was a little bit too loud and he could hear us from the entire map
21:21So, we'll just make it if we're a bit closer
21:21Now, he can't hear us, but that's just because we're not in range
21:21If he comes back around and we play another noise, now he can hear us
21:27We're going to go to our AI controller interface, add a new function called chase player
21:32Again, we just need the function
21:32We don't need inputs or outputs
21:38Then we're going to make a new variable called attack target and change it to type of actor
21:50Every time we successfully see the enemy, we're going to set the attack target
21:56And every time we don't see him, we're going to set the attack target to nothing
21:56So set the attack target to the outputed pin
22:02For successful and for false, just leave it blank
22:02This means every time we see the player, we are creating a variable which holds the reference to the player
22:09And if we lose sight of the player, we are clearing that reference so we no longer have reference to it
22:16Here I'm just organizing a little bit more, adding some comments
22:16You don't have to do this, but it makes it look a bit neater and you can better understand the code
22:21So just drag over all just do a box drag, press C, and it will come up with the comment
22:27[Music] Make sure you double click on the chase function on the side under interfaces to make this function pop up
22:35Now we're going to search for AI move to
22:45We're going to put in the attack target, convert it to a validated get
22:45Validated get checks if a variable like a reference to an actor is valid before using it
22:53It helps prevent errors or crashes if something isn't set or has been destroyed
23:00If valid, it runs the logic
23:00If not valid, you can handle the error [Music] safely
23:07Then we make a new state in our st_ene enemy
23:14Call it chase
23:14We're also going to make a new task to go along with this
23:14So search for new task st_chase
23:23Make sure you trigger the event enter state
23:23Then add a variable called AIC of type AI controller
23:31In State Tree AI, the concept of a task and a transition is a bit different than in animation blueprint
23:38A task is a piece of logic or behavior that runs when a state is active
23:43For example, move to player, play attack animation, or wait for x amount of seconds
23:48A task defines what the AI should do in that state
23:54You can create custom tasks or use built-in ones like move to, wait, send signal, or blueprint task where you add custom logic
24:01A transition is the rule or condition that moves the AI from one state to another
24:07This could be a condition becoming true, for example, player scene, a signal being sent, or a task finishing successfully
24:15You can define transitions in the state tree by selecting a state, adding a transition condition, then choosing where the state next [Music] goes
24:32Drag that into the event graph
24:32Then search off that chase player
24:32This will call the reference to the interface we just implemented to fire the event
24:37Then just search for finish task
24:43If we don't do this, we never finish the state and we'll never move on
24:43Now we need to actually add this task
24:43So next to task, click on the plus button
24:48It will give you that input value that you need
24:48So just go on the side and make sure it's linked to the context
24:54Then on [Music] transitions, add a transition on event
25:00Then change the priority to high
25:06Make sure it transitions to chase
25:06And on the required event, create a new tag
25:06Call it chase
25:06And make sure the source is on that first one that pops up because otherwise it won't work
25:12And what this does is every time we call to that tag, we can call to it from anywhere
25:18It will now reference that event and trigger the state [Music] change
25:30We're going to make another tag, just call it patrol
25:30And then we're going to have another onevent transition change which goes to patrol
25:36[Music] on our AI perception for site
25:50We're going to drag in the state tree and we're going to say send event or rather send state tree event
25:56On the event we're going to make it, drag off and search make
25:56And this will take three inputs
26:03It'll take the tag, the payload, and the origin
26:03The payload and the origin we don't need
26:03But on the tag, just search for chase because now this means that every time this event triggers, we trigger the change of state from patrol to chase or from whatever to chase
26:16And the same for if we lose sight of the enemy
26:16But this time we're going to send the stick back to [Music] patrol
26:38I'm just changing the location of the enemy because where he is now, as soon as we press start, he's going to see the player and he's going to run to the player
26:45He's not actually going to run his patrol
26:45So, just making he starts his patrol [Music] first
26:54I'm just changing the max walk speed of the enemy
26:54You don't have to do this
27:00This doesn't really change much
27:00It's just to make it easier to run away from the enemy for [Music] testing
27:07I also got rid of the finish task on the ST chase
27:14Now, as you can see, every time we go in the view path of the enemy, he's going to start chasing us
27:20And if we leave his view, I just did it then when I ran behind him, he's going to return back to patrol
27:20So, if he sees us, he'll chase us
27:27If he can't see us anymore, he's going to return back to his [Music] patrol
27:33We're going to add a new state
27:33Call it [Music] investigate
27:40Then, we're going to add a new task
27:40[Music] Call it st_in [Music] investigate
27:53Off the function, just search for event enter state
27:53This is the default one we almost always need
27:59There are some others, but this is the one we almost always use
27:59Again, just add another variable AIC of type AI controller
28:06So, we can reference the controller from the context in the state tree
28:06[Music] add the task and give the context for the task so it runs
28:21Drag in the AIC, search off it and search for cast to AIC enemy and cast to AIC enemy
28:28We're going to go back to our AIC enemy and create an event dispatcher on investigate finished
28:42[Music] We're going to drag off the AIC enemy in our task st_in investigate
28:42We're going to say assign uninvestigate finished
28:49This creates a bind event and an uninvestigate finished
28:49Off that investigate finished, we're just going to say finish [Music] task off our hearing sense
29:02We're going to break this output stimulus
29:02We're going to say AI move to
29:02We're going to input the enemy and we're going to input the stimulus location
29:15So this way it's going to move to wherever it heard something
29:21On success, we're going to call investigate finish
29:21We're going to call that event dispatcher we just made
29:29On patrol, we're going to add another transition
29:29We're going to say trigger on event and it's going to go to investigate
29:36is going to be of high priority
29:36And the tag, we're going to make a new tag, call it investigate
29:42Make sure the source is selected
29:42That's why I get an error there because I didn't select the source
29:48Now, we just click on the investigate tag
29:48And every time we reference this tag, we're going to move from patrol to investigate
29:57On investigate, we're also going to create a transition on state completed
29:57We're going to go on state succeeded
30:04Sorry
30:04We're going to go to patrol on state succeeded
30:10We're going to go to patrol in our AIC enemy
30:27We're going to copy and paste that that little couplet of three nodes to send the event
30:33You could do this again
30:33It's state tree AI
30:33Search for send event
30:33Send state tree event
30:33Make sure that the tag is set to patrol
30:39This time, ignore the tag that I just left in there
30:46Right now, it says patrol
30:46Later, we're going to come back and change that to investigate
30:46But for now, I didn't realize
30:52I'll notice in a minute
30:52But in that tag section, like I said, you don't want patrol
30:58You want to have investigate for both of them because this way we're triggering [Music] investigate
31:12When we play the sound, he turned to start facing the sound
31:12Then he saw the player, so he started chasing the player
31:17So here, if you press N to trigger damage, you'll see he starts moving to us
31:24Make sure the tags are both set to investigate, not [Music] patrol
31:37On investigate, add the transition on event [Music] chase
31:45Now, if we trigger a damage for the enemy, he starts moving towards and then he saw the play
31:52We started moving towards the player, but then we moved behind the wall
31:57So, we returned to his [Music] patrol
32:03We're going to add a new folder, call it anim
32:03I'm going to import an animation I have
32:03You can find this if you get the project files on my Patreon, but it's just a simple anim
32:10It's a simple punch anim I retargeted from Miximo
32:18We're going to create an anime montage called it an punch
32:25We're going to go to We're going to go to our enemy, not enemy controller, our actual enemy blueprint
32:25We're going to create a custom event
32:30Call it [Music] attack
32:30We're going to search for play montage
32:38Just the play montage, not play anime montage
32:43In skeletal mesh component, just drag in the mesh
32:43And on montage to play, we're going to search for a punch
32:49We're going to create an event dispatcher called attack finished
32:49We're going to drag it
32:56We're going to call it uncompleted
32:56An event dispatcher is a way to broadcast a custom event from one blueprint to others
33:03For example, when a boss dies, you can broadcast on boss death and all listening blueprints, for example, UI, doors, etc
33:08react
33:08It's like shouting, "Hey, something happened." and other listening and other listening actors can choose what to do in our AIC enemy
33:26Now, we're going to make another custom event
33:26We're going to call it attack as well
33:31We're going to get our enemy
33:31We're going to cast it to BP enemy
33:40Then, we're going to drag off and we're going to search for attack
33:40We're going to say assign on attack finished
33:47Then on attack finished, we're going to create another event dispatcher called on attack finished again
33:54And we're going to call this event dispatcher after this event
34:00Compile and save
34:08Go back to our state tree
34:08Make another state
34:08Call it attack
34:13Make another task
34:13Call it st_att attack
34:22Search for enter state
34:22We're going to make a variable
34:28Call it AIC of actor
34:28We're going to make a variable called actor of type actor
34:39Make it instance editable
34:39Then go to tasks for our attack state
34:39add that attack
34:45We didn't compile before, so we won't see it pop up, but here we search for get AI controller cast AIC enemy
34:57Drag off that and search for attack
34:57Search for assign on attack finished
35:05Then on attack finished, search for finish task
35:11Create a new event dispatcher in our AIC enemy
35:16Call it onchase completed and another one called onchase [Music] failed
35:22We're going to make a little update to how our chase works
35:29Go to our chase event
35:29I'm just going to add a little comment so it's more readable
35:35[Music] on success
35:44We're going to call unchase [Music] completed
35:51We're going to we're going to get our state tree AI
35:51We're going to search send state tree [Music] event
35:58So on the failed pin, we're going to search for this
36:04We're going to make sure we're sending this event
36:04Make the event and give it the tag of patrol
36:10The payload and origin are as usual not important
36:10Call on chase failed
36:10After we lose sight of the enemy, go to our state tree
36:19Go to our [Music] state
36:26This time we're going to cast to our AIC enemy
36:34[Music] We're going to drag off the enemy
36:39We're going to say assign on chairs completed
36:45We're going to say finish task
36:45This time we're going to say on assign on chairs failed
36:50And we're going to say finish task, but this time succeeded will be false
36:56We're going to go to chase
36:56We're going to add transitions
37:03We're going to say on state succeeded
37:03Go to attack
37:03Then another one on state failed
37:10We're going to go to [Music] patrol
37:16We're going to change the position of the attack state
37:16We're going to move it above investigate under chase
37:21We're going to change the transition to on state succeeded
37:21Go to chase
37:31Go to the state tree
37:31Go to our attack function
37:31We're going to change how we get the controller
37:37We're going to make a variable, call it AIC, give it of type AI controller
37:43We're going to input it to that cast instead of getting the actor
37:49Now, when we start, if the enemy sees us, we play the sound
37:49He moves to the sound
37:55He checks it out
37:55There's nothing there
37:55So, he walks back to his patrol
37:55We damaged him
37:55He turns around
38:01This time, he sees us
38:01So, he chases us
38:01He gets to us
38:01He starts punching us here
38:01You'll see a little bit of capsule clicking
38:07Capsule clipping is the weird camera movement
38:07Go to your player BP third person character again
38:14Ctrl P to open this asset to open the asset selector
38:14Then go to the third person character
38:21Go to the camera boom
38:21Scroll down
38:21Find do collision test and disable that
38:27So now if he punches us, you'll see that there's not the weird [Music] clipping
38:33And now we're done
38:33So the final behavior, if we apply some damage, he'll move to the location where he where he sensed the damage
38:45And if we play a noise and he's in range, he will turn around to start moving towards that sound
38:52If he sees the player whilst he's moving, he'll start chasing them
38:57And if he reaches them, he'll start throwing punches
38:57But then if he loses sight of the player, he will go back to his normal patrol
39:04For example, here he can no longer see the player, so he's patrolling
39:09Thank you for watching to the end
39:09I hope you managed to get the system working
39:09And if for some reason you're having troubles with it, you can get the working project files from my Patreon
39:15And if you're an avid U5 learner and want to become a part of a rapidly growing development community, then come and join my Discord
39:21We're nearly at 200 members.
