00:00We all know behavior trees, but state trees are a new and exciting way to get our AI behavior, and actually a lot of other fun stuff working in Unreal, so let's enable it

00:13Uh, we go into the plugins

00:15If you don't have the plugins tab yet, you can go up into edit and enable it right there, and we will look for the state tree plugins, where we will enable both the gameplay state tree and normal state tree plugins

00:27Restart the projects to load them in, and then we can get started

00:32So state trees, by default, will actually work very similarly to behavior trees in a lot of ways, but give you a lot more flexibility because they also support

00:42Pretty much the exact same way of transitioning between different states or tasks as a state machine, that's why they're called State Trees, because they are a combination of state machines and behavior trees

00:55So let's make one, and we can start looking at all the bells and whistles that we have with them

01:01So you can just make them by going into the artificial intelligence and state tree

01:05Now that we have this thing enabled, then we get the schema that we can pick

01:10We can either pick a normal State Tree component or a State Tree AI component

01:14If you're working with C++, I do believe you can make custom schemas that will

01:18Also, show up here

01:21I haven't looked into that because, and look, that's not necessary to do

01:24If you have certain state trees that really need to only be used on certain types of actors that have certain, like, unique data that the state tree is going to need to use, it might be nice to have that all automatically provided in with a custom schema, but it's by no means necessary, so we're not going to bother with, like, any of that stuff in here

01:47So we'll limit it to the normal state tree component and the state tree AI component

01:51As a general rule, the only difference is the schema that it uses, so the default data that it provides, and also on what kind of object it runs

02:01The story component schema will run on story components that are on the actors themselves

02:10Wonderful thing about that is that it doesn't need an AI controller to function, so unlike something like a behavior tree that needs to be run on an AI controller, so it needs to be working with a pawn, it can't work with a normal just regular actor

02:24State trees can run on regular actors without a need for any AI controller related stuff

02:30Stage three AI components, uh, run on the AI controllers, which can be nice if you have a specific controller that needs to give behavior to

02:39A bunch of different possessed actors that just share the same type of controller, so if you have like just basic animals in your game that just need to wander around and run away when the player gets near, something like that, you can just make an AI controller that has the state tree for that on it, and then anything that has that AI controller will behave like that

03:02In this series, we're going to mostly use the normal state tree component

03:07I'll show you the differences between the two in a moment, uh, and we're going to still do some AI controller based stuff because the examples that I'm going to show are going to be

03:17Like moving around, which requires an AR controller, but I like personally putting these things on the actors themselves, so let's open up the state tree and let's look at what the interface has to offer, because there are quite a few things here to talk about, and immediately let's start off with, uh, the schema, because that is again effectively the only difference, uh, between the state tree component and the state tree AI component after you make one of these

03:40Uh, as you can see, you can just switch back and forth between the two different schemas anyway, or whatever other schemas you might have custom made in C++

03:47So if I change to the AI, uh, component one

03:50This will make, this expects to be run on an AI controller, and we'll see that the contact variables here, which has only acor, it will change to having the actor ni controller, which also, uh, Chang the fields that we have down here from only one thing for the actor class to two things for the actor class and the AI controller class

04:11So what are these? These are the classes for the context variables, and what are the context variables? The context variables are variables that we can automatically supply into our tasks for whenever we need like something to reference the actor that

04:28We're working with, with that will become a little bit more clear in the next video when we actually dive into making custom tasks, though

04:34Uh, for now, all that we need to really worry about is the fact that we can either keep this very generic so that it can run on a variety of different things, or we can do something like, I'm just going to make a, like, character here, and we'll call that "state tree character," and I will populate all these things in a moment

04:54Uh, but we can also just change the actor class here to specifically "State Tree Character," which will now allow us to access specific variables created on the state

05:05Tree character class, either within the individual tasks or within this interface

05:10Again, this will become more relevant in the next video

05:12If it doesn't fully make sense right now, don't worry, as you will see examples

