00:00All right guys, so in this video we're going to go over, um, I'll briefly go over this problem right here where he kind of jitters there

00:06Now that's caused by RVO avoidance, and it's, you can, I believe it's caused by RVO avoidance, probably not exclusively, but I do believe that plays a factor in it

00:24And under the crowd manager in your project settings, when you're using the detour, uh, crowd AI controller, uh, these are the settings that control that

00:36Uh, so I don't know a lot about tweaking this, I'm not really that familiar with it, so I'm not going to go into it obviously, but you might be able to find a video on, uh, the Crowd manager or something floating around

00:46Um, if not, then you can, uh, go to your AI controller and you can reclassify this as a regular AI controller, and then you can just try using the RVO avoidance on the character movement, uh, component

01:07So let's just type in avoidance, so right here you'll see we have this RVO avoidance, and this is the avoidance consideration radius, and that's the weight, so that's all the control you have over whenever you're using it from the character movement component, and in fact, you can actually have both the Detour crowd AI controller RVO avoidance in this enabled

01:38But I don't think there's actually really a point in it, because it's already being used by the dour crowd AI controller, and it's kind of integrating it into the path finding, and so if you use this one too, it may seem better

01:52I've, I've seen some comparisons of using both versus one, but I think you're just doubling the uh, performance hit of it for no good reason

02:03That's just my opinion

02:13Uh, so, uh, anyway, I mean if you type in uh, "Ro," you'll see the rotation right here, it's 500, that is pretty high, and so if we turn that down, that'll probably smooth uh, that jittering out quite a bit, just be careful not to turn it down too far, or Uh, your character won't be in sync with the way he moves

02:24Uh, so you, you see that time it was a little bit better, it's not jittering now

02:28So the rotation rate does have an effect on that

02:32If the rotation rate is too high, it can cause jittering with the AI

02:37But anyway, let's go ahead and uh dive into the environmental query system

02:44So we'll go ahead and start setting that up, and so under our smart objects, I'm just going to place it in this folder, and my organization for this series isn't really great, uh, so you know, uh, follow my organization skills in this project at your own risk

03:02But anyway, we just want to create an Environmental query, and that's going to be under the artificial intelligence uh category, environmental query, and so we're just going to say EQS uh query smart object actor actor

03:23So we're querying an actor of type smart object, and so in order to do that, uh, we actually need uh to be able to query um a parent class of all smart objects, so that's where inheritance comes in

03:37Uh, so actually I've, I already started this, but I, I kind of made a lot of mistakes, and so I started over again

03:45This would actually be the bench right here, but um let me just update these redirectors, so that actually was the bench, uh, but we're going To rename it to Smart, uh, let's, let's name it to SO, so, SO Master Smart Object Master, and then we're going to create a child blueprint of it, and we're going to call this bench

04:22And so we are going to replace this one in the world with this one that's selected, so we're going to right click on it, if I can get it to right click, it sometimes it won't do it, so you might have to zoom in and right click on that little decal, and then go to replace selected actors with BP_SO bench, so now it's been replaced

04:43So we're going to open up both of these, uh, first off, because we're going to clear these out on here, so that, uh, these won't be loaded

04:55Into memory automatically whenever, uh, the game starts, and so we're going to manually set these on the other one, and I'm going to clear this one out too

05:07So I'm going to go to this one, and we're going to leave these, this, uh, channel the way it is right here

05:13You could also make your own collision preset for smart objects if you want, or you can modify the ones that are already, uh, there

05:25If you want to modify the ones that are already there, you can go to Collision presets, uh, and you can just double click on one of these, and you can modify them, change their object type

05:31Uh, I'm not going to go too in depth on that, uh, because That's not what this is about, but anyway, so we've cleared out that static mesh, and we're going to set this one, the same one

05:48And so now basically everything's the same

05:54So the main point of that is, is that if you want different types of smart objects, uh, then you're going to want a master smart object, and later in the series, I'll show you how to do a general, uh, smart object, uh, that I used in my project, and I guess I don't have it open right now, uh, but I'll go ahead and open it, and I'll go over that with you guys, uh, just so that you understand what I'm talking about as far as a general smart object, because I did explore this a

