#behaviour trees

[remembercomic]

A brief demonstration of one use-case for editable behaviour trees for the purposes of sandbox automation, featuring a fox.

The tree used in this demonstration is 15 nodes in total, which is relatively small. It primarily consists of only two behaviours: retrieving up to 8 fuel whenever its hands are empty and the lamp is on, and cycling through the furnaces giving them 1 fuel each. Otherwise, it waits at its initial position.

The lamp itself only serves as an indicator that enough fuel is present to retrieve, which ensures the fox distributes it evenly. Beyond that, the fox's behaviour tree is entirely responsible for the automation demonstrated.

In this particular implementation, the number of furnaces is entirely arbitrary and the tree can handle as many furnaces as the fox can hold fuel. The only thing that would need to be changed is the contents of the Furnace Array variable, the tree would handle everything else.

Without the fox, this particular automation problem would necessitate dozens of ticking tile entities (in the form of hoppers) and significantly-complex wiring dependent upon discrete knowledge of the game engine.

[remembercomic]

Fundamental Elements of Automation

It can roughly be said that a behaviour tree is only as useful as the sum of its available conditions and actions, to that end when building a behaviour tree system for the purposes of automation it becomes important to consider what actions the player takes most frequently to identify what nodes will be necessary.

Virtually all sandbox games for example include a degree of inventory management. This is to say, not only picking items up from somewhere in the world but also moving them intelligently into a container for long-term storage. Useful conditions in these contexts include the exact type of item that a given item represents (such as a set of wooden planks or a valuable ore), and whether a given container is appropriate to receive it (either because it has been designated as such by the player or because it already contains some amount of the same item).

In Minecraft, the majority of automation falls into this category, a task which is typically addressed through the usage of a great many hopper blocks, which both pick up items that land on top of themselves and transfer them to other containers or hoppers in a predictable and linear fashion. It is then up to the player to properly engineer only the intended items to arrive in the intended containers.

A behaviour tree approach is quite valuable in this context, as it enables a singular agent to take the place of possibly dozens or even hundreds of ticking tile entities with considerably less engineering needed on the part of the player. Instead, they only need to walk through the steps they themselves would take to perform the same task.

Automation seldom ends here, however. There may be occasions where specific player-taken actions are needed, often specifically relating to certain items held in hand. This might range from applying a food item to multiple livestock to initiate breeding, to mining resources (both in the wild and in controlled environments), to attacking hostile agents in the pursuit of certain rewards (aka "drops", after the tendency of such items to "drop" once the entity is slain).

These tasks may be simplistically reduced to repeating them endlessly (in the understanding that the desired context will just happen to occur whilst the loop continues) or performed more conservatively (such as waiting until a sheep's wool has regrown before trying to shear it). This presents a quandary in terms of efficiency: The eternal loop approach will inevitably require fewer behaviour tree nodes, whereas the efficient approach will inevitably require more, hence the efficient tree has higher computing costs. This poses a problem when attempting to maintain a low-impact system, which is difficult to overcome without providing very low-impact and often hyper-specific conditions.

However, despite this challenge, it can be foreseen that the end result remains less severe on a server's resources than the equivalent in a large mechanical system as well as providing opportunities for players to continue playing the game. This is to say that as many of these more complex automation tasks require the player to undertake them, either by writ of how interactions are performed or by their complexity, it becomes increasingly necessary for the player themselves to perform them. This can range from mindless repetition of the same action for hours on end or, even less palatably, from automating the player's control inputs directly (such as by an external auto-clicking application).

But in all this there is an overarching question: Is it fun?

By alleviating the need for large complex systems, reducing much of them down to only a handful at most of behaviour tree-driven programmed agents, are we eliminating part of what the player finds enjoyable in the first place?

Surely the end product is less time-consuming and less prone to error in the event of malfunction or mistake during construction, and for many players the engineering is indeed the entertaining activity. However, there is skill and puzzle to the design of an efficient behaviour tree as well, which can be construed as being different but similar to the original approach.

[madhenhouse]

Doug Teaches UE4 - Clone Cyberpunk Abilities - Proxy Based Pt 2

[ruimm]

Very basic editor tests for #BehaviourTrees in Unity.

Right now just visualising a pre-existing tree :)

[chainedchaos31]

I'm learning about Behaviour Trees in order to teach the students about them next week - this article has appeared just in time! 

[fermentedpolygon]

April meetup - Digit

When: 14th April  6.30pm

Where: Digit Gaming - 4 Prince's Street South map

At the last Fermented Poly Andrew O'Connor didn't talk about Behaviour Trees because there wasn't too many people (he likes an audience :) ) so he is going to be presenting about that.

Also, we'll try a cool new thing:  Code Crit: the idea is, you bring a bit of code (a file something readable in a few minutes) and we all try to comment on it as a group, if you don't bring code, you can't comment If you are coming please let us know (if you can't make it, also ) via the facebook event  or if you don't have facebook, please reply here in the comments section

Thanks to Digit Gaming for hosting us :D

[fermentedpolygon]

March meetup - 4th March @ Engine Yard

Hi there

Since GDC is looming we are having our meetup earlier than usual.

Jonathan Frawley will talk about TBC

Andrew O'Connor will talk about Behaviour trees. 

More details soon

Please let us know if you are coming over on the facebook event page