Java Behaviour Trees

Java Behaviour Trees, User Guide

Ricardo Juan Palma Dur´an

August 23, 2010

Contents

1 Introduction 2

2 JBT, an Overview 3

2.1 Model Driven by Ticks . . . . . . . . . . . . . . . . . . . . . . . . 3

2.2 Model Independent from Execution . . . . . . . . . . . . . . . . . 3

2.3 Architecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

6 Step 4: Creating a Java Declaration of the BTs 26

7 Step 5: Running the Behaviour Trees 29

1

1 Introduction

Java Behaviour Trees (JBT) is a Java framework for building and running be-

haviour trees (BTs). In the past few years, BTs have been widely accepted as

a tool for defining the behaviour of video games characters. However, to the

best of our knowledge, there is no free-software Java implementation of such

technology. With JBT we intend to provide a solid framework to build and run

BTs in Java.

a BT from its description in an XML format. By doing so, the user of this

framework basically has to worry only about defining BTs in XML files and

implementing the low level actions and conditions that his trees will use, which

are domain-dependant (that is, they depend on the game being played). We

provide a .jar file with all the JBT Core classes. Of course, in order to get the

last version of the JBT Core the repository can be accessed.

On the other hand, there is the JBT Editor (which is composed of two Eclipse

SDK projects under the ”./JBTEditor” directory of the repository). The JBT

Editor is a GUI application that can be used for defining BTs, and then export-

ing them into XML files in the format that the JBT Core understands. The

application, so you must use Eclipse SDK in order to run it. An alternative to

run it is to use the executable files provided for each platform. Of course, if

order to get the last version of the JBT Editor the repository can be accessed.

JBT implements a BT model which is mainly based on that of the book

”Artificial Intelligence for Games”, second edition, by Ian Millington and John

Funge. JBT also includes the concept of ”guard” and static and dynamic prior-

ity lists, which make use of guards. JBT BTs are driven by ticks, which means

that, in order for them to have CPU time, they need to be externally ticked.

By following this pattern, the user can control how much CPU time the BT

consumes.

Note that, when talking about BTs, node and task are used interchangeably.

2

• Creating BTs with the JBT Editor. Here, the user creates BTs that are

• Creating the Java declaration of the BTs that were declared in the XML

• Running the BTs by using the core classes of JBT.

In the next sections we will describe all of these steps. Also, we will con-

ceptualize them through a real example on a real game, since we will build a

JBT implements a BT model driven by ticks. A BT must be evaluated through

ticks, so every game cycle an external caller ticks the tree in order for the tree

to update its status. A tick is just a way of giving the tree some CPU time

to update their status; in particular, ticks are used to give the nodes of the

tree some time to evaluate whether they have finished or not, and consequently

make the tree evolve.

The simplest approach to BTs driven by ticks is that of ticking the root node

and then letting each node recursively tick its children according to its semantics.

However, this is a very inefficient process, since in general the major part of the

nodes of the tree are just waiting for their children to finish. Therefore, they

is being run (the model) and how it is actually being run (the execution). For

each particular behaviour, we distinguish between the Model BT that defines it

and how it is being run. The how is what the BT Executor does. Basically, for

every entity in the game that wants to run a behaviour (Model BT), there is a

BT Executor. The BT Executor takes the Model BT and processes it (without

modifying it), simulating the behaviour that is represented by the Model BT.

This choice implies that, apart from the Model BT, there is another type of

tree, the Execution BT. When an entity wants to execute a behaviour, the BT

Executor takes the Model BT and creates an Execution BT to execute the

behaviour. The BT Executor along with the Execution BT know how to run

3

Figure 1: Overview of the BT architecture

Figure 1 shows an overview of the JBT Core architecture. There is a Model

BT that represents a particular behaviour. Also, there is a BT Executor for

every entity that wants to run the Model BT. Each BT Executor makes use of

Before even starting to explain all the steps required to build and run BTs with

JBT, we have to first think about what BT model JBT offers. JBT implements

a BT model that is mainly based on that of [2]. Our model also include guards

and static and dynamic priority lists, as described in [1]. With this model the

user can implement a wide range of behaviours.

For instance, the tree of figure 2 represents a simple tree that is used by a

game character that wants to open a door. First of all, it checks if the door is

closed (condition DoorClosed). If so, then it tries to open it by executing the

action OpenDoor.

4

is, they have been defined by the user so they have a useful meaning within the

context of the game being played.

The tree of figure 3 represents the behaviour of a character that is trying

to enter a room. The topmost selector succeeds as long as one of its children

succeed. The first child tries to enter the room when the door is locked. In such

case, the character tries several tactics to open the door. First, if it has the key,

it uses it to open the door. If it does not have the key, but it has a grenade, then

it uses the grenade in order to blow the door up. Finally, if none of the above

conditions are met, the character will try to enter the room through its window

(note that here a Subtree Lookup node is used. This node just runs a tree that is

5