06:20little bit, and they seem a little static and not very flexible, but if, if you do things just right, then you can make them fairly flexible

06:33Uh, so right here I have a, uh, a general smart object definition, and I'm using the same one for like five different things over here, and basically, um, I'm coming in here and I can change, I can change the state tree if I need to, uh, uh, or the smart object definition itself, but I can change the state tree that's assigned to that smart object definition to a different state tree, you see, and I'm actually doing that in one of these cases over here, so, uh, that kind of allows a little bit of Flexibility, and how am I doing that? Uh, I'll go ahead and go over that with you since, uh, I'm already in here

07:14So actually, all you have to do, and I guess I'll remove this, all you actually have to do, let's see, is you see right here where the state tree is, press this little button here and promote it to a parameter

07:34That's all you have to do

07:39But, uh, yeah, let me, okay, that caused it to, undoing it caused it to crash, that's all right

07:47Uh, but anyway, you, you get the point

07:54So, uh, anyway, moving on, and it looks like I restarted it, sorry about that

08:02Um, but yeah, uh, so I just, uh, I'm using a tag, you know, I have these different things so that I can

08:07Loop it or do montages, but anyway, so moving on, we're going to go ahead and set up our EQS for this now, so we can actually close out both of those, since we've already taken care of that, and under the smart objects, you'll see the EQS

08:28I'm actually going to drag this master out into the smart objects folder right here

08:33Now, anytime you move something, right click on content, or right click on the folder you're in, and do update redirector references

08:40I always do it on content, because I might accidentally miss something if I don't, and then you just press that button on the left whenever it pops up, so, uh, What that does is it fixes redirectors

08:55If you don't, and your game crashes for whatever reason, why there's redirectors floating around in here, then it could break them, and it'll cause problems

09:07Um, so anyway, opening up the EQS, uh, you'll notice that under the generators, we do have a smart objects

09:13The problem with this is, uh, it seems to be, its purpose seems to be that it'll actually just return the location of a smart object slot

09:28Um, that's basically what I'm getting from it, so it actually just returns the location of a smart object slot

09:40We don't want a smart object slot location, we want to claim a smart object, so

09:45The only way that I know of that we can uh do this is by actor, so if we have a reference to the smart object actor, then we can still uh claim a slot on it from that reference

10:00And so we're going to do an actor of class here, and we're going to set the search radius to something like uh uh 1,500 or 2,000, it's up to you, but if you come over here and you go to your top right here, you can uh press your middle mouse button and drag out, and that'll give you an ideal as to how far uh 1500 is, so that's a pretty good distance as you can see

10:33Uh, 1500 is um, so 2500, as you can see, would probably, it would look to be about as, about double that

10:44Uh, but yeah, so anyway, that's how you can uh determine how far out you probably want it, and you can actually create a query parameter right here, and you can pass in that search radius float value externally

10:59Now, as far as I know, you can only do this with float values, anything that has a float value, you can do a data binding to it as a query parameter, and then you can pass that in, but I only know how to do that with parameters, I mean a float uh parameters

11:18So, so anyway, the search center is the querier, so the querier is the one that's uh the actor that we're doing this on or for, so the searched actor class, that's going

11:30To be our BP, SO master, and so we're looking for anything of type Smart Object Master

11:39Yeah, and so now we can set up, let's say, a distance

11:48We can filter by distance, so if we click this, uh, you'll see we can set a distance range

11:58Uh, I'm going to do inverse linear to inverse that

12:06Uh, otherwise, if you, by default, with linear, uh, you're searching, uh, for things outside of this range, basically

12:19Uh, well, this is the scoring, so actually with the linear, the further away it is, the higher the score it gives it

12:26And so if you do inverse linear, then the closer it is, the higher the score, uh, and you'll see it right here, it says prefers lesser, uh

