mecha10-behavior-runtime 0.1.25

Behavior tree runtime for Mecha10 - unified AI and logic composition system
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

// Tests for mecha10_behavior_runtime::config

use mecha10_behavior_runtime::{BehaviorConfig, CompositionConfig, ParallelPolicyConfig};
use std::collections::HashMap;

#[test]
fn test_parse_simple_sequence() {
    let json = r#"{
        "name": "test",
        "root": {
            "type": "sequence",
            "children": []
        }
    }"#;

    let config = BehaviorConfig::from_json(json).unwrap();
    assert_eq!(config.name, "test");

    match config.root {
        CompositionConfig::Sequence { children, .. } => {
            assert_eq!(children.len(), 0);
        }
        _ => panic!("Expected sequence"),
    }
}

#[test]
fn test_parse_node_with_config_ref() {
    let json = r#"{
        "name": "test",
        "root": {
            "type": "node",
            "node": "my_behavior",
            "config_ref": "my_config"
        },
        "configs": {
            "my_config": {
                "speed": 1.5
            }
        }
    }"#;

    let config = BehaviorConfig::from_json(json).unwrap();

    match &config.root {
        CompositionConfig::Node { node, config_ref, .. } => {
            assert_eq!(node, "my_behavior");
            assert_eq!(config_ref, &Some("my_config".to_string()));
        }
        _ => panic!("Expected node"),
    }

    let node_config = config.get_config("my_config").unwrap();
    assert_eq!(node_config["speed"], 1.5);
}

#[test]
fn test_parse_parallel_with_policy() {
    let json = r#"{
        "name": "test",
        "root": {
            "type": "parallel",
            "policy": "require_one",
            "children": []
        }
    }"#;

    let config = BehaviorConfig::from_json(json).unwrap();

    match config.root {
        CompositionConfig::Parallel { policy, .. } => {
            assert!(matches!(policy, ParallelPolicyConfig::RequireOne));
        }
        _ => panic!("Expected parallel"),
    }
}

#[test]
fn test_generate_schema() {
    let schema = BehaviorConfig::generate_schema().unwrap();
    assert!(schema.contains("BehaviorConfig"));
    assert!(schema.contains("CompositionConfig"));
}

#[test]
fn test_roundtrip() {
    let config = BehaviorConfig {
        schema: None,
        name: "test".to_string(),
        description: Some("Test behavior".to_string()),
        root: CompositionConfig::Sequence {
            children: vec![],
            name: None,
        },
        configs: HashMap::new(),
    };

    let json = config.to_json().unwrap();
    let parsed = BehaviorConfig::from_json(&json).unwrap();
    assert_eq!(parsed.name, config.name);
    assert_eq!(parsed.description, config.description);
}