00:00[Music] Hi everyone, welcome back to Solo Dev
00:07Over the past few weeks, I've embarked on a long-term journey building a sample Unreal project from the ground up and we'll be learning it together bit by bit
00:18Our goal to explore and experiment powerful features in open world map streaming the gameplay ability system, state trees, asset registry, and more using only free assets from the Fab store
00:31I've been building this primarily in C++ with blueprints making a few guest appearances along the way
00:38I'll drop the GitHub repo link in the description so you can follow along and grab the latest code at any time because this project is firmly still in progress
00:44As I nail down each feature, I'll be making dedicated videos to walk through them
00:51In today's session, we're diving into something exciting yet evolving
00:58How to build an advanced state tree with custom C++ evaluators, conditions, and tasks to supercharge our AI logic
01:04We'll also go hands-on with debugging tools, and tackling some common pitfalls
01:09And just for a cherry on top, I'll show you how I wired up a custom C++ AI controller to drive our enemy character through the state trees brain power
01:22Let's dive in
01:22But remember, this is a work in motion, and I can't wait to see what we build together next
01:28All right, team
01:28Let's dive into the source folder
01:28Here's how things are organized under the hood
01:28All of our header files live in the public directory
01:35This is where we declare our interfaces, reusable strcts, and class definitions
01:42This structure means if another module needed to include something, this is where I'd look
01:42The heavier stuff, the CPP implementation files live in the private directory
01:55This keeps our modules internals encapsulated and clean
01:55Unreal's build system makes this distinction so that only the public folder gets exposed to external modules while the private stays internal, keeping implementation details safe and tidy
02:08I've gone one step further and group the code into functionbased folders like AI, controllers, state tree, characters, etc
02:20So you can find related code quickly
02:20And if a class is really tiny, I'll keep its implementation right in the header
02:27cuts down on file clutter and speeds up iteration
02:27Cool
02:27Now that the structure is clear, let's jump straight into our state trees
02:33Before we build anything with state trees, first we need to make sure the state tree plugin is enabled
02:39In your Unreal project, go to edit plugins to open the plugins window
02:46Use the search bar and type in state tree
02:46You should see entities like state tree and gameplay state tree
02:52Make sure those boxes are checked
02:52Unreal will prompt you to restart the editor
02:58Go ahead and do that to activate the plugin
02:58Once we're back in editor, let's create a new state tree asset
03:03In the content browser, right click and bring up the context menu
03:08Navigate to artificial intelligence, click state tree, and this will generate a new asset
03:14In today's video, we won't start from scratch
03:19Instead, we have a prefab state tree already added to our sample project
03:19We'll be working on that one, exploring how it's structured, enhancing it, learning as we go with more videos coming as we build features over time
03:33Let's open it up and dive in
03:38So, what is a state tree? Think of it as a supercharged offspring of two familiar AI systems, behavior trees and state machines
03:45It combines the hierarchical selectors from behavior trees with the state and transition flow of traditional state machines into one elegant framework
03:52At its core, a state tree is a tree of states starting at a root and branching down
03:57Each node can have child states selectors leading to a leaf states where actual behavior happens
04:08Here's how it works step by step
04:08On start, it implicitly enters the root state, then evaluates its enter conditions
04:16If they pass, it descends into child states, checking their conditions and continuing until it hits a leaf state
04:23All tasks in the active branch from root down to leaf, run concurrently, staying active until a transition fires
04:28Transitions can be triggered by task completion on every tick or by custom conditions and they can point to any other state in the tree
04:39This combination lets you structure AI logic with clear reusable flows
04:47You get flexibility, high performance, and organized behavior without decorators, blackboards, or the clutter that comes with them
04:55In essence, a state tree gives you a datadriven modular and visual way to author AI
05:02It's got the best of selectors plus state logic baked in, making it powerful, intuitive, and feature ready for UE5 AI developers
05:13Let's take a closer look at the state tree editor
05:13It's made up of three main sections with the details panel on the right used to edit what'sever currently selected in the states panel
05:19We'll start with the asset details section
05:26Think of this as everything that's global to the entire state tree
05:26First up, the schema
05:26This defines the type of state tree you're working with
05:34In our project, we're using the state AI component schema, which is more advanced and ties into an AI controller
05:40There's also a simpler state tree component schema, great for objects that don't need AI controller to handle their logic
05:46Both schemas have access to the context actor, but only the AI component schema can access the context AI controller
05:59You can even create your own custom schema
05:59While it's not required, for our sample, I built one called PAGAS enemy AI state tree schema so I could show you how it's done
06:11You can find it in the source folder under state trees schemas
06:11In it, I've set up our custom enemy character class and custom enemy AI controller class as the context value
06:24You can see these same values listed in the context section
06:24Context is important because every evaluator, condition, and task in our state tree can reference these classes to get their job done
06:36Below that, you'll see parameters
06:36These are global variables that every evaluator, condition, and task has access to
06:43Next are evaluators, which we'll dive into shortly
06:43After that comes global tasks
06:50We're not using any in our sample, but just know that these are tasks that run for the entire lifetime of the state tree
06:55I'd recommend only using them when absolutely necessary as they run continuously
07:02And finally, there are theme colors
07:07These let you color code your states so you can quickly spot and organize them visually in the editor
07:12Let's take a look at our custom C++ AI controller
07:18You'll find it in the controllers AI folder in our example project
07:23Every enemy uses this controller
07:23This AI controller exposes stimuli for our enemies
07:28Right now, we've got sight, hearing, damage, and general perception all set up
07:34It also defines two multiccast delegates that broadcast when certain events happen
07:39On damage when the AI takes damage on site when it sees an actor detected or forgotten and on hearing when it hears an actor detected or forgotten
07:51These delegates make it easy to trigger eventdriven reactions in either C++ or blueprint
08:00So we're not constantly polling for changes
08:00We also have several helpers that simplify common tasks like retrieving all sensed actors are manually reporting damage and noise events
08:20Now, one more important detail
08:20This AI controller also tracks the enemy's acquired target
08:25At first, this may seem like we're doing double work because our perception evaluator in the state tree also tracks a target
08:30But here's the difference
08:30The evaluator's target tracking is for internal state tree logic
08:37The AI controllers tracking exists outside the state tree so other systems can easily access it
08:43This separation gives us flexibility
08:49For example, in the future, we'll be splitting out our control and combat states into their own state trees, which means we can build modular state trees for different enemy types without duplicating work
09:01From experience, I found this method is more reliable than trying to pass a target from a master state tree down into a link state tree
09:11It keeps everything modular and easier to maintain
09:17All right, let's demystify this thing called an evaluator
09:17When I'm building AI with Unreal State tree, I picture the whole system like a newsroom
09:23The task are the reporters
09:30They go out and do stuff
09:30The transitions are editors deciding what stories run next
09:30And the evaluators, they're the researchers working in the background pulling in facts so everyone else can make smart choices
09:39Concretely, an evaluator is a lightweight C++ or blueprint class that runs on a schedule, usually every tick or at a custom interval
09:52Its sole job is to observe the world, crunch a quick piece of logic, and stash that result in the state tree context
09:59Think of it as the AI's heartbeat monitor
10:04Is the player within 10 meters? Is my stamina or my health below 20%
10:09Did I just spot an enemy target? Every frame it updates these vitals
10:15So when a transition checks a condition, the answer is already waiting
10:15No expensive queries, no tangled blueprint spaghetti
10:22Because evaluators never execute actions
10:27They're dirt cheap and thread safe
10:27They just collect data, keep it current, and hand it off to the decision makers
10:35Strip away the fancy name
10:35An evaluator is simply real-time situational awareness package in a reusable class
10:42In our sample project, I've built three custom evaluators
10:42They gather key information about our AI's world
10:48Specifically, our context actor, the enemy character, the player character, and the AI stimuli around them
10:55First up is the context actor monitor
10:55This evaluator keeps track of the enemy's current health
11:01As the project evolves, we'll expand into monitoring additional metrics like stamina, status effects, other special conditions
11:08Next is the context actor stimuli tracker
11:14This one's like the heartbeat of the state tree
11:14It detects when the enemy is damaged, when it sees or hears an opponent, and when those senses are lost or forgotten
11:25That constant feedback loop is what keeps our AI aware and reactive
11:30Finally, we have our player monitor
11:30This evaluator records a player's distance from the enemy, their gameplay ability system, character level, whether they're currently attacking, or even whether they're dead
11:44All of these evaluators feed their data back to the state tree as out parameters
11:44And like I mentioned earlier, this data is refreshed continuously
11:50So conditions, task, and other state components always have the latest information to make smart real-time decisions
11:58Let's go over how to create evaluator in C++
11:58In our project, you'll find all the evaluators inside state trees evaluators folder
12:11Each one is built on Unreal's use state tree evaluator blueprintbased class
12:18Every evaluator implements two key override
12:18Tree start call when the state tree starts running
12:23This is where we put our gathering logic
12:23Anything we want to initialize or start tracking right away
12:28Tree stop call when the state tree stops
12:33This is where we handle cleanup such as unregistering delegates or resetting variables
12:40There's also an optional get description function
12:40This controls the text you see in the evaluator's top bar inside the state tree editor
12:45You can customize it to be as simple or as detailed as you want, which is great for keeping complex setups easy to read
12:52Next, we define our properties
12:58And here's where the category metadata really matters
12:58Context tells the evaluator to fill this property with the value from the state trees context
13:06For example, if I want my AI controller property to reference the AI controller context value, I just set its category to context
13:17Input means the state tree designer needs to assign a value in the editor
13:24Output means this property will be populated by the evaluator and made available to the rest of the state tree
13:30In the editor, these show up with helpful little context in or out badges next to the property name, making it easy to spot their role at a glance
13:37While I'm using C++ for all of our evaluators here, you can absolutely build them in blueprint as well, using the same underlining concepts
13:50Let's walk through the anatomy of a state tree, one piece at a time
13:50First up, a state
13:58Think of a state as a self-contained unit of behavior logic
14:03When the state tree runs, it selects a root state and potentially drills down into child states based on enter conditions
14:08Once selected, all states on the active branch from root to leaf become active at the same time
14:14Each has its own task and potential transitions
14:20Next, the custom tick rate
14:20A custom tick rate controls how frequently the state tree re-evaluates rather than running every single frame
14:33For example, setting a tick rate of 0.25 means the state tree updates every 0.25 seconds, i.e
14:40four times a second
14:40This helps reduce overhead if your logic doesn't need constant checks
14:46What's a condition? Conditions are logical checks that gate logic
14:52An inter condition controls whether a state can become active
14:57A transition condition decides if and when the state should move on to another state
15:03States only active if their enter condition passes and transitions fire when it conditions are met
15:09So what about task? Task are the conditions or behaviors performed while a state is active
15:15They run concurrently across all active states in the branch
15:21Task can also produce outputs like setting a target, triggering an animation, or updating context values which other parts of the state tree can use
15:33And finally, transitions
15:38Transitions define how and when the state tree moves from one state to another
15:38They can trigger based on task success or failure or on custom events
15:45The state tree checks transitions starting from leaf state up toward the root
15:50And the first valid one will guide the next selection
15:56Now it's time to walk our state tree and see exactly how we created it
15:56From our root, I've created three main states
16:04I like to do my state trees this way so that it helps me organize the state tree as I'm building it
16:10The first state the tree will come to is idle
16:10idle state is also my fallback state
16:19The reason I do this is because in other states if the state tree is to fail, the state tree will automatically go back to the root and then start downward
16:24If that's the case, I want a state that we know the tree can move into
16:31If we do not and none of the states match any of our conditions, then the state tree will error and stop, which means your AI will just stand there or stop functioning because there's no state tree at this point
16:43So, this gives us that protection with that idle
16:50Naturally, you would think you would use a delay task in the idle, but we do not need to as our animation blueprint for our enemy is idle
16:57So we do not have to put a delay as our character is standing
17:03All we do is we set the max speed walking speed to 200
17:10We have set a custom tick rate to 0.25
17:10So four times a second we will process our task
17:16For our transitions we want to be able to transition to the other two main states patrol or combat
17:23And since those are event driven, basically our tree is going to be going back and forth between root and idle at all times because it can't go into patrol or combat without an event being fired first
17:34If we're in the middle of the idle processing four times during a second, it's going to run this task and then check our transitions
17:48within that checking of the transition
17:48If the event is fired for combat and we're saying the gameplay tag state tree event, we're telling the transition to move to combat
18:01We do the same for patrol with a priority of normal if we get a patrol event
18:01So next we have patrol
18:01Our first state that has an enter condition, we're telling it it's required event to enter which is our patrol event
18:16You can click the plus here and add other um other conditions
18:23All of these are built-in conditions other than the two that we have here
18:23So I've created our own category PG gas for our sample
18:30And we've created two conditions
18:30We'll go over those in a second
18:36Uh one is compare gameplay tags and another is character armed which you'll see in combat why we use that
18:42But there's others like a bull compare distance compare uh float just random has tag has tag so it's tag container different things like the object valid we use this one also within our tree the require enter to event is built into uh each state on the editor so that comes predefined as you see it's always there and you click it on if you want it
19:13So, we're only using on two of our states
19:20We're not providing any payload
19:20We want to consume the event on select
19:26So, when it's selected, we consume the event
19:26Our next state, I call it move to random location
19:32It has a custom tick.3
19:32So, basically about three times a second
19:32And we're performing three tasks
19:39Now, here's a little gotcha
19:39When you create a new state, the task are all the task dropdown or the task section is always set to any
19:46This can wreak some havoc at times, especially if you're using debug task
19:51So, there is a debug task here
19:57I've created a custom one as well, but there is a debug text task
19:57If we were to put this in here and all these tasks somewhat run at the same time kind of based on how you build the task
20:10Um, but if we have it set to any that means whenever the first tag completes it's going to go and try to transition
20:23Most of the time that is something you do not want
20:23Most of the time you set up these tasks and you set up up set them up in order that you want them to run
20:30And so setting this to all means all the tasks have to complete before we try to transition
20:36So that is something to remember
20:42In this move to random location state, we're setting the actor max walk speed to 200
20:49We are then calling our get random location around the actor radius 1,00 units
20:56We can change the units if we like
20:56We can say 2,00 but we're patrolling so we'll keep it at 1,00
21:02We are specifying an out parameter because we're telling this task to get me a location that I can move to within a 100 units around where I'm at
21:16outputs that random location and then we use a move to task to move to that random location we got from the previous task
21:31When we set the destination to random location, which is our task, the random location task and then random location
21:37When we set it to that, the state tree knows I need to wait to get this random location from the previous task
21:42When it gets it, it's going to run this task
21:50And then there's a lot of other properties and things you can set, setable radius, move tolerance, things like that
21:55If you're moving directly towards an actor, you would set the actor and the target actor and you wouldn't set the destination and it's just going to move towards the actor which we'll see in our combat state
22:09Once those complete, we're saying on state complete
22:09Now the state is complete because we've run all the task and we've told it that all the tasks have to run to be completed
22:23Now our task is complete
22:23We're just saying go to the next state
22:23So there's choices up here or you can jump directly to a state within our tree
22:30So our next state is a look around state
22:30So basically it just pauses
22:35You look the character looks around as part of their patrol sequence and we use a simple delay task
22:42We're delaying for 5 seconds
22:42Give or take 1.5 seconds
22:42Once our state is complete, we then transition back up to the move to random location
22:55So that's our patrol state
22:55Our combat state requires an event to enter and it's our state tree.event.ag
23:02First thing we're going to do is determine if the character or the enemy needs to draw its weapon
23:07I don't have this on the tick because it should only enter this state one time in the combat sequence
23:15And that's only if the weapon is not drawn
23:21So you will see when we run the game in our sandbox, the player or the enemy has his weapon holstered on his back
23:27He will then grab that weapon if it is holstered on his back
23:35This is where we use a custom condition
23:41So this custom condition is this one here
23:47Is character armed? We'll look at the code shortly
23:47Our context, our character context that the condition takes is mapped to our actor and the AI controller is mapped to the AI controller
23:58That's that mapping we talked about with the context for conditions
24:04It's the same for task as well
24:04We are inverting, meaning we're doing the opposite
24:10So, it's checking to see if it's armed, and it's going to return a true or false, a true if it's armed, false if it's not
24:15We want to invert that because we want to enter if it's the opposite of being armed
24:22So basically it returns false
24:22That's when we want to enter
24:27And when we enter custom uh task and the custom task is play montage
24:33I created a custom task
24:39One, you have to if you want to play a montage within the state tree because there's not one that's built in
24:45And also we do we don't want to have the task set itself to successful or failed until the montage is mostly finished or has completed and I have a we have a play rate
24:58So you can up the play rate if not once completed we go to the next state
25:03Our next state is a is a basically a container state
25:03Now there are such things as container states which are groups
25:09Um, so I kind of use the word interchangeably and that's not exactly right
25:14But our next state is attackfense, which then automatically goes into the the the following state, which is is player dead
25:25So we're checking to see if the player is dead
25:30So at this point, we could have went through several loops of our attack defense sequence and the player could have died
25:35At that point, we want to stop and and and we're returning to idle, but technically the game would be over
25:46So, the state tree would stop
25:46So, we could just tell the tree to succeed and then that stops the the the state tree because the state tree itself has succeeded
25:51Our next state is flee
25:59This gives an example of monitoring our character and our character's health
26:05over here in our evaluator that monitors our enemy health
26:15We check this health as our condition
26:15So we've set it here
26:15So you can go into your evaluator
26:22Evaluator names are listed here
26:22You can select the property you want to evaluate
26:28For our example here is current health
26:28And we say 20
26:33And then we give it the less or equal
26:33So it's less or equal than 20
26:33we want to flee
26:33It also runs a EQS query
26:33So let's look at that in the task
26:43We run a EQS query
26:43Here's our query location which is simply generating a path around our context
26:59Our context is the quer
26:59So that will be our actor our state tree and our state trees actor path exist we check to make sure exist and then we want to make sure that we are the path that we're checking the paths that are available are away from the player
27:17So we have a player context which is a C++ player context
27:24We'll look at that shortly as well
27:24And we want to make sure that we are moving in a distance away from the player context
27:30So that's what this flea EQS query does
27:38And so our query owner is our AI controller
27:38Our result so EQS queries return the return a result
27:47And so when you use this task, you have to set a EQS result value
27:53So that's what our global parameter is here
27:53We could have used a local parameter and set the local parameter and then use the local parameter in the move to but I set it up as a a global for future expansion as I have an idea of what we're going to do when we in the future and so I wanted this to be exposed outside of this state and that's simply how you run a EQS query
28:19When we look further down the tree I'll show you what the query config looks like
28:25We set our max walk speed to 400 because we want them to run when they're fleeing from uh from our player
28:31And then we use a move to task and we use the destination as our public uh flea EQS result
28:44And that's what the fleet does
28:44On complete, we loop back to our top attack defense state and then it re-evaluates again
28:52This will allow enemy to continuously flee if need be
28:58Then we go into our defense
28:58Now the defense is very simple here and over the course of time as we're creating this project, we're going to upgrade the defense more
29:11For now, we have a simple defense
29:11We're monitoring the player and if the player is attacking and that comes from our player monitor evaluator here is player attacking
29:22So our condition to enter here is true or is player attacking is true? If that's the case then transition to the next state which is block
29:35And for block, we are performing the game state ability
29:35And then we'll perform a block
29:43Once that complete, we transition back up to our top container here
29:43And then we start all over again
29:50Now, we're kind of getting into some more meat of it of the actual enemy attacking
29:50We want to make sure that there the enemy still has the target acquired
29:58So, we have two states here that handle that
30:04using the condition is object valid and we're checking the acquired target on the controller
30:09We could check the acquired target here on the evaluator, but we also know our evaluator sets the acquired target on the AI controller
30:23So, we can just use the AI controller
30:23This also means if something outside the state tree affects that acquired target there, that outside code is going to target the AI controllers acquired target because it will not know anything about that state trees copy of this evaluator that's running
30:42So, it's best to use this one here if you plan to have outside code affect that
30:48And if it's true, if that is a valid object, it's not a no, it's not a no pointer anymore, we want to continue
30:54If it is a no pointer, that means we no longer have that target
31:01That target could have been forgotten because the enemy can no longer see that target
31:08And when it used perception to move to the location it thought the target would be, it's no longer there or it lost the hearing of the target
31:15Either way, it's no longer there
31:15Then we want to move into patrol or idle states
31:21Whichever state, whichever event, whichever event that we're using, we want to move into idle or patrol for the transition
31:33Our task, we do have a set f a custom set focus task and we're telling it to erase the focus
31:42So we want to remove the evaluator's acquired target as well as the acquired target and the AI controller
31:48We want to take it away
31:54So now we want to move into a patrol state
31:54So we send that state tree event patrol which then will cause the state tree to start running our patrol branch
32:02That's what happens when we lose our target
32:07Now if we have our target now we want to attack
32:07So we're using our set focus
32:12So our set focus tag or we have a set focus state which has a simple task of set focus
32:19So we're setting focus to the acquired target and then we transition
32:24Now here's an example of a gotcha that you may want to you know look out for if your code you're building a state tree and it's not acting the way you want it to
32:31Those two thing here's the here's the two things to watch out for
32:37the one that we talked about earlier with the all any task
32:44The other is transitioning properly
32:44A lot of times you will want to use and rightfully so the enter conditions
32:50But there are times when the enter conditions don't work as expected
32:55So it's best to use the transition and the conditions from a pre state to move into the next state
33:08So we have a group here with move to strafe move to or strafe target
33:14Basically this group is our movement to and or around the target
33:14So from when we set focus, so we've acquired our target, we pulled out our weapon, we set focus to our target
33:21Now we want to calculate the distance between us and the enemy
33:28So, we know if we need to run towards the enemy or we are already engaged with the enemy, so we need to strafe around the enemy and make ourselves harder to hit
33:40Well, we've got that information from our player monitor because it tells us the distance in our evaluator, the distance to the player
33:53So what we're doing in this state transition conditions, we're saying if the player if the evaluator the player evaluator's distance to player is greater than 250 units, I want to transition to close distance between target
34:06If it's less than 250, we are already within striking distance for this character and this character's weapon to the player
34:13So, we just want to transition into strafing the player
34:20So, just remember if your inner conditions are not responding the way you want them to, look at the previous task and and put those conditions on your transitions and that should work for you
34:39So, our close distance simply has two task
34:39We update our speed to run to move to the acquired target which is our player
34:45So as you see here, we're using the target actor and not a destination
34:52So we want wherever the player because the player could be moving at the time
34:52So we want is basically it will chase the player until it gets within 125 units because that is the acceptable range
35:05If it's above 250, we're telling it to close in to within 125 units
35:05If we're going to strafe, then we're running the strafe EQS query, which is a donut query
35:18And we've set up parameters here for inner radius, outer radius, and points per ring
35:25This is now where you can see the query config
35:33So those three parameters we set up, the state tree editor knows that once you set the uh EQS and this allows us to update these values based on this state tree and this character
35:47So we can have a completely different state tree and set different values because that's a different type of character
35:52It could be a range character or something like that
35:58So we want to stay even further
35:58We want to have a bigger radius or something to that effect
36:04And then we set our straight the return of the EQS strafe donut to our strafe EQS result global parameter
36:09And then we do a move to to that destination and we've set it there
36:16Also, if you noticed these parameters here can be set by uh global variables
36:27So if you wanted to set up global variables here, get those values from evaluator, you can do that
36:27Or just set up parameters on the state and feed them that way
36:33You can do it that way as well
36:33Okay
36:33Then we do a slight fourth of a second pause before we tack
36:41And then we're just going to move directly to our perform
36:41We're going to transition directly to perform attack
36:48Now perform attack is where we created another custom task
36:53And this custom task similar to our perform block custom task which uh basically is calling gas to do this
36:59We're doing the same thing with perform attack
37:05We're calling uh gas and we set it up a little bit differently
37:12It's an array
37:12So you're putting in attack ability tags
37:12So gas ability tags
37:19Our enemy had four or five, but I only have three here listed
37:24So, we have a sword slash, a sword slow, and a sword slashspin
37:32So, it has three different attacks
37:32It's a custom task
37:32So, we can upgrade it in the future to do even more, but it evaluate basically eval evaluates the number of arrays you put in there and the weights that you have with each one
37:50And we have it set to random
37:50So once it evaluates these three, it randomly selects which attack it's going to perform and then it tells gas perform the attack
38:02Or we can set it to sequentially and it's going to do all three attacks in a row
38:02So, if you want your enemy to be a little more predictive, say your low-level enemies are very predictive, you've given them a variety of attacks, but they do the attacks in an order, so your player can catch on to the pattern and kind of know exactly how to defeat these lower level players
38:21Once it's complete, we go all the way back up to our attack defense state, and then we start it all over again
38:31And this is our attack defense loop that creates our our state tree
38:31So let's play and you can see it in action
38:47Okay, let's show our senses
38:47So as you can see, you can see our senses are set
38:52That's out of bounds
38:52This one is within our hearing
38:52And once it sees us, it pulls out it sword
38:59It comes towards directly towards us
38:59Pauses, attacks, pauses, attacks
39:05And so, as you see, it's attacking
39:05It's strafing
39:05It's using its different Oh, got a little bug there
39:10It's using our its different abilities that it has, and it's going to keep following us around, continue its attack until one of us dies
39:21And lastly, we'll close the video with showing how to build our conditions and task in C++
39:34So, you saw that we had two different conditions that we built
39:34We didn't use the compare gameplay tags, but I built it because I think we will use it in the future
39:44But we did use is character armed condition
39:51All conditions are based off a use state tree condition blueprint base and it has one overridable function which is test condition
39:57And so we just check the character which is I call it character but it is the context actor
40:10We're checking the context actor and we call the function is weapon equipped which is a function on our character in our character class
40:17So we have a let's see character enemy character
40:23All our characters are based off of our base character class
40:29And then our player and our our enemies have their own different classes
40:34And we have a function uh within here is is weapon equipped
40:43And so it's calling this to determine if it has equipped a weapon or not
40:43Then we you know based on if it's inverted or not, how it returns true or false
40:48And that's all it's doing in that test condition
40:53When creating a condition, you have the function test condition that you override and put your logic in
41:04And then just like you saw with evaluators, we are we have our uh character or actor and AI controller uh properties that we have access through through the uh context
41:11And then we have our property here that lets us know if we want to have this inverted or not
41:19And just like evaluators, there is a get description property
41:27Um, and we're just saying checks if the context actor is armed
41:32Um, and so that is that value
41:37You see here that description checks if contest actors armed
41:43You also see that here, which is why the description is very important because I can look at the tree and visually see what is going on with that tree without even having to go into it and investigate
41:56It's telling me
41:56All right
42:02So, that is the uh conditions and task we'll look at
42:11So there is we'll look at two of these
42:11So the play montage this one's using the ustate tree task blueprint base and it has a constructor
42:25We're telling it that it should call tick
42:30you have to set should call tick equals to true for the tick event to actually fire uh on C++ task our context that property montage so allows us to specify a montage and our play rate now as you notice our category I use the word task you can use any word if you're not saying input output or context just like uh you would do with any of your C++ structure properties, anything like that
43:06But if you notice uh is the montage? Yes, here's the montage
43:12It still allows us to set the properties
43:12So, we could have a property, a global property that is a montage uh and a montage
43:26And we could that's called new property
43:31We could set this to new property or we would name it of course something more identifiable but having so the context input requires you if we set it to input it requires you to provide a link to the property
43:49If you don't set input, but it's still an input value like we done with the play montage task properties, we just set the category to task
43:54You you basically can have it both ways
44:00You can set it or you can set it directly or use a property
44:06So that's a little tip
44:06We have our get description
44:11So if we have set a montage, then we get the montage name
44:11And this is how you can customize your descriptions
44:17So we're returning values here
44:22So this is play montage
44:22It's going to say our montage and it's going to say at the speed of
44:22And if we go into the editor, you see this play montage am sword un sheath, which that's what it is at speed rate of of one
44:33We would also see that here
44:40So we know exactly what's going on
44:40This is why descriptions are important and I'm kind of harping on them, but it helps when you're sharing these with anybody else or you come back to this two or three weeks or a month later and say, "Okay, what is this doing?" You'll know exactly what it's doing because you've set up your task evaluators and everything that have good descriptions
45:00So, as far as the functions, there are three to override
45:06There's a enter state
45:06when the state is entered and the task begins to run, this is the function you want to start setting things up and performing actions
45:12So, if we don't have an actor or a montage set, we're going to say that this is failed
45:19So, we're returning failed
45:19We don't want to go any further
45:25In this example, since it's the playing a montage, we need to get the anim instance for the actor skeletal mesh
45:33Once we get that, we are then setting up event bindings
45:33So this is to bind for uh notify and notify events
45:40Um and then this is to bind for the montage events themselves
45:46And this is going to be very important here in a second
45:46And then we play the montage
45:54Then it's very important to set the state tree to running
45:54So when you're doing something that's like an animation montage in the interstate, you want to say when this ends, you want to say this is running
46:06That means the task is still running
46:06So it doesn't try to mark it as complete
46:12We want it to say it's still running
46:12Then on the tick, what we're doing is we're checking a flag to see if the the montage is finished
46:18if it hasn't finished
46:23So, say for example, the montage takes a whole second
46:23It's a 60 frame montage
46:29It takes a whole second
46:29This is going to be running 60 times per frame if you achieve the acceptable level of performance for your game
46:36You're running 60 frames per second
46:36This is this tick is going to run 60 times for this this task
46:42So, we want to make sure if it's not finished, we want to keep telling the state tree that we're still running
46:48If it is finished, then we want to say yes, we're done
46:55It we succeeded
46:55And as exit state, we want to unbind all our bindings
47:01So we've we remove all our bindings to the events just in case we stop the task for some other reason
47:08Then we want to stop the montage with a 0 2 fade out or blend out
47:08And then we have some properties here
47:14Here's our montage finished uh flag
47:14And here are functions
47:21These consu these are the bindings that consume the events
47:21So uh when a montage started, we're just logging at this point
47:30But when it ends, this is when we set our flag to true, which we know to we know then in our tick that we need to say yes, we're done with this task and we exit
47:38So perform attack
47:38This is for our enemy to perform attacks
47:47We have uh a non
47:47This is our non for random and sequ sequential
47:53We have a strruct that represent the array item and it has these two properties in it
47:59Ability tag selection weight and that's what these here for and it's in this strct
48:12And then we have a instance data strct which is nothing other than a um a strruct that has our values um the values you see in the editor on it
48:19So there's two ways to create some of these components task
48:26I like to create majority of my tasks using the the uh state tree task common base
48:33The play montage task actually uses the state tree blueprint uh base because I needed to use a class to uh trap the events to bind the events
48:49You can't bind the events in a uct
48:56So that one uses a class
48:56However, all the other all the other tasks use the state tree task common and austruct
49:09And so we're telling it what's our instance
49:09So our instance type is that structure above
49:14And then the editor uses get instant data type
49:14So it knows when it looks at this task, where's the the the instance data coming from? So it can display it in the editor and that's how it knows it looks at this function and so we're returning this static str which is this strct here and then we have the same enter state tick and exit states
49:40Um and this for this example in the performance state we're not doing any exit uh state code but we are um playing a montage ultimately
49:53So it continues to run as the actor is attacking
49:53So we have on the actor class is attacking
49:59So while a montage a game play ability is running this is true
50:06It's saying that the actor is attacking because it's currently attacked and using a gameplay ability
50:12And once this is no longer true, we set it to succeed and that means that the task is over
50:18So, it's similar to the other play montage
50:18You just don't have the montage playing code right there because that's in the gas ability that it's going to call
50:26And that's pretty much how you build task and how you build conditions
50:34And we saw earlier in the video how to build evaluators
50:34And using those components with your states, you can create advanced state trees that are easier to build, easy to maintain, and are very performant
50:46I hope you guys learned something on this one
50:51It's kind of a longer video
50:51Um, I had built pre two previous videos and I had planned to create these into a series of videos, but because I have less amount of time to actually create these videos and edit them and get them out, it was best that I just put it all in one video uh that you all can consume
51:13Don't forget all the code for this is on the GitHub and the link in the description
51:18Thanks everyone
51:18See you next time
51:23[Music]