05:16Hopefully, it'll start making a little more sense

05:22Uh, for now though, we are going to stick with the normal State Tree components, uh, which will also reset this EXO class thing, but again, we'll worry about, like, setting all that up properly once we actually get into the examples of things

05:34Next up down the list, we have the parameters, which, uh, is exactly what it sounds like, it's just effectively

05:40Variables for your state tree, except that these are variables that aren't necessarily meant to change, uh, unlike something like a Blackboard with Blackboard keys that are effectively also variables for your behavior tree

05:54These are meant to mostly just be set once and then not be touched anymore

06:00There are ways, either in C++ or in recent updates also through blueprint, uh, to set these as well

06:04It is possible, uh, in my experience, that causes a lot of crashing in packaged builds because the state trees, uh, have some kind of bug in them, uh, where it's not properly referencing, uh, these values if you're watching

06:21This, in the future, I'm sure that that's been fixed, uh, but for now, we're going to avoid setting these parameters, we're only going to be reading from them

06:28You can set them, uh, just in this interface, no problem, right? We can just make this and call this like walk distance or something like that, very badly spelled

06:37You can set them to whatever you want here, like you can set them up in advance, you just shouldn't set them on run time

06:44There's a lot of work around for that that we'll discuss, and in the future, maybe it'll work, but if you're going to be messing with these things before you get in too deep back at your game, make A standalone build and test whether or not it actually works in that as well, because in my experience, there is a bit of a discrepancy between how they function in the editor and how they function in a standalone build when you're trying to set these during run time

07:10Uh, we're going to ignore evaluators and global tasks for the time being, because those can be videos all to themselves, so let's move on to the theme

07:17Uh, these are just pretty little colors that you can give your states in your state tree, so we can say we want to have a red color, uh, for when they are angry, and then we want to have maybe a, I don't know, yellow color

07:28I like yellow, uh, for when they are scared, and so on and so forth

07:33These functionally don't do anything, these are just there, uh, to make your state tree more readable, uh, for you as a developer

07:40So if we go into one of these states, which finally, we're talking about state trees, right, let's go into one of the states and look at the details that we have for those

07:48We can set the color right from angry to scared, uh, to default to whatever you want, not all that relevant

07:56You can see that each state in itself also has parameters

08:00Ideally, once these are actually settable and they don't crash the game when you set them, uh, this might

08:06Be a cool way to effectively have like local variables within a state that you can set and a reference back to

08:14Uh, for the time being, again, setting these on runtime is a little bit tricky and not very stable, so don't worry so much about these parameters

08:24Uh, for the time being, we have an enter condition, uh, and some transitions, which we'll make a separate video about, and then we have good tasks, which again, I'll make a separate video about

08:33This is just an overview, uh, for you to understand how the structure of all the states works

08:38The next video will be about tasks, and after, we'll talk about like conditions and that

08:41Kind of stuff for now

08:43I want to talk about the different type of selection behavior first, and then we'll talk about the different types of states as well

08:49So the selection behavior, uh, is mostly to do with being selected and what it selects

08:58So if we go, uh, through, through the roots, we can make a couple of child states

08:59You can right click and add states this way, or you can add states, uh, just through the add state button, but this is a little bit more precise where you can add either sibling states, so that's a state on the same hierarchical level as the state that you're currently, uh, clicking on, so in this case, these

09:16Are uh, part of the same parent state, in this case that's no parent state, or you can add a child state, which adds a state that is linked to this as a child

09:29It is important to realize that once this state is selected, this state is not considered unselected necessarily

09:35When a child state is selected, it also counts as the parent state being selected, and the reason that's important is because you can explicitly go immediately into a child state, which will also activate every parent of that state in tune

09:52That'll probably make sense a little bit later if it doesn't right now, so let's add a couple more child states

