cornerstone 0.1.2

A behavior tree library
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

use std::collections::HashMap;

use cornerstone::{
    node::{
        control::{ControlNode, SequenceNode},
        decorator::RepeatNode,
    },
    Context, DataProxy, NodeStatus, TreeNode,
};

#[derive(Clone, Debug)]
struct Arm {
    name: String,
}

#[derive(Debug)]
struct PrintArmNode {
    data_proxy: DataProxy,
}

impl TreeNode for PrintArmNode {
    fn tick(&mut self, ctx: &mut Context) -> NodeStatus {
        if let Some(arm) = self.data_proxy.get::<Arm>(ctx, "arm") {
            println!("get arm: {arm:?}");
        };

        NodeStatus::Success
    }
}

#[derive(Debug)]
struct Body {
    left_arm: Arm,
    right_arm: Arm,
}

#[derive(Debug)]
struct PrintBodyNode {
    data_proxy: DataProxy,
}

impl TreeNode for PrintBodyNode {
    fn tick(&mut self, ctx: &mut Context) -> NodeStatus {
        if let Some(body) = self.data_proxy.get::<Body>(ctx, "body") {
            println!("PrintBodyNode: {body:?}");

            let left_arm = body.left_arm.clone();
            let right_arm = body.right_arm.clone();

            ctx.set("left_arm".to_string(), left_arm);
            ctx.set("right_arm".to_string(), right_arm);

            NodeStatus::Success
        } else {
            NodeStatus::Failure
        }
    }
}

fn main() {
    let mut ctx = Context::default();
    ctx.set(
        "body".to_string(),
        Body {
            left_arm: Arm {
                name: "left_arm".to_string(),
            },
            right_arm: Arm {
                name: "right_arm".to_string(),
            },
        },
    );

    let mut seq_root = SequenceNode::default();

    let body = PrintBodyNode {
        data_proxy: DataProxy::new(HashMap::new()),
    };
    seq_root.add_child(Box::new(body));

    let mut arms_root = SequenceNode::default();

    let mut left_ports = HashMap::new();
    left_ports.insert("arm".to_string(), "left_arm".to_string());
    let left_arm = PrintArmNode {
        data_proxy: DataProxy::new(left_ports),
    };

    let mut right_ports = HashMap::new();
    right_ports.insert("arm".to_string(), "right_arm".to_string());
    let right_arm = PrintArmNode {
        data_proxy: DataProxy::new(right_ports),
    };

    arms_root.add_child(Box::new(left_arm));
    arms_root.add_child(Box::new(right_arm));

    seq_root.add_child(Box::new(arms_root));

    let mut root = RepeatNode::new(5, Box::new(seq_root));

    loop {
        let status = root.tick(&mut ctx);

        if status == NodeStatus::Success {
            println!("tree finish");
            break;
        }
    }
}