12:38Distance, and so we'll do something like, uh, uh, let's just say 150, and our max will be 200, well it'll be 500, and really we don't need a max, so let's just set a minimum, so our minimum will be 150, because our radius is already clipping everything else out beyond 1500, so there's no point in doing a ranged based, uh, filter and score system, and in actuality, I'm not sure we actually, uh, even need to filter

13:25Yeah, I mean I guess we could only do, uh, the scoring part of it, so it's up to you

13:31So we'll do a DOT product too, and what this will do is it'll allow us to, um, and I'll show you how to test this too without starting the game, so what

13:43The dot product will do is, it's going to allow us to uh test to see uh how that point is oriented, or that smart object actor is oriented in relation to the actor uh that we're querying for

13:55So, for line A, this is where it starts at

14:06Uh, we're going to do a two mode from uh one location to another, and so we're starting at the querier and we want to go to the item

14:18And so you can actually uh create your own uh environmental query content text uh that stores a specific actor, and it'll show up in here too, but I'm not going to go over that in this one

14:33Uh, but for this, we just need the querier and the item, so the item is actually the

14:39Point that were that shows up in the query, and so in order to make this clear, we're going to go ahead and create that actor I was telling you about

14:45So right click and go to blueprint class, and just type in EQS, and you should see EQS testing pond, and we're just going to call this, uh, EQS testing

14:57And so, uh, it looks like my, I don't know what's up with that, it's weird

15:03Okay, my man, dude, this has been happening a lot, it's so annoying

15:09This has been, this bug has been in here since Unreal Engine 5 was released, they need to fix it

15:15Uh, basically my screen is frozen and I have to reload the map or restart the project in order to

15:21Unfreeze it

15:28It's some kind of rendering bug, I don't know, it's really weird, but it's hyper annoying

15:35So, uh, anyway, under Smart Objects EQS Testing Pawn, we'll drag this out, and, uh, it should already be pulling them up, but it's not

15:46Uh, we're supposed to be seeing the, oh right, okay, I'm, uh, missing this right here

15:52So go into details, EQS query template, and we want to choose that one that we just created

16:05And so now you'll see that there's a little blue node right here saying that it's being filtered out, that's not included in the filter

16:12And so, uh, and that's because we haven't finished this dot product right here, so we want To whenever we do the 2.1, we're doing a line, uh, or we're doing the dot product in relation from this actor right here to this item right here

16:31This is the querier, this is the item, and so that's why we're doing that

16:38And then rotation, the rotation of the querier is what we're interested in, and we want this to be 2D because we don't need it to be 3D, uh, it'll be more performance friendly if we do 2D

16:50So, uh, we don't necessarily need to filter those, uh, so we could actually just do score only, and we'll do, let's see, okay, so right now that seems to work

17:09We need to duplicate this in order to fully test it, so if we select to this

17:15Other one right here, if I can get it to select

17:21Uh, and you'll see it hasn't updated yet, but as soon as you move it, it'll update

17:26So you'll see this one actually has a low score, but if I rotate it, that score goes up and the other scores go down, because, uh, as you can see, the character is pointing this way, so that allows us to make sure that, um, that the ones that are more closely oriented with the character will be scored higher, so that he goes to one, uh, that that makes sense, because you would expect him to walk forward towards the bench rather than turning around and walking to the one behind him

17:59So that's just, uh, You don't have to include that, but if you want to include it and then just disable it, you can just uncheck that, and it'll disable it

18:05That's all I'm going to do for this one though

18:12If you want to know more about environmental query systems, then you can go watch dedicated videos on that

18:18So anyway, that's an environmental query for a smart object

18:25So, um, we could actually move the state tree over here, uh, but I'm having, I'm seeing some kind of weird bug whenever I move the state tree over here, uh, and I do a state tree AI, and I convert this one to a state tree AI, uh, then what happens is it won't actually load up

18:50Unless I specifically, uh, uh, do a, uh, start, um, a start logic, um, yeah, let's see, state

19:06So it won't actually, uh, start for some reason, even though it's, it's set to start, unless I do a start, a start logic off of it

19:18So, uh, I mean, you could move it over here if you want, you'll still have access to the third person because, uh, this actually gives you access to that

