beehave 0.0.4

A simple library for defining and evaluating a hierarchical state machine (behaviour tree).
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

# Beehave [![Build Status](https://travis-ci.org/Archytaus/beehave.svg)](https://travis-ci.org/Archytaus/beehave)

A simple library for defining and evaluating a hierarchical state machine (behaviour tree).

[Documentation](https://docs.rs/beehave/)

## Compatibility

Because this library uses `fn_traits` and `unboxed_closures` it will only compile using rust nightly.
See rust-lang/rust#29625 for the related issue around stabilization.

This was last tested against `rustc 1.13.0-nightly (a23064af5 2016-08-27)`

## Example

Building a behaviour tree using the supplied macros:
```rust
let world_behaviour: Selector<World> = behaviour_selector!("World Root", [
    condition!("Ensure Can Shine",
        |world: &mut World| {
            world.can_shine()
        },
        action!("Cycle Day/Night", |world: &mut World| {
            world.toggle_sun()
        })
    ),
    condition!("Ensure Can Rain",
        |world: &mut World| {
            world.can_rain()
        },
        action!("Rain", |world: &mut World| {
            world.rain()
        })
    )
]);

let tree_behaviour: Selector<Tree> = behaviour_selector!("Tree Root", [
    behaviour_sequence!("Photosynthesise", [
        condition!("Ensure Can Make Energy",
            |tree: &mut Tree| {
                tree.can_make_energy()
            },
            action!("Make Energy", |tree: &mut Tree| {
                tree.make_energy()
            })
        ),
        condition!("Ensure Can Grow",
            |tree: &mut Tree| {
                tree.can_grow()
            },
            action!("Grow", |tree: &mut Tree| {
                tree.grow()
            })
        ),
        condition!("Ensure Can Emit Oxygen",
            |tree: &mut Tree| {
                tree.can_emit_oxygen()
            },
            action!("Emit Oxygen", |tree: &mut Tree| {
                tree.emit_oxygen()
            })
        )
    ]),
    condition!("Ensure Can Gather Sun",
        |tree: &mut Tree| {
            tree.can_gather_sun()
        },
        action!("Emit Oxygen", |tree: &mut Tree| {
            tree.gather_sun()
        })
    ),
    condition!("Ensure Can Gather Water",
        |tree: &mut Tree| {
            tree.can_gather_water()
        },
        action!("Emit Oxygen", |tree: &mut Tree| {
            tree.gather_water()
        })
    )
]);
```

Evaluating the behaviour tree against an actor:
```rust
tree_behaviour.evaluate(&mut tree);
world_behaviour.evaluate(&mut world);
```

For more information please see the [full example](./examples).

You can run the example using:

```sh
cargo run --example main
```

## Design Goals

- Easily generate an immutable behaviour tree
- Evaluate the behaviour tree on a mutable actor

## See also

[PistonDevelopers/ai_behavior](https://github.com/PistonDevelopers/ai_behavior)

## License

Beehave was created by [Ryan Scott](http://github.com/archytaus) is distributed under the [MIT](http://ryanscott.mit-license.org) license.