behaviortree

'behaviortree' implements a behavior tree library similar to BehaviorTree.CPP but in Rust.

Examples implementing the BehaviorTree.CPP tutorials can be found here. For embedded devices similar examples are available here

⚠️ INFO ⚠️ This crate is still in development.

Usage

Below is a very simple example using functions as Actions. For more examples see:

• Linux/Mac-OS/Windows,
• embedded

use behaviortree::prelude::*;

const XML: &str = r#"
<root BTCPP_format="4">
    <BehaviorTree ID="MyBehavior">
        <Sequence>
			<MyAction1/>
			<MyAction2/>
        </Sequence>
    </BehaviorTree>
</root>
"#;

fn action_1() -> BehaviorResult {
    // your activity
    // ...

    // In case of Failure    
    //return Ok(BehaviorState::Failure);

    // In case of Success    
    Ok(BehaviorState::Success)
}

fn action_2() -> BehaviorResult {
    // your activity
    // ...
    Ok(BehaviorState::Success)
}

#[tokio::main]
async fn main() {
    // create a behavior factory
    let mut factory = BehaviorTreeFactory::new().unwrap();

    // register your behaviors
    register_simple_behavior!(factory, action_1, "MyAction1", BehaviorKind::Action).unwrap();
    register_simple_behavior!(factory, action_2, "MyAction2", BehaviorKind::Action).unwrap();

    // create the tree
    let mut tree = factory.create_from_text(XML).unwrap();
    
    // run the tree until Success or Failure
    tree.tick_while_running().await.unwrap();
}

For implementation of your own complex behaviors, there is a set of derive macros: Action, Condition, Control and Decorator.

use behaviortree::prelude::*;

/// Derive an `Action`
#[derive(Action, Debug, Default)]
pub struct SaySomething {}

/// Implement the `Action`s functionality
#[async_trait::async_trait]
impl Behavior for SaySomething {
    /// Minimum implement the tick function
	async fn tick(
		&mut self,
		behavior: &mut BehaviorData,
		_children: &mut BehaviorTreeElementList,
		_runtime: &SharedRuntime,
	) -> BehaviorResult {
        // getting the port
		let msg = behavior.get::<String>("message")?;
        // doing something
		println!("Robot says: {msg}");
        // signaling success
		Ok(BehaviorState::Success)
	}

    /// Define the available ports.
    /// This is optional, the default implementation is for no ports.
	fn provided_ports() -> PortList {
		port_list! {input_port!(String, "message")}
	}
}

Capabilities

✅: Supported ☑️: Supported with some caveats 🚦: Needs testing but basically works 🔴: Not yet supported ??: Unclear if it can be supported ❌: Will not be supported

General capabilities

Built-in behaviors

License

Licensed with the fair use "NGMC" license, see license file

Contribution

Any contribution intentionally submitted for inclusion in the work by you, shall be licensed with the same "NGMC" license, without any additional terms or conditions.