19:24And in fact, I guess we can go ahead and do that, so if there's any problems, you can always switch back, it shouldn't be a problem, but you have to set this to state tree AI component

19:44And then over here, we're going to remove it off of this one, compile it, and save it, and then Over here, it should show up

19:52If it doesn't show up, that's because you forgot to set the state tree AI component from state tree component to state tree AI component

19:59It needs to be state tree AI component, or it will not show up in the state tree AI component, so with that out of the way, we'll see if that works

20:11If it causes any problems, we can go back and fix it

20:17Now, that doesn't require us to change this use Smart object act, uh, use Smart object task, uh, to an AI controller, but it probably actually makes more sense now that we have a reference to it, so we'll go ahead and change that, so you'll see right now we're

20:31Getting the AI controller from the actor, we don't actually need to do that

20:37We can say AI controller, and we can change this to an AI controller type

20:46Now, we can just plug that directly into there and it'll work

20:59I'm going to toggle those off because I don't need those anymore

21:04So, um, let's see, let's go ahead and open up our find smart object

21:19We're actually probably going to have to copy this over

21:29Now, I did have some problems with this when I set it up in mine, and I think it's bug related, so what I ended up having to do is, whenever I set mine up on the EQS one, for some reason this claim handle never properly makes it

21:43Over to this used smart object, even though that they're bound, it's bound to it, it's not making it over for some reason, and I don't know why

21:50Now, in my project, the same thing happened, and so what I ended up having to do is, I ended up having to store, uh, this claim handle reference on my, uh, AI controller, uh, and then I had to, whenever I used it, whenever I called the use Smart object, I had to call this off of my AI controller

22:16So, uh, we can actually do that as well

22:22So, so what we'll do, we'll just leave this like it is, we won't change it to an AIC NPC, what we'll do instead is we'll end up binding it from the AI controller, since we

22:37Have access to this stuff in here, and we'll change this one to AIIC NPC, and then on the AI NPC, let's see, I'm going to copy this, and I'm going to paste it in here, and then I'm going to create a variable, so this is where we will be storing it, the claim handle, and this will give us a workaround, and now we'll be able to actually bind that to the claim handle on our AI controller

23:16So, um, first off, let's just go ahead and make sure this still works, so we'll go to the debugger

23:23Okay, so you'll see the debugger, it's still showing that it's working, which is good, that's, we wanted to make sure that it still works if it doesn't work for

23:34You let me know, maybe just revert back and store that variable on the actual actor instead

23:40Uh, that that's my only solution for now for that problem

23:47I do believe it's a bug, uh, but let's just go ahead and create that task

23:53So we're going to create a new state tree task and we'll call it, uh, "Query Smart Object." And so we'll do an interstate, and we need an AI controller, and we'll do this one as an AI controller

24:38And now what I did on mine, and let me actually just close this because people might start blowing me up, I did a, uh, stop movement on mine, and now it's doing it on my phone, so let me silence my phone

24:53Uh, so, so I did that on, I did

25:00That you don't have to do that, that's just something I did for mine

25:08I don't even remember why I did it, but, uh, you might find that it's important for whatever reason

25:16So like, if you're chasing an actor right here, then, and you interrupt that, then it might be that he continues chasing the actor

25:24Uh, I think that was the reason why I did it online, just as a failsafe, but anyway, we're going to do an EQS, uh, run EQS query, and we're going to run this specific one right here

25:37We want the single best one, but you can choose the random best five or 25%, or you can do all matching

25:44You can also set up a wrapper class, I'm not sure what

25:52The purpose of that would be, though, uh, you can also do a, uh, set named, and that's what I was telling you about, about the floating point values, but you have to, uh, pass in the name that it assigns to it

26:00So, for example, if I come in here and let's say I want to bind this search radius to a query parameter, uh, you'll see that this is the name, so this would be the name that I would actually have to, uh, give it, and then I would have to set the value of it right here, and that's how that would work

26:26So I'm not going to do that in this one, I don't really feel it's necessary, but I wanted to show you how you could do that, so that's how you would

26:32Do it

