feat: add f32 feature (#48)

- Add `f32` feature
- f64 as default precision
- Use `Float` type for `f32` and `f64`

Author: jeyum2

bonsai/Cargo.toml

@@ -24,6 +24,7 @@ serde = { version = "1.0.137", features = ["derive"], optional = true }
 
 [features]
 visualize = ["dep:petgraph"]
+f32 = []
 
 [dev-dependencies]
 serde_json = { version = "1.0.81" }

bonsai/src/behavior.rs

@@ -1,6 +1,8 @@
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
+use crate::Float;
+
 /// Describes a behavior.
 ///
 /// This is used for more complex event logic.
@@ -10,8 +12,8 @@ use serde::{Deserialize, Serialize};
 pub enum Behavior<A> {
     /// Waits an amount of time before continuing
     ///
-    /// f64: Time in seconds
-    Wait(f64),
+    /// Float: Time in seconds
+    Wait(Float),
     /// Wait forever.
     WaitForever,
     /// A high level description of an action.
@@ -131,20 +133,23 @@ pub enum Behavior<A> {
 #[cfg(test)]
 #[cfg(feature = "serde")]
 mod tests {
-    use crate::Behavior::{self, Action, Sequence, Wait, WaitForever, WhenAny, While};
+    use crate::{
+        Behavior::{self, Action, Sequence, Wait, WaitForever, WhenAny, While},
+        Float,
+    };
 
     #[derive(serde::Deserialize, serde::Serialize, Clone, Debug)]
     pub(crate) enum EnemyAction {
         /// Circles forever around target pos.
         Circling,
         /// Waits until player is within distance.
-        PlayerWithinDistance(f64),
+        PlayerWithinDistance(Float),
         /// Fly toward player.
         FlyTowardPlayer,
         /// Waits until player is far away from target.
-        PlayerFarAwayFromTarget(f64),
+        PlayerFarAwayFromTarget(Float),
         /// Makes player loose more blood.
-        AttackPlayer(f64),
+        AttackPlayer(Float),
     }
 
     #[test]

bonsai/src/bt.rs

@@ -1,6 +1,6 @@
 use std::fmt::Debug;
 
-use crate::{state::State, ActionArgs, Behavior, Status, UpdateEvent};
+use crate::{state::State, ActionArgs, Behavior, Float, Status, UpdateEvent};
 
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
@@ -45,15 +45,15 @@ impl<A: Clone, B> BT<A, B> {
     /// Passes event, delta time in seconds, action and state to closure.
     /// The closure should return a status and remaining delta time.
     ///
-    /// return: (Status, f64)
+    /// return: (Status, Float)
     /// function returns the result of the tree traversal, and how long
     /// it actually took to complete the traversal and propagate the
     /// results back up to the root node
     #[inline]
-    pub fn tick<E, F>(&mut self, e: &E, f: &mut F) -> Option<(Status, f64)>
+    pub fn tick<E, F>(&mut self, e: &E, f: &mut F) -> Option<(Status, Float)>
     where
         E: UpdateEvent,
-        F: FnMut(ActionArgs<E, A>, &mut B) -> (Status, f64),
+        F: FnMut(ActionArgs<E, A>, &mut B) -> (Status, Float),
     {
         if self.finished {
             return None;

bonsai/src/event.rs

@@ -10,7 +10,7 @@ use serde::{Deserialize, Serialize};
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct UpdateArgs {
     /// Delta time in seconds.
-    pub dt: f64,
+    pub dt: Float,
 }
 
 impl UpdateArgs {
@@ -54,7 +54,7 @@ pub trait UpdateEvent: Sized {
     /// Creates an update event.
     fn from_update_args(args: &UpdateArgs, old_event: &Self) -> Option<Self>;
     /// Creates an update event with delta time.
-    fn from_dt(dt: f64, old_event: &Self) -> Option<Self> {
+    fn from_dt(dt: Float, old_event: &Self) -> Option<Self> {
         UpdateEvent::from_update_args(&UpdateArgs { dt }, old_event)
     }
     /// Calls closure if this is an update event.
@@ -84,6 +84,8 @@ impl UpdateEvent for Event {
 
 use std::time::Instant;
 
+use crate::Float;
+
 /// A monotonic clock/timer that can be used to keep track
 /// of the time increments (delta time) between tick/tree traversals
 /// and the total duration since the behavior tree was first invoked/traversed
@@ -101,18 +103,24 @@ impl Timer {
     }
 
     /// Compute duration since timer started
-    pub fn duration_since_start(&self) -> f64 {
+    pub fn duration_since_start(&self) -> Float {
         let new_now: Instant = Instant::now();
         let duration = new_now.duration_since(self.start);
-        duration.as_secs_f64()
+        #[cfg(feature = "f32")]
+        return duration.as_secs_f32();
+        #[cfg(not(feature = "f32"))]
+        return duration.as_secs_f64();
     }
 
     /// Compute time difference last invocation of `get_dt()` function
-    pub fn get_dt(&mut self) -> f64 {
+    pub fn get_dt(&mut self) -> Float {
         let new_now: Instant = Instant::now();
         let duration = new_now.duration_since(self.now);
         self.now = new_now;
-        duration.as_secs_f64()
+        #[cfg(feature = "f32")]
+        return duration.as_secs_f32();
+        #[cfg(not(feature = "f32"))]
+        return duration.as_secs_f64();
     }
 }
 

bonsai/src/lib.rs

@@ -137,3 +137,9 @@ mod when_all;
 
 #[cfg(feature = "visualize")]
 mod visualizer;
+
+#[cfg(feature = "f32")]
+pub type Float = f32;
+
+#[cfg(not(feature = "f32"))]
+pub type Float = f64;

bonsai/src/sequence.rs

@@ -1,9 +1,10 @@
 use crate::status::Status::*;
+use crate::Float;
 use crate::{event::UpdateEvent, state::State, ActionArgs, Behavior, Status, RUNNING};
 
 pub struct SequenceArgs<'a, A, E, F, B> {
     pub select: bool,
-    pub upd: Option<f64>,
+    pub upd: Option<Float>,
     pub seq: &'a [Behavior<A>],
     pub i: &'a mut usize,
     pub cursor: &'a mut Box<State<A>>,
@@ -16,11 +17,11 @@ pub struct SequenceArgs<'a, A, E, F, B> {
 //
 // `Sequence` fails if any fails and succeeds when all succeeds.
 // `Select` succeeds if any succeeds and fails when all fails.
-pub fn sequence<A, E, F, B>(args: SequenceArgs<A, E, F, B>) -> (Status, f64)
+pub fn sequence<A, E, F, B>(args: SequenceArgs<A, E, F, B>) -> (Status, Float)
 where
     A: Clone,
     E: UpdateEvent,
-    F: FnMut(ActionArgs<E, A>, &mut B) -> (Status, f64),
+    F: FnMut(ActionArgs<E, A>, &mut B) -> (Status, Float),
 {
     let SequenceArgs {
         select,

bonsai/src/state.rs

@@ -3,15 +3,15 @@ use crate::sequence::{sequence, SequenceArgs};
 use crate::state::State::*;
 use crate::status::Status::*;
 use crate::when_all::when_all;
-use crate::{Behavior, Status};
+use crate::{Behavior, Float, Status};
 use std::fmt::Debug;
 
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
 /// The action is still running, and thus the action consumes
 /// all the remaining delta time for the tick
-pub const RUNNING: (Status, f64) = (Running, 0.0);
+pub const RUNNING: (Status, Float) = (Running, 0.0);
 
 /// The arguments in the action callback.
 pub struct ActionArgs<'a, E: 'a, A: 'a> {
@@ -20,7 +20,7 @@ pub struct ActionArgs<'a, E: 'a, A: 'a> {
     /// The remaining delta time. When one action terminates,
     /// it can consume some of dt and the remaining is passed
     /// onto the next action.
-    pub dt: f64,
+    pub dt: Float,
     /// The action running.
     pub action: &'a A,
 }
@@ -36,7 +36,7 @@ pub(crate) enum State<A> {
     /// Ignores failures and always return `Success`.
     AlwaysSucceed(Box<State<A>>),
     /// Keeps track of waiting for a period of time before continuing.
-    Wait { time_to_wait: f64, elapsed_time: f64 },
+    Wait { time_to_wait: Float, elapsed_time: Float },
     /// Waits forever.
     WaitForever,
     /// Keeps track of an `If` behavior.
@@ -196,14 +196,14 @@ impl<A: Clone> State<A> {
     /// Passes event, delta time in seconds, action and state to closure.
     /// The closure should return a status and remaining delta time.
     ///
-    /// return: (Status, f64)
+    /// return: (Status, Float)
     /// function returns the result of the tree traversal, and how long
     /// it actually took to complete the traversal and propagate the
     /// results back up to the root node
-    pub fn tick<E, F, B>(&mut self, e: &E, blackboard: &mut B, f: &mut F) -> (Status, f64)
+    pub fn tick<E, F, B>(&mut self, e: &E, blackboard: &mut B, f: &mut F) -> (Status, Float)
     where
         E: UpdateEvent,
-        F: FnMut(ActionArgs<E, A>, &mut B) -> (Status, f64),
+        F: FnMut(ActionArgs<E, A>, &mut B) -> (Status, Float),
     {
         let upd = e.update(|args| Some(args.dt)).unwrap_or(None);
 
@@ -413,7 +413,7 @@ impl<A: Clone> State<A> {
             ) => {
                 // println!("In AfterState: {}", next_success_index);
                 // Get the least delta time left over.
-                let mut min_dt = f64::MAX;
+                let mut min_dt = Float::MAX;
                 for (j, item) in states.iter_mut().enumerate().skip(*next_success_index) {
                     match item.tick(e, blackboard, f) {
                         (Running, _) => {

bonsai/src/visualizer.rs

@@ -1,12 +1,12 @@
 #![allow(dead_code, unused_imports, unused_variables)]
-use crate::{state::State, Behavior, Select, Sequence, BT};
+use crate::{state::State, Behavior, Float, Select, Sequence, BT};
 use petgraph::{graph::Graph, stable_graph::NodeIndex, Direction::Outgoing};
 use std::{collections::VecDeque, fmt::Debug};
 
 #[derive(Debug, Clone)]
 pub(crate) enum NodeType<A> {
     Root,
-    Wait(f64),
+    Wait(Float),
     WaitForever,
     Action(A),
     Invert,
@@ -152,7 +152,7 @@ mod tests {
     }
 
     // A test state machine that can increment and decrement.
-    fn tick(mut acc: i32, dt: f64, bt: &mut BT<TestActions, HashMap<String, i32>>) -> (i32, Status, f64) {
+    fn tick(mut acc: i32, dt: Float, bt: &mut BT<TestActions, HashMap<String, i32>>) -> (i32, Status, Float) {
         let e: Event = UpdateArgs { dt }.into();
         let (s, t) = bt
             .tick(&e, &mut |args, blackboard| match args.action {

bonsai/src/when_all.rs

@@ -1,4 +1,5 @@
 use crate::status::Status::*;
+use crate::Float;
 use crate::{event::UpdateEvent, state::State, ActionArgs, Status, RUNNING};
 
 // `WhenAll` and `WhenAny` share same algorithm.
@@ -8,16 +9,16 @@ use crate::{event::UpdateEvent, state::State, ActionArgs, Status, RUNNING};
 #[rustfmt::skip]
 pub fn when_all<A, E, F, B>(
     any: bool,
-    upd: Option<f64>,
+    upd: Option<Float>,
     cursors: &mut [Option<State<A>>],
     e: &E,
     f: &mut F,
     blackboard: &mut B,
-) -> (Status, f64)
+) -> (Status, Float)
 where
     A: Clone,
     E: UpdateEvent,
-    F: FnMut(ActionArgs<E, A>, &mut B) -> (Status, f64),
+    F: FnMut(ActionArgs<E, A>, &mut B) -> (Status, Float),
 {
     let (status, inv_status) = if any {
         // `WhenAny`
@@ -27,7 +28,7 @@ where
         (Status::Success, Status::Failure)
     };
     // Get the least delta time left over.
-    let mut min_dt = f64::MAX;
+    let mut min_dt = Float::MAX;
     // Count number of terminated events.
     let mut terminated = 0;
     for cur in cursors.iter_mut() {

bonsai/tests/behavior_tests.rs

@@ -1,7 +1,7 @@
 use crate::behavior_tests::TestActions::{Dec, Inc, LessThan, LessThanRunningSuccess};
 use bonsai_bt::{
-    Action, ActionArgs, After, AlwaysSucceed, Event, Failure, If, Invert, Select, Sequence, Status::Running, Success,
-    UpdateArgs, Wait, WaitForever, WhenAll, While, WhileAll, BT,
+    Action, ActionArgs, After, AlwaysSucceed, Event, Failure, Float, If, Invert, Select, Sequence, Status::Running,
+    Success, UpdateArgs, Wait, WaitForever, WhenAll, While, WhileAll, BT,
 };
 
 /// Some test actions.
@@ -18,7 +18,7 @@ enum TestActions {
 }
 
 // A test state machine that can increment and decrement.
-fn tick(mut acc: i32, dt: f64, state: &mut BT<TestActions, ()>) -> (i32, bonsai_bt::Status, f64) {
+fn tick(mut acc: i32, dt: Float, state: &mut BT<TestActions, ()>) -> (i32, bonsai_bt::Status, Float) {
     let e: Event = UpdateArgs { dt }.into();
     println!("acc {}", acc);
     let (s, t) = state
@@ -59,7 +59,7 @@ fn tick(mut acc: i32, dt: f64, state: &mut BT<TestActions, ()>) -> (i32, bonsai_
 }
 
 // A test state machine that can increment and decrement.
-fn tick_with_ref(acc: &mut i32, dt: f64, state: &mut BT<TestActions, ()>) {
+fn tick_with_ref(acc: &mut i32, dt: Float, state: &mut BT<TestActions, ()>) {
     let e: Event = UpdateArgs { dt }.into();
 
     state