Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

https://github.com/Sollimann/bonsai

Rust implementation of AI behavior trees.
https://github.com/Sollimann/bonsai

ai autonomous-robots behavior-tree bevy concurrency finite-state-machine fsm game game-development navigation piston robotics ros ros2 rust unreal-engine

Last synced: 2 months ago
JSON representation

Rust implementation of AI behavior trees.

Host: GitHub
URL: https://github.com/Sollimann/bonsai
Owner: Sollimann
License: mit
Created: 2022-05-23T20:15:23.000Z (about 2 years ago)
Default Branch: main
Last Pushed: 2024-03-19T01:38:18.000Z (3 months ago)
Last Synced: 2024-03-19T02:48:44.537Z (3 months ago)
Topics: ai, autonomous-robots, behavior-tree, bevy, concurrency, finite-state-machine, fsm, game, game-development, navigation, piston, robotics, ros, ros2, rust, unreal-engine
Language: Rust
Homepage:
Size: 2.5 MB
Stars: 248
Watchers: 6
Forks: 11
Open Issues: 2
Metadata Files:
- Readme: README.md
- License: LICENSE

Lists

awesome-bevy - Bonsai

README

        
 Bonsai 盆栽 



  





    Rust implementation of Behavior Trees



[![Build Status](https://github.com/Sollimann/bonsai/actions/workflows/rust-ci.yml/badge.svg)](https://github.com/Sollimann/bonsai/actions)

[![Bonsai crate](https://img.shields.io/crates/v/bonsai-bt.svg)](https://crates.io/crates/bonsai-bt)

[![minimum rustc 1.56](https://img.shields.io/badge/rustc-1.56+-blue.svg)](https://rust-lang.github.io/rfcs/2495-min-rust-version.html)

[![Docs](https://docs.rs/bonsai-bt/badge.svg)](https://docs.rs/bonsai-bt)

[![codecov](https://codecov.io/gh/Sollimann/bonsai/branch/main/graph/badge.svg?token=JX8JBPWORV)](https://codecov.io/gh/Sollimann/bonsai)

[![Maintenance](https://img.shields.io/badge/Maintained%3F-yes-green.svg)](https://GitHub.com/Sollimann/bonsai/graphs/commit-activity)

[![GitHub pull-requests](https://img.shields.io/github/issues-pr/Sollimann/bonsai.svg)](https://GitHub.com/Sollimann/bonsai/pulls)

[![GitHub pull-requests closed](https://img.shields.io/github/issues-pr-closed/Sollimann/bonsai.svg)](https://GitHub.com/Sollimann/bonsai/pulls)

![ViewCount](https://views.whatilearened.today/views/github/Sollimann/bonsai.svg)

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

## Contents

* [Quick intro to Behavior Trees](https://www.youtube.com/watch?v=KeShMInMjro)

* [Concepts](docs/concepts/README.md)

* [Examples](examples/README.md)

* [Development Guide](DEVELOPMENT.md)

* [Kanban Board](https://github.com/Sollimann/b3/projects/1)

* [Honorable Mentions](#similar-crates)

## Using Bonsai

Bonsai is available on crates.io. The recommended way to use it is to add a line into your Cargo.toml such as:

```toml

[dependencies]

bonsai-bt = "*"

```

## What is a Behavior Tree?

A _Behavior Tree_ (BT) is a data structure in which we can set the rules of how certain _behavior's_ can occur, and the order in which they would execute. BTs are a very efficient way of creating complex systems that are both modular and reactive. These properties are crucial in many applications, which has led to the spread of BT from computer game programming to many branches of AI and Robotics.

### How to use a Behavior tree?

A Behavior Tree forms a tree structure where each node represents a process. When the process terminates, it signals `Success` or `Failure`. This can then be used by the parent node to select the next process. A signal `Running` is used to tell the process is not done yet.

For example, if you have a state `A` and a state `B`:

- Move from state `A` to state `B` if `A` succeeds: `Sequence([A, B])`

- Move from state `A` to sequence of states `[B]` if `A` is running. If all states in the sequence `[B]` succeed in order, check if `A` is still running and repeat. Stop if `A` succeeds or any of the states fail: `RepeatSequence(A, [B])`

- Try `A` first and then try `B` if `A` fails: `Select([A, B])`

- If `condition` succeedes do `A`, else do `B` : `If(condition, A, B)`

- If `A` succeeds, return failure (and vice-versa): `Invert(A)`

- Do `B` repeatedly while `A` runs: `While(A, [B])`

- Do `A`, `B` forever: `While(WaitForever, [A, B])`

- Run `A` and `B` in parallell and wait for both to succeed: `WhenAll([A, B])`

- Run `A` and `B` in parallell and wait for any to succeed: `WhenAny([A, B])`

- Run `A` and `B` in parallell, but `A` has to succeed before `B`: `After([A, B])`

See the `Behavior` enum for more information.

### Calling long-running tasks in behavior tree

To make sure that the behavior tree is always responsive, it is important that the actions that are created executes instantly so that they do not block the tree traversal. If you have long-running tasks/functions that can take seconds or minutes to execute - either `async` or `sync` - then we can dispatch those jobs into background threads, and get status of the task through a channel.

see *async drone* example in the `/examples` folder for more details.

## Example of use

See [Examples](examples/README.md) folder.

## Similar Crates

Bonsai is inspired by many other crates out there, here's a few worth mentioning:

* [ai_behavior](https://github.com/PistonDevelopers/ai_behavior) (bonsai is a continuation of this crate)

* [aspen](https://gitlab.com/neachdainn/aspen)

* [behavior-tree](https://github.com/darthdeus/behavior-tree)

* [stackbt](https://github.com/eaglgenes101/stackbt)