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
#![deny(missing_docs)] #![deny(missing_copy_implementations)] //! AI behavior tree //! //! You can serialize the //! behavior tree using [Serde](https://crates.io/crates/serde) and //! e.g. [Ron](https://crates.io/crates/ron). //! //! ### What is an AI behavior tree? //! //! An AI behavior tree is a kind of state machine logic for processes. //! //! Many things that a game logic does, e.g. controlling AI characters, //! fits the pattern of AI behavior trees. //! //! An AI behavior tree is a very generic way of organizing interactive logic. //! It has built-in semantics for processes that signals `Running`, `Success` or //! `Failure`. //! //! 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])` //! - Try `A` first and then try `B` if `A` fails: `Select([A, B])` //! - Do `B` repeatedly while `A` runs: `While(A, [B])` //! - Do `A`, `B` forever: `While(WaitForever, [A, B])` //! - Wait for both `A` and `B` to complete: `WhenAll([A, B])` //! - Wait for either `A` or `B` to complete: `WhenAny([A, B])` //! //! See the `Behavior` enum for more information. //! //! ### Parallel semantics //! //! This library has parallel semantics for AI behavior trees. //! It means that multiple processes can happen at the same time //! and the logic can be constructed around how these processes runs or terminate. //! //! For example, `While(A, [B])` runs both `A` and `B` at the same time. //! If either `A` or `B` fails, then the whole while-behavior fails. //! //! A property of AI behavior trees with parallel semantics is that you can //! control termination conditions externally, as opposed to most //! programming languages where termination condition is controlled internally: //! //! ```text //! while A() { //! // This inner loop will never terminate unless `B` fails. //! while true { //! B(); // Runs `B` forever. //! } //! } //! ``` //! //! ```text //! // This will terminate if `A` stops running, which also stops `B`. //! WhenAny([A, //! While(WaitForever, [ //! B //! ]) //! ]) //! ``` extern crate input; #[macro_use] extern crate serde_derive; extern crate serde; pub use behavior::Behavior::{ self, Action, After, AlwaysSucceed, If, Fail, WaitForPressed, WaitForReleased, Select, Sequence, Wait, WaitForever, WhenAll, WhenAny, While, }; pub use state::{ ActionArgs, State, RUNNING }; pub use status::Status::{ self, Failure, Success, Running, }; mod behavior; mod state; mod status;