bhv 0.4.0

A crate providing means to create and use Behavior Trees
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
129
130
131
132
133
134
135
136

use crate::old_impl::core::{Bhv, Status};

/// A node that runs its child nodes in turn until one of them completes successfully (if any), or
/// all of the children complete otherwise. If all the children return [`Status::Failure`],
/// then this node also returns [`Status::Failure`], otherwise it returns [`Status::Success`] after
/// the first child node that succeeds. If there are no failures but there are still nodes that are
/// running, this returns [`Status::Running`]. This node is similar to [`Sel`], with the difference
/// being that this node runs its children even after one of them returns [`Status::Running`],
/// instead of waiting for the next call of [`Bhv::update`].
pub struct WhenAny<C>(pub(crate) Box<[Box<dyn Bhv<Context=C>>]>);

/// A node that runs its child nodes in turn until all of them complete. If all the children return
/// [`Status::Success`], then this node also returns [`Status::Success`], otherwise it returns
/// [`Status::Failure`] after the first child node that fails. If there are no failures but there
/// is at least one node that returns [`Status::Running`], all the nodes are run and
/// [`Status::Running`] is returned. This node is similar to [`Seq`], with the difference
/// being that this node runs its children even after one of them returns [`Status::Running`],
/// instead of waiting for the next call of [`Bhv::update`].
pub struct WhenAll<C>(pub(crate) Box<[Box<dyn Bhv<Context=C>>]>);

impl<C> WhenAny<C> {
    #[inline]
    pub fn new(bhvs: Box<[Box<dyn Bhv<Context=C>>]>) -> Self {
        Self(bhvs)
    }
}

impl<C> WhenAll<C> {
    #[inline]
    pub fn new(bhvs: Box<[Box<dyn Bhv<Context=C>>]>) -> Self {
        Self(bhvs)
    }
}

impl<C> Bhv for WhenAny<C> {
    type Context = C;
    fn update(&mut self, ctx: &mut Self::Context) -> Status {
        let mut any_running = false;

        for node in self.0.iter_mut() {
            match node.update(ctx) {
                Status::Running => any_running = true,
                Status::Failure => continue,
                Status::Success => return Status::Success,
            }
        }

        if any_running {
            Status::Running
        } else {
            Status::Failure
        }
    }
}

impl<C> Bhv for WhenAll<C> {
    type Context = C;
    fn update(&mut self, ctx: &mut Self::Context) -> Status {
        let mut any_running = false;

        for node in self.0.iter_mut() {
            match node.update(ctx) {
                Status::Running => any_running = true,
                Status::Success => continue,
                Status::Failure => return Status::Failure,
            }
        }

        if any_running {
            Status::Running
        } else {
            Status::Success
        }
    }
}

/// A macro used to create an [`WhenAny`] from a list of behaviors.
///
/// # Example
///
/// ```
/// use bhv::*;
///
/// let tree = when_any! {
///     async_action(|v| Status::Running), // show still goes on
///     action(|v| *v = 20),
///     cond(|v| false), // but not from here
/// };
///
/// let mut ctx = 10;
/// tree.execute(&mut ctx);
///
/// assert_eq!(ctx, 20);
/// ```
#[macro_export]
macro_rules! when_any {
    () => {
        compile_error!("`when_any` should have at least one argument!")
    };
    ($($x:expr),+$(,)?) => {
        $crate::WhenAny::new(
            Box::new([$(Box::new($x)),+]),
        )
    };
}

/// A macro used to create an [`WhenAll`] from a list of behaviors.
///
/// # Example
///
/// ```
/// use bhv::*;
///
/// let tree = when_all! {
///     async_action(|v| Status::Running), // show still goes on
///     action(|v| *v = 20),
///     cond(|v| false), // but not from here
///     action(|v| *v = 40),
/// };
///
/// let mut ctx = 10;
/// tree.execute(&mut ctx);
///
/// assert_eq!(ctx, 20); // value is still modified on the first time
/// ```
#[macro_export]
macro_rules! when_all {
    () => {
        compile_error!("`when_any` should have at least one argument!")
    };
    ($($x:expr),+$(,)?) => {
        $crate::WhenAll::new(
            Box::new([$(Box::new($x)),+]),
        )
    };
}