26:38So what we do need to do though, is we need to bind uh, event to on query finished, so when the query finishes, it'll return a value

26:43So off this event, uh, thing right here, we want to do an event dispatcher and create event, and I like to do it this way because it's wireless, uh, and create a matching uh, event, and then we'll just say, uh, claim smart, claim smart object

27:08So what we're going to do off of here is, this is going to return the status of our query, if it failed for whatever reason or whatever

27:15So we're going to do a switch off of this, uh, and this will allow us to fail this state if, if the query itself failed, and that's the

27:22Reason why? Because we only want it to try to do this, uh, if it's successful

27:31So, uh, off of the query instance, we can say, "Get query results as actors." Uh, so this will return all the actors that pulled up, and since we're doing the single best item, there should only ever be one that's returned here, but it will return it in an array, just know that

27:49Uh, that doesn't mean, um, oh, I don't know, I'm saying break branch

28:01So we want to do a branch off of here, sorry, I get distracted easily in case you haven't, uh, noticed

28:09So we're going to do a finish task here, and we want it to be a failure if it failed, was aborted, owner was lost, or if it's Missing parameters that, uh, are required, then we want to fail it, and if this, uh, fails right here to find or to get the results, uh, as actors, then we also want to fill it

28:20This is actually going to return a copy

28:31I don't think that's going to be a problem

28:42That wasn't a problem for me, uh, but it seems like you can only get a, uh, a copy of the actor and not an actual reference to it

28:50If you do a, uh, for each loop though, it'll return an actual reference to it, so I'm thinking that this copy right here, when in terms of actors, it's not actually copying the actor

29:05I think it's probably just passing a pointer, I don't know for sure, but anyway

29:11So off of this, uh, find Smart Objects, what we're going to do is everything after the find Smart Objects, right here, we're just going to copy all of that, and we're going to paste that into here

29:32So actually, we don't need that part, because I already set that up, and we're just going to see, oh right, okay, so what we need to do is we need to do a, uh, we need to scroll down here until you find Smart Objects

29:47Let's see, 'cause I don't remember the exact name of it

30:03Okay, so find Smart Objects and actor, this does not require the Smart Object, uh, subsystem, and so that's why I manually searched for it, so this will go into this random node and

30:11Actually, I guess we didn't need to delete that

30:19Uh, this has a return value, so we want to do a branch off of this, just like we did before

30:27We want to try to catch if something fails, for whatever reason, we want to know what it was, so, or we want the state to fail, so we're going to, you see this filter here, we're going to promote this to a variable, so we can, so we can set it from the state tree itself

30:48This user actor, same as the one over here, it requires, uh, some kind of actor, so we're going to replace that one with the AI controller, and we're going to replace, uh, we're going to hook this one up to it too, and then we're

31:01Going to pro, well the thing is, is this is the part where we have that problem

31:09Uh, but yeah, let's uh, let's promote that to a variable, and I'm going to do a set by ref

31:25I'm hoping that'll work

31:45So if I set it by reference, then what we can do is we can make this an input, and that'll be a required one also, so we need to make this context

31:57So this will be an input, and so it'll, it won't comp unless we bind this to that variable, kind of saves us from ourselves

32:09We don't actually need this to be hooked up, but what you can do is you can do a uh, uh, should, should finish task and make this a Boolean and expose it, expose the filter as well, and if

32:37That's true, then we'll finish, we'll fire a finish task that allows you to use it however you want, uh, in the state tree, so you can use it like I'm doing here, uh, or you can use it as a stand alone, uh, it gives you that freedom, and that's the reason why I did that, so I do that on my own as well, so that I can determine if it should finish the task or not, because if it finishes the task, you have multiple tasks here, then it probably won't execute the other task, uh, depending on your order of operation, obviously, but that should pretty much be it, so we're going to, oh wait, no, let's go to class settings, and I believe this was

33:31Custom bar, smart objects, bar utility, we'll call this query smart object, and so this will uh look for the closest smart object uh to the player, as demonstrated here, the closest one and the one that is directly in front of them, more than likely, not necessarily

