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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166

use std::marker::PhantomData;

use crate::events_impl::{
    core::{Bhv, Status},
    events::{Event, EventKind, EventType},
};

/// A decorator that runs the given node until it's done and inverts
/// the result.
///
/// More specifically, it converts [`Status::Success`] to [`Status::Failure`]
/// and [`Status::Failure`] to [`Status::Success`].
#[derive(Debug, Clone)]
pub struct Inv<B>(pub(crate) B)
    where B: Bhv;

/// A decorator that runs the given node until it's done and then returns [`Status::Success`].
#[derive(Debug, Clone)]
pub struct Pass<B>(pub(crate) B)
    where B: Bhv;

/// A decorator that runs the given node until it's done and then returns [`Status::Failure`].
#[derive(Debug, Clone)]
pub struct Fail<B>(pub(crate) B)
    where B: Bhv;

/// A decorator that runs the given node a certain number of times and returns its status.
#[derive(Clone)]
pub struct Repeat<B: Bhv> {
    pub(crate) bhv: B,
    pub(crate) count: u32,
    pub(crate) current: u32,
}

/// A decorator that runs the given node until it returns [`Status::Success`].
///
/// It returns [`Status::Running`] until the node returns [`Status::Success`], in which case it is propagated.
#[derive(Clone)]
pub struct RepeatUntilPass<B: Bhv>(pub(crate) B);

/// A decorator that runs the given node until it returns [`Status::Failure`].
///
/// It returns [`Status::Running`] until the node returns [`Status::Failure`], in which case it is propagated.
#[derive(Clone)]
pub struct RepeatUntilFail<B: Bhv>(pub(crate) B);

/// A decorator that runs a node only when a certain event type is triggered.
#[derive(Clone)]
pub struct WaitFor<B: Bhv, E: EventType> {
    pub(crate) bhv: B,
    pub(crate) kind: EventKind,
    pub(crate) _tag: PhantomData<E>,
}

impl<B: Bhv> Bhv for Inv<B> {
    type Context = B::Context;
    #[inline]
    fn should_react_to(&self, kind: EventKind) -> bool {
        self.0.should_react_to(kind)
    }
    #[inline]
    fn react(&mut self, event: &dyn Event, ctx: &mut Self::Context) -> Status {
        match self.0.react(event, ctx) {
            Status::Running => Status::Running,
            Status::Success => Status::Failure,
            Status::Failure => Status::Success,
        }
    }
}

impl<B: Bhv> Bhv for Pass<B> {
    type Context = B::Context;
    #[inline]
    fn should_react_to(&self, kind: EventKind) -> bool {
        self.0.should_react_to(kind)
    }
    #[inline]
    fn react(&mut self, event: &dyn Event, ctx: &mut Self::Context) -> Status {
        match self.0.react(event, ctx) {
            Status::Running => Status::Running,
            _ => Status::Success,
        }
    }
}

impl<B: Bhv> Bhv for Fail<B> {
    type Context = B::Context;
    #[inline]
    fn should_react_to(&self, kind: EventKind) -> bool {
        self.0.should_react_to(kind)
    }
    #[inline]
    fn react(&mut self, event: &dyn Event, ctx: &mut Self::Context) -> Status {
        match self.0.react(event, ctx) {
            Status::Running => Status::Running,
            _ => Status::Failure,
        }
    }
}

impl<B: Bhv> Bhv for Repeat<B> {
    type Context = B::Context;
    #[inline]
    fn should_react_to(&self, kind: EventKind) -> bool {
        self.current < self.count && self.bhv.should_react_to(kind)
    }
    #[inline]
    fn react(&mut self, event: &dyn Event, ctx: &mut Self::Context) -> Status {
        match self.bhv.react(event, ctx) {
            Status::Running => Status::Running,
            _ => {
                self.current += 1;
                Status::Running
            }
        }
    }
}

impl<B: Bhv> Bhv for RepeatUntilPass<B> {
    type Context = B::Context;
    #[inline]
    fn should_react_to(&self, kind: EventKind) -> bool {
        self.0.should_react_to(kind)
    }
    #[inline]
    fn react(&mut self, event: &dyn Event, ctx: &mut Self::Context) -> Status {
        match self.0.react(event, ctx) {
            Status::Success => Status::Success,
            _ => Status::Running,
        }
    }
}

impl<B: Bhv> Bhv for RepeatUntilFail<B> {
    type Context = B::Context;
    #[inline]
    fn should_react_to(&self, kind: EventKind) -> bool {
        self.0.should_react_to(kind)
    }
    #[inline]
    fn react(&mut self, event: &dyn Event, ctx: &mut Self::Context) -> Status {
        match self.0.react(event, ctx) {
            Status::Failure => Status::Failure,
            _ => Status::Running,
        }
    }
}

impl<B: Bhv, E: EventType> Bhv for WaitFor<B, E> {
    type Context = B::Context;
    #[inline]
    fn should_react_to(&self, kind: EventKind) -> bool {
        self.kind == kind
    }
    #[inline]
    fn react(&mut self, event: &dyn Event, ctx: &mut Self::Context) -> Status {
        self.bhv.react(event, ctx)
    }
}

impl<B: Bhv> Repeat<B> {
    #[inline]
    pub fn reset(&mut self) {
        self.current = 0;
    }
}