bevior_tree 0.11.0

Behavior tree plugin for Bevy.
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

//! Composite nodes that run children parallelly.

use bevy::ecs::{entity::Entity, world::World};

use crate::node::prelude::*;
use crate::sequential::ResultStrategy;

pub mod variants;

pub mod prelude {
    pub use super::{Parallel, variants::prelude::*};
}

/// Composite node that run children parallelly.
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug)]
#[with_state(ParallelState)]
pub struct Parallel {
    children: Vec<Box<dyn Node>>,
    result_strategy: Box<dyn ResultStrategy>,
}
impl Parallel {
    /// Creates new [`Parallel`] node.
    ///
    /// # Arguments
    /// * children - Children nodes that this node runs.
    /// * result_strategy - Strategy to determine the result of this node based on results of children.
    pub fn new(children: Vec<Box<dyn Node>>, result_strategy: impl ResultStrategy) -> Self {
        Self {
            children,
            result_strategy: Box::new(result_strategy),
        }
    }
}
#[cfg_attr(feature = "serde", typetag::serde)]
impl Node for Parallel {
    fn begin(&self, world: &mut World, entity: Entity) -> NodeStatus {
        let state = ParallelState {
            children_status: self
                .children
                .iter()
                .map(|_| NodeStatus::Beginning)
                .collect(),
        };
        self.resume(world, entity, Box::new(state))
    }

    fn resume(&self, world: &mut World, entity: Entity, state: Box<dyn NodeState>) -> NodeStatus {
        let state = Self::downcast(state).expect("Invalid state.");
        if let Some(result) = self.result_strategy.construct(state.results()) {
            self.force_exit(world, entity, Box::new(state));
            return NodeStatus::Complete(result);
        }
        let children_status = self
            .children
            .iter()
            .zip(state.children_status.into_iter())
            .map(|(child, child_status)| match child_status {
                NodeStatus::Beginning => child.begin(world, entity),
                NodeStatus::Pending(child_state) => child.resume(world, entity, child_state),
                NodeStatus::Complete(_) => child_status,
            })
            .collect();
        let state = ParallelState { children_status };
        if let Some(result) = self.result_strategy.construct(state.results()) {
            self.force_exit(world, entity, Box::new(state));
            NodeStatus::Complete(result)
        } else {
            NodeStatus::Pending(Box::new(state))
        }
    }

    fn force_exit(&self, world: &mut World, entity: Entity, state: Box<dyn NodeState>) {
        let state = Self::downcast(state).expect("Invalid state.");
        self.children
            .iter()
            .zip(state.children_status.into_iter())
            .for_each(|(child, child_status)| match child_status {
                NodeStatus::Pending(child_state) => child.force_exit(world, entity, child_state),
                _ => {}
            });
    }
}

/// State for [`Parallel`]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(NodeState, Debug)]
struct ParallelState {
    children_status: Vec<NodeStatus>,
}
impl ParallelState {
    fn results(&self) -> Vec<Option<NodeResult>> {
        self.children_status
            .iter()
            .map(|status| match status {
                &NodeStatus::Complete(result) => Some(result),
                _ => None,
            })
            .collect()
    }
}