34:04If, say, he's over here, then it may be the case that it selects this one

34:09Actually, looks like I might have, oh, my search radius, I thought I set that to 1500

34:24Okay, anyway, so you'll, you'll see that just because that one's not directly in front of him doesn't mean he won't choose it, he'll choose this one because it has a higher score than that one, so in some

34:30Situations, just because he's not, uh, just because he's not, uh, facing it, does not mean that he won't choose it, so I wanted to point that out

34:52Uh, so we bound this one to that, uh, variable, on this one, the claim handle, and we're going to bind this one to it as well

34:59And so actually, we could probably, okay, that one's already an input, so it forces us to bind

35:08Okay, so we're going to switch over to query, and we're going to, uh, select this right here, and we're going to bind it to that claim handle, and we don't want that to finish the task, so we'll leave that disabled, but if we did, we could check that, but then the use Smart object

35:30Wouldn't be executed, uh, most likely, uh, can't be 100% sure on that, so they'll probably fix that later in the future, I imagine, so that if tasks are stacked, then they won't execute, they won't finish, uh, and they won't transition until all of them have, uh, executed, but currently, if you fire a finished task and there's multiple, then it's going to transition regardless, uh, so that's just something you have to keep in mind

36:02Um, I'm hoping I got everything right, we will see

36:08So remember that bug I told you about, so I can't be too sure that hasn't affected this, so it doesn't look like they're moving, uh, but you'll see that

36:15They are looking for smart objects, for some reason

36:22It's not actually, uh, doing anything

36:29If we break on exit, the thing is though, is that these, uh, break points inside of here, they don't always work, so they're supposed to pause it, uh, in case you didn't know, but they don't always pause it

36:38Okay, it paused it

36:47Okay, let's see

36:51So I think it's exiting it

36:54Oh, no, it entered it

36:58Okay, yeah, so at least I know that works

37:02Let's see if it does it on, uh, if it does exit it

37:06It does not

37:11Okay, at least it doesn't appear to be, but you see this is flashing right here

37:16I don't know if that's important

37:21I don't think it is, but it seems like it's stuck, uh, so

37:26What we need to do is, we need to, let's see, this might not be working

37:35Let me set a breakpoint right here

37:44We'll fire this and see

37:52So you'll see, we do have a claim handle here

37:58It did give it a user ID

38:03This was the same problem I had before

38:09I thought this would fix it

38:14Let's go breako on this

38:26Okay, so it's passing the user handle, but the more object handle is not there

38:37So we can go to deep blueprint debug on this, and we can search for claim handle

38:44You're using an older version

38:50This will cause your computer to seriously lag, just giving you a heads up

38:56So I'm pressing this arrow here, and it's not, it's not expanding, which Probably means that it's a null variable, it's never been set

39:03Let me just confirm that first, though

39:09Okay, that's not the case, it's a bug

39:15Okay, but yeah, the smart object ID and that slot handle, it's not being properly set

39:23Okay, so that kind of complicates things

39:34Uh, I don't know if setting it directly will actually fix it, we might have to use a blueprint interface

39:41That's, I used a blueprint interface on mine, I thought maybe that would, uh, that would work, but let's see

40:05So you'll see that one fires first for some reason, and then, and then this one fires, and then that other one will fire

40:13I don't know if that's a bug or what

40:21Uh, I feel like it shouldn't be doing that, so the smart object handle is 5953, and right here you'll see it says 5953, but this is for AI controller NPC C1

40:28Uh, so over here we'll go to, let's do the debugger again, NPC C1, this one right here, and you'll see it's empty, it has no smart object handle ID, so it wasn't properly set using this method

40:49So we're going to have to create a blueprint interface, that's how I had to do it in mine guys, I don't know what's up with that, I hope they fix that here soon, but let's just do a BPI, NPC or AIC, uh, NPC, and then we'll go to class settings under interfaces right here, uh, we'll add that BPI NPC, and Let's just go ahead and press this brow button, it'll open it up

