beetry-node 0.2.0

Beetry library with reusable behavior tree nodes.
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use beetry_core::{Node, NonEmptyNodes, TickStatus};

use crate::{Indices, control::RunningNodesAborter};

/// Control node that tries children in order until one succeeds.
///
/// `Fallback` ticks children in order on each tick:
///
/// - returns [`TickStatus::Success`] as soon as a child succeeds
/// - returns [`TickStatus::Running`] as soon as a child is still running
/// - returns [`TickStatus::Failure`] only if every child fails on the same tick
///
/// This variant does not remember which child was previously running, so the
/// next tick starts again from the first child.
pub struct Fallback {
    nodes: NonEmptyNodes,
    aborter: RunningNodesAborter,
}

impl Fallback {
    #[must_use]
    pub fn new(nodes: NonEmptyNodes) -> Self {
        Self {
            nodes,
            aborter: RunningNodesAborter::new(),
        }
    }
}

impl Node for Fallback {
    fn tick(&mut self) -> TickStatus {
        let aborter = &mut self.aborter;
        for idx in self.nodes.indices() {
            let node = &mut self.nodes[idx];
            match node.tick() {
                TickStatus::Failure => {
                    aborter.untrack(idx);
                }
                TickStatus::Running => {
                    aborter.abort_if_other_running(&mut self.nodes, idx);
                    aborter.track(idx);
                    return TickStatus::Running;
                }
                TickStatus::Success => {
                    aborter.abort_if_other_running(&mut self.nodes, idx);
                    return TickStatus::Success;
                }
            }
        }
        TickStatus::Failure
    }

    fn abort(&mut self) {
        self.aborter.clear();
        for node in &mut self.nodes {
            node.abort();
        }
    }

    fn reset(&mut self) {
        self.aborter.clear();
        for node in &mut self.nodes {
            node.reset();
        }
    }
}

#[cfg(test)]
mod tests {
    use beetry_core::{Node, TickStatus};

    use super::*;
    use crate::mock_test::{boxed, mock_returns};

    #[test]
    fn success_with_first_success() {
        let nodes = NonEmptyNodes::from([
            boxed(mock_returns([TickStatus::Failure])),
            boxed(mock_returns([TickStatus::Success])),
            boxed(mock_returns([])),
        ]);
        let mut fb = Fallback::new(nodes);

        assert_eq!(fb.tick(), TickStatus::Success);
    }

    #[test]
    fn running_with_first_running() {
        let nodes = NonEmptyNodes::from([
            boxed(mock_returns([TickStatus::Failure])),
            boxed(mock_returns([TickStatus::Running])),
            boxed(mock_returns([])),
        ]);
        let mut fb = Fallback::new(nodes);
        assert_eq!(fb.tick(), TickStatus::Running);
    }

    #[test]
    fn failure_with_all_failed() {
        let nodes = NonEmptyNodes::from([
            boxed(mock_returns([TickStatus::Failure])),
            boxed(mock_returns([TickStatus::Failure])),
        ]);
        let mut fb = Fallback::new(nodes);

        assert_eq!(fb.tick(), TickStatus::Failure);
    }

    #[test]
    fn resets_running() {
        let m1 = mock_returns([
            TickStatus::Failure,
            TickStatus::Failure,
            TickStatus::Running,
        ]);
        let mut m2 = mock_returns([TickStatus::Failure, TickStatus::Running]);
        let mut m3 = mock_returns([TickStatus::Running]);
        m2.expect_abort().once().return_const(());
        m3.expect_abort().once().return_const(());

        let nodes = NonEmptyNodes::from([boxed(m1), boxed(m2), boxed(m3)]);
        let mut fb = Fallback::new(nodes);

        assert_eq!(fb.tick(), TickStatus::Running);
        assert_eq!(fb.tick(), TickStatus::Running);
        assert_eq!(fb.tick(), TickStatus::Running);
    }
}