09:56To this, uh, to show off what Tri select children in order does, because this is the route, and the state tree is effectively just going to start off with the root state, and the root state is just the topmost state in this interface

10:11So if I make a sibling state to this and I put that here, it's going to try to enter this one first

10:18It's just whatever is in this position is the first thing that's getting entered, so then when this thing is selected, uh, it will try to select its children in order, so it's going to try to select this one first, and based on its enter conditions, it's going to check, "Hey, can I enter this, yes or no?" If no, It's going to move on to the next, and it does the same thing until it finds something that it can enter, which is exactly the way that a behavior tree would function

10:41So, by default, if you don't set up any transitions whatsoever, it's just going to behave like a behavior tree, and as you can see here, at the end of every state, we have this thing that says "back to root," so after a state is done, it's going to go back to route and do everything all over again, once again, exactly the way that a behavior tree functions

10:59A state tree is just a state machine that behaves like a behavior tree

11:04It's the best of both worlds, but Selection behavior doesn't just stop with trying to select the children order, we also have none, which makes this state unselectable

11:14I frankly have no idea why you would do this, straight up, no idea why this exists, but it does

11:19So doing this makes it unselectable

11:22If we just go into here and we make a transition real quick, uh, you can see that it gives you an error because you can't enter the root state

11:30I suppose if you want to explicitly enter one of these states and then also want this to be considered active because it has some tasks on it that you don't want to directly be able, uh, to only do this, that's where non

11:45Comes in, uh, I don't see too much use for that, but it is technically a possibility

11:51I guess the much more useful version of that is "try enter." What this will do is, it will just enter this state, but not try to activate any of the child states, so we can explicitly just enter this and do whatever tasks are on this state without bothering with any of the child states

12:08But if we go into any of the child states, it will do both whatever it is on this and the child states

12:11As a fair warning, that also means that if this completes before whatever child state, uh, completes, that this is going to be marked as completed, and it's going to do Its transition, which either is going to go back to, like, route or restart the tree or whatever, and it doesn't necessarily wait for the child to be finished, the other way around as well

12:32It's just whichever one finishes first is going to do its transition

12:34Then we have the "try selecting children in order," which we talked about, and we have "try follow transitions." This is effectively just a, "Hey, I want to set up my own logic for what you should do, just like make my own transitions with conditions and all that kind of stuff." The difference is, for "try follow transitions," is that if it finds any transition that it can do, It will do that instead of its own task, so it never actually starts with its own task if it can transition through, whereas when you do "try enter," at least the task will get started, and then it will start doing transitions, which brings us to the types of states that we can do

13:10Um, the most basic one, which most of the states are going to be, is a state

13:14This is a state that can contain child states, like all of these, and this can nest as deeply as you want, right? So you can make a child state and a child state and a child state, and they can all, like, whenever we do this, it'll also have this and this and this all active, so that's chart

13:31States, but it can also contain tasks, which is like actual code to run, which is what the behavior is going to, like, be based on

13:35Then we have a group

13:40A group is effectively just a state without tasks

13:44You can see as I go back and forth between state and group, it just, uh, makes the task little thing here disappear

13:51This is purely for organizational, uh, purposes

13:54So let's set this back to try, uh, and select an order

13:57We can select this as a stat to go to

14:00It won't have any code, uh, of its own to run

14:03It'll just be a redirector to, like, whatever child state that we're going to go in, quite useful

14:07Next up, though, we have linked, and for Linked, we need to, uh, talk about sub tree first, so you can mark a specific state here

14:17Uh, let's say this one as a sub tree, and let's call this, uh, sub tree

14:24Usually it makes more sense, uh, to make this like an actually, like, separate thing altogether from the tree that we're working with, but it doesn't have to be

14:34And when we set this to, uh, being linked, we can link it to anything that is marked as being a sube, and what it will effectively do is, whenever we get to this state, so it would make more sense to do that on like a CH state, like all the way down here, like linked, when we get to this, it's just going to run whatever sub tree