41:26I'm going to call this set claim handle, and I think it's a little ridiculous that I have to create setters and getters on a blueprint interface just to communicate, but uh, until they fix those bugs, that's what we're gonna have to do and get claim handle

41:47So the git claim handle is going to return a claim handle, and if you're confused, you can move your cursor over this more object claim handle type, uh, so smart object claim handle and claim handle, and then on this one, this will take a claim handle and it should automatically set that one for you, this

42:23Time, and then we'll save and compile, and then over here, okay, you have to compile it, apply the setter and the getter, and so now, oh wait, that's not going to help

42:40Uh, so we actually need to use it

42:56So off of this AI, uh, controller, in here, we're going to do a set claim handle message, and we're just going to pass that in like this

43:13So now we can actually remove that because we don't need that anymore

43:21We're going to compile and save it, and I'm hoping this is all we have to do, but if you want to be safe, you can actually get it here, so what we could just go ahead and do is we could just go ahead and preemptively do this so that we don't

43:42Have to worry about any problems, so we'll go ahead and remove that

43:58We'll just save that, and now it should, should work, I hope so

44:13It looks like it's still not doing anything, so let's see here

44:21It's not even running, so this seems to be a bug, uh, something to do with maybe converting these

44:27Oh wait, it didn't compile, so we need to recompile

44:33If your shows a little red thing up here, just recompile it and save it, and then run it again, and it should start running

44:39Let's see, hopefully, uh, we're still not receiving an ID

44:47Okay, okay, uh, so that might have something to do with it

45:04Let's do it like this

45:13Let's see if this, if this fires

45:22Then we'll know that, uh, that this was set properly

45:31Okay, and it fired that time and still not getting a claim ID

45:42Okay, I'll be right back

45:53All right, so this seems to be a timing thing, and this is really weird, but, uh, if you don't check to make sure that your claim handle is valid, uh, beforehand, before trying to use it, that seems to break it for some reason

46:03I don't think this lock AI logic thing, uh, was a factor in that

46:08I did disable it, but what you need to do is you just need to drag off of this and do an is valid, uh, check, and then just do a branch off of that, and then, uh, just copy and paste this right here, and plug that into

46:28There before, so that's, uh, basically the rundown on that, and I'm just going to move this over here, and you can actually temporarily store that and then plug it in over here, or just rewire it like this, like I'm going to do, totally up to you, but that's basically all I had to do to fix that, so I'm going to disable that and leave everything else like it was, and so now, um, it should be working for you

47:11Let me just disable that

47:21There you go

47:31You'll see the NPC IDs right there on those lines, so there you go, that's, uh, that part out of the way, thank God

47:39Oh my gosh, I had to do this like three times in a row, guys, it was, it was bad, uh, all

47:48Right, so finally I was able to get you guys moved over to the, uh, to where your state tree is on the AI component, uh, controller

47:56I didn't really have to do mine quite like that, uh, so, or maybe I did and I just didn't realize I did it

48:08Anyway, little bit involved process there, it can be frustrating at times, we got it working though, and now everything's a little bit more modular, um, and we have a proper, uh, querying of the smart objects, at least until they fix that find smart object, uh, objects, uh, function

48:30Until they fix that, this is probably the way to do it, because, uh, this right here is the problem, this fine smart objects

48:38Even though we're giving it a user actor, uh, and we're giving, giving it our request, it seems to be querying, uh, this world origin right here and not the actual

48:47So I'll look into that

48:55That could be a misunderstanding on my part

49:00I don't see why it should be

49:05Uh, if it is a misunderstanding, I think they should, I think they should make this a little bit more, uh, intuitive

49:10So if you pass in a user actor, I think it should be looking for it based off of that user actor and not the world origin

49:17I don't know why that would even be a thing

49:23Why would I ever want it to be looking around the world origin? But anyway, we got it, we got that fixed, and Out of the way, so um, before we go, um, I guess I'll go ahead and, no, no, no, we're going to do this in the next video

49:41So in the next video, uh, we're going to extend this so that they do, they randomly walk around, and then after, you know, maybe randomly, they'll look for a smart object

49:53We'll do that in the next video, and I'll see you guys later.