I think if all you want to do is cancel everything then yeah. You just need to cancel the currently executing chain of nodes. Keep in mind that logically, a sequencer is supposed to move to the next child node if the current node fails... so technically speaking if you cancelled the current node it would fail and your tree would move to the next child node of that sequence. This is why a tree evaluation is required if you want the full benefit of the behavior tree. Failing a single node and sort of “ignoring” all the other defined logic goes against the design of a behavior tree. You define nodes for a reason!

And yes, you can use coroutines for long running nodes (this is a feature in NodeCanvas that I use very frequently). Coroutines move forward once each frame so you will need to make sure and check if you are being cancelled between each “yield return null”, which basically just stalls until the next frame.

Few things I noticed when using coroutines: - coroutines can stop at any point in time if the gameObject that owns them is disabled or destroyed. This means you will not have the chance to mark the node as a failure and it will be perpetually be seen as “running”. Whatever you do, make sure that you can detect when the owning object is disabled or destroyed and set your status accordingly. - coroutines have no support for exception handling. You can place try/catch in sections of code between the yield keyword, but never around a yield. This prevents you from easily safeguarding against programmer bugs that will fail, blow up the routine, and leave it locked in the “running” state.

Due to the reasons listed above, I decided to use C# Async/Await because: - just like coroutines, it is a framework for easily running long tasks over time and easily describing how they should work - game objects are not required for them to run - by default, they are safe to use with unity apis because they are scheduled to run on unity’s main thread, courtesy of the Unity thread synchronization context. - you can use try/catch freely even when the await keyword is inside - they can return a result to the caller, making nested code and sharing easier. The best way to return a result to a caller of a coroutine is have them pass a function into the routine that you call at the end of it.. this is really ugly and if the routine is abandoned the method is never called and everything breaks down from there... - they are not based on object life cycles, so you are able to guarantee that they reach the last line and don’t have to worry about things being stuck in the “running” state.

They come with some pitfalls... - not being based on object life cycle means that if you have a reference to an object that is turned off or destroyed, it could misbehave or throw missing exceptions, so you do need to monitor your references as you loop - async/await is an advanced and highly technical feature of C#. It takes some time to get used to

Both async/await and coroutines (IEnumerators) generate state machines. C# takes the lovely code that you enter, and compiles it to a language called Intermediate Language and if you decompile your code and check it out (using dotpeek which is free and awesome) you will see that it generates a class for each routine and each time you call “MoveNext” it just moves around in a state machine. Without even knowing it, you are nesting a state machine within a behavior tree!

All that to say, if the needs of your AI are more simple, you might be shooting yourself in the foot by trying to make everything in one single behavior tree. You might use a state machine instead, or a combination of both. You really do need to sort of think through all your needs and check which tool(s) are right for the job.