14:51We link it to as this state, so a state tree has this concept of being able to be finished as one of its transitions, so we can say, uh, here, if we like, on state complete, we can mark this as, instead of transitioning to something, as the whole tree having succeeded or failed, and when it does that, it finishes the sub tree and it marks this state as completed, so you can have these entire sub trees accessible and run them as a singular state

15:25I personally don't love doing this, uh, because of the next thing that we can do, instead of doing a sub tree, is we can use a linked asset

15:34This effectively works the same way, but instead of Making a sub tree within this state tree view, you can just link an entirely like separate assets that it will run until it is marked as being completed, and that will then mark the completion of that state

15:51The upside of that is that you can make many more modular small pieces, like if you have a character that needs to have a patrol routine, right, it starts at a location, then it finds something to walk to, then it walks through there, waits for a couple of seconds, finds a new location, walks to there, waits for a couple of seconds, something fairly simple, of course, it can be more complex than that, but a lot of your characters

16:13are probably going to need to use that, so you can make a state tree specifically for that, and then just use this as like a linked asset, so anytime a character needs to patrol, you can just link it to that other state tree, and that is effectively like a sub state tree that makes the code a lot more modular, a lot more reusable, uh, than using these linked sub trees, which is also a possibility and sometimes might be nicer to do, uh, but I personally think that using linked assets is a little bit smoother to work with

16:49So those are all the types of states that we can have

16:51Now, none of this does anything yet because we need to

16:56Actually, like start programming some tasks for this, so let's just remove all of these, and we're going to change this back to being a state

17:01The root usually, uh, can actually be a group instead if you want to, but we're going to just change it back to being state, everything back to default, and we'll make a character that has this state tree on it real quick

17:15So I already made this state tree, uh, character, uh, character class, and here we simply just add a state tree component

17:23Again, if you're making the state tree AI schema, you're going to need to add the state AI component, and you need to add that on the AI controller, not On the character itself, we're going to stick with state three, uh, normal here

17:37Apparently, I already added one of those, so in there you have this, uh, State Tree AI thing, and you can see we can pick our schemas here

17:44We only have one schema, and I already picked it, and here we can even change the walk distance parameter

17:50Remember the parameter that we made, the walk distance, that I said you can't write to? Uh, you can very much just say, hey, I want to set a custom value here, like I want to make this 1500 for this type of C character, and then whenever we use this walk distance in any of our tasks, it's going to, uh, use whatever value

18:05We gave in there because it's just a variable, we can say whether or not it should start your logic automatically, uh, and all that kind of good stuff

18:11So let's add in a, uh, child state real quick, and we're going to just add in a task, uh, debug text task, and the text will just be "hello," just so that we can see that it's actually running

18:27We'll talk more our tasks in the future, already put it in the world as well, so now when we run this, we should be able to see right there, it says "hello." Uh, this actually seems a little bit broken because it's supposed to use the actor as the location, and this should be offset, but apparently it's

18:45Doing this as world location, but we can see that the debug, do that we apply it to, uh, the hello is getting added to the world as a debug thing, so our state tree is running, congratulations, and you have technically added your first task

18:59It doesn't really do anything yet, uh, but I think this is quite enough for the first part here, so we've run through all this so that you have a basic understanding of where everything is and what kind of things they do

19:11If you aren't really following along in a lot of detail yet, uh, don't worry, as we start going through and actually making stuff, all of this information will start to

19:21Click into place and you'll start to understand what is actually going on, but now that you have all of this basic, basic knowledge of like what all of these little uh different things are, we actually can start to use them

19:32And a very big thank you to all my Patreons, you can see them on screen right now

19:37If you want to help support the channel or get any of the project files in any of my tutorials, there's a link down below to the Patreon page to support me, or alternatively as a YouTube member

19:48And of course, an extra massive thank you to my Cave Digger tier supporters, Serj Thomas, and my Cave St to support USU.