behavior-tree 0.1.0

Yet another behavior tree library for rust!
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
109
110
111
112
113

use std::{cell::RefCell, rc::Rc};

use behavior_tree::*;

#[test]
fn test_simple_select() {
    let mut bt: Node<()> = Node::select(vec![
        Node::action("fail", |_| Status::Failure),
        Node::action("fail", |_| Status::Failure),
        YesTick::action(),
        NoTick::action(),
        NoTick::action(),
    ]);

    let res = bt.tick(1.0, &mut ());
    assert_eq!(res, Status::Success);

    assert_eq!(bt.status, Status::Success);
    if let Behavior::Select(_, ref nodes) = bt.behavior {
        assert_eq!(nodes[0].borrow().status, Status::Failure);
        assert_eq!(nodes[1].borrow().status, Status::Failure);
        assert_eq!(nodes[2].borrow().status, Status::Success);
        assert_eq!(nodes[3].borrow().status, Status::Initialized);
        assert_eq!(nodes[4].borrow().status, Status::Initialized);
    } else {
        panic!("Expected sequence")
    }

    bt.reset();
    assert_eq!(bt.status, Status::Initialized);

    if let Behavior::Select(_, ref nodes) = bt.behavior {
        for node in nodes.iter() {
            assert_eq!(node.borrow().status, Status::Initialized);
        }
    } else {
        panic!("Expected sequence")
    }
}

#[test]
fn test_simple_select_inv() {
    let mut bt: Node<()> = Node::select(vec![
        Node::action("success", |_| Status::Success),
        NoTick::action(),
        NoTick::action(),
        NoTick::action(),
        NoTick::action(),
    ]);

    let res = bt.tick(1.0, &mut ());
    assert_eq!(res, Status::Success);
}

#[test]
fn test_simple_select_running() {
    let mut bt: Node<()> = Node::select(vec![
        Node::action("fail", |_| Status::Failure),
        Node::action("fail", |_| Status::Failure),
        Node::action("fail", |_| Status::Failure),
        AlwaysRunning::action(),
        NoTick::action(),
        NoTick::action(),
        NoTick::action(),
        NoTick::action(),
    ]);

    let res = bt.tick(1.0, &mut ());
    assert_eq!(res, Status::Running);
}

#[test]
fn test_simple_select_fail() {
    let mut bt: Node<()> = Node::select(vec![
        Node::action("fail", |_| Status::Failure),
        Node::action("fail", |_| Status::Failure),
        Node::action("fail", |_| Status::Failure),
        Node::action("fail", |_| Status::Failure),
        Node::action("fail", |_| Status::Failure),
    ]);

    let res = bt.tick(1.0, &mut ());
    assert_eq!(res, Status::Failure);
}

#[test]
fn test_condition_recheck() {
    let const_status = Rc::new(RefCell::new(Status::Failure));

    let mut bt: Node<()> = Node::select(vec![
        Node::stateful_action(
            "const",
            Box::new(ConstAction {
                return_status: const_status.clone(),
            }),
        ),
        Node::stateful_action("counter", Box::new(Counter::default())),
        AlwaysRunning::action(),
    ]);

    let status = bt.tick(1.0, &mut ());
    assert_eq!(status, Status::Success);

    *const_status.borrow_mut() = Status::Success;

    let status = bt.tick(1.0, &mut ());
    assert_eq!(status, Status::Success);

    *const_status.borrow_mut() = Status::Running;

    let status = bt.tick(1.0, &mut ());
    assert_eq!(status, Status::Running);
}