Jengamon/acerola_jam0_gam - Change G3FE5YP2OBTWE563KVAJTSUGIYNF3NDOVZSOP2DART725GPZRC3QC

feat: start a simple behavior tree implementation

Created by Jengamon on March 6, 2024

G3FE5YP2OBTWE563KVAJTSUGIYNF3NDOVZSOP2DART725GPZRC3QC

Dependencies

In channels

main

Change contents

File addition: simple_bt.rs (----------)

[4.15]

//! Create a simple behavior tree implementation
mod composite;
use bevy::prelude::*;
pub use composite::Sequence;
use std::{collections::HashMap, sync::Arc};
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum NodeResult {
    /// The node is still running
    ///
    /// This contains the node to be ticked
    Running(BehaviorArc),
    /// The node succeeded
    Success,
    /// The node failed
    Failure,
}
/// A wrapper around a behavior node reference that
/// implements pointer equality behavior
#[derive(Clone, Debug)]
pub struct BehaviorArc(Arc<dyn BehaviorNode>);
impl std::cmp::PartialEq for BehaviorArc {
    fn eq(&self, other: &Self) -> bool {
        Arc::ptr_eq(&self.0, &other.0)
    }
}
impl std::cmp::Eq for BehaviorArc {}
impl std::hash::Hash for BehaviorArc {
    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
        std::ptr::hash(self.0.as_ref(), state)
    }
}
impl<T: BehaviorNode + 'static> From<T> for BehaviorArc {
    fn from(value: T) -> Self {
        Self(Arc::new(value))
    }
}
// This is our main "behavior tree" trait.
// all nodes implement this trait.
pub trait BehaviorNode: std::fmt::Debug {
    fn tick(&self, blackboard: &mut Blackboard, commands: &mut Commands) -> NodeResult;
    fn arc(self) -> Arc<dyn BehaviorNode>
    where
        Self: Sized + 'static,
    {
        Arc::new(self)
    }
}
// blackboard is how the behavior tree sees/shares information
#[derive(Debug, Clone, PartialEq, Copy)]
pub enum BlackboardValue {
    Integer(i64),
    Float(f64),
    Point(Vec2),
    Vector(Vec2),
    Boolean(bool),
    // We want Copy, and strings are probably unneccessary
    // String(Arc<str>),
}
// TODO If this ever librarifies, make this use mint
pub trait BlackboardValueVector {
    fn point(self) -> Vec2;
    fn vector(self) -> Vec2;
}
impl BlackboardValueVector for Vec2 {
    fn point(self) -> Vec2 {
        self
    }
    fn vector(self) -> Vec2 {
        self
    }
}
impl BlackboardValue {
    fn into_point<T: BlackboardValueVector>(point: T) -> Self {
        Self::Point(point.point())
    }
    fn into_vector<T: BlackboardValueVector>(vector: T) -> Self {
        Self::Vector(vector.vector())
    }
}
impl From<bool> for BlackboardValue {
    fn from(value: bool) -> Self {
        Self::Boolean(value)
    }
}
macro_rules! bv_from {
    (integer $type:ty) => {
        impl From<$type> for BlackboardValue {
            fn from(value: $type) -> Self {
                Self::Integer(i64::from(value))
            }
        }
    };
    (float $type:ty) => {
        impl From<$type> for BlackboardValue {
            fn from(value: $type) -> Self {
                Self::Float(f64::from(value))
            }
        }
    };
}
bv_from!(integer u8);
bv_from!(integer u16);
bv_from!(integer u32);
bv_from!(integer i8);
bv_from!(integer i16);
bv_from!(integer i32);
bv_from!(float f32);
bv_from!(float f64);
#[derive(Debug, Default)]
pub struct Blackboard(HashMap<Box<str>, BlackboardValue>);
impl Blackboard {
    pub fn set<S: AsRef<str>>(&mut self, key: S, value: BlackboardValue) {
        self.0.insert(Box::from(key.as_ref()), value);
    }
    pub fn get<S: AsRef<str>>(&self, key: S) -> Option<&BlackboardValue> {
        self.0.get(key.as_ref())
    }
    pub fn get_mut<S: AsRef<str>>(&mut self, key: S) -> Option<&mut BlackboardValue> {
        self.0.get_mut(key.as_ref())
    }
}
#[derive(Debug)]
/// Takes care of executing a behavior tree
pub struct BehaviorRunner {
    tree: Arc<dyn BehaviorNode>,
    current_tick: Option<BehaviorArc>,
    blackboard: Blackboard,
}
impl BehaviorRunner {
    pub fn new(tree: Arc<dyn BehaviorNode>) -> Self {
        Self {
            tree,
            current_tick: None,
            blackboard: default(),
        }
    }
    pub fn is_running(&self) -> bool {
        self.current_tick.is_some()
    }
    pub fn blackboard(&self) -> &Blackboard {
        &self.blackboard
    }
    pub fn blackboard_mut(&mut self) -> &mut Blackboard {
        &mut self.blackboard
    }
    fn tick_node(&mut self, node: &dyn BehaviorNode, commands: &mut Commands) -> Option<bool> {
        match node.tick(&mut self.blackboard, commands) {
            NodeResult::Running(nbp) => {
                self.current_tick = Some(nbp);
                None
            }
            NodeResult::Success => Some(true),
            NodeResult::Failure => Some(false),
        }
    }
    // returns None -> still running
    // return Some(p) -> p true success, p false failure
    pub fn proceed(&mut self, commands: &mut Commands) -> Option<bool> {
        if let Some(bp) = self.current_tick.take() {
            self.tick_node(bp.0.as_ref(), commands)
        } else {
            let node = self.tree.clone();
            self.tick_node(node.as_ref(), commands)
        }
    }
}
#[cfg(test)]
mod tests {
    use assert2::check;
    use bevy::ecs::{
        system::{CommandQueue, Commands},
        world::World,
    };
    use bevy::prelude::*;
    use super::{BehaviorNode, BehaviorRunner, Blackboard, BlackboardValue, NodeResult, Sequence};
    fn create_testing_state() -> (CommandQueue, World) {
        (CommandQueue::default(), World::new())
    }
    #[derive(Debug)]
    struct MoveTo {
        part: f32,
        goal: Vec2,
    }
    impl BehaviorNode for MoveTo {
        fn tick(&self, blackboard: &mut Blackboard, _commands: &mut Commands) -> NodeResult {
            let Some(BlackboardValue::Point(position)) = blackboard.get_mut("position") else {
                return NodeResult::Failure;
            };
            let movement = (self.goal - *position) * self.part.recip();
            *position += movement;
            const ERROR: f32 = 0.001;
            if (self.goal - *position).length() < ERROR {
                NodeResult::Success
            } else {
                NodeResult::Running(
                    Self {
                        part: self.part,
                        goal: self.goal,
                    }
                    .into(),
                )
            }
        }
    }
    #[test]
    fn test_seequence() {
        let (mut cq, world) = create_testing_state();
        let mut commands = Commands::new(&mut cq, &world);
        let tree1 = MoveTo {
            part: 5.0,
            goal: Vec2::ZERO,
        }
        .arc();
        let tree2 = [
            MoveTo {
                part: 5.0,
                goal: Vec2::ZERO,
            }
            .arc(),
            MoveTo {
                part: 5.0,
                goal: Vec2::splat(5.0),
            }
            .arc(),
        ]
        .into_iter()
        .collect::<Sequence>()
        .arc();
        // With no info, the node should fail
        {
            let mut runner1 = BehaviorRunner::new(tree1.clone());
            check!(!runner1.is_running());
            check!(runner1.proceed(&mut commands) == Some(false));
            let mut runner2 = BehaviorRunner::new(tree2.clone());
            check!(!runner2.is_running());
            check!(runner2.proceed(&mut commands) == Some(false));
        }
        // Set some position
        let starting_position = Vec2::X * 5.0;
        // If a position is set, we will execute the action
        {
            let mut runner1 = BehaviorRunner::new(tree1.clone());
            runner1
                .blackboard_mut()
                .set("position", BlackboardValue::into_point(starting_position));
            check!(runner1.proceed(&mut commands) == None);
            while let Some(BlackboardValue::Point(_)) = runner1.blackboard().get("position") {
                if let Some(res) = runner1.proceed(&mut commands) {
                    // we should succeed
                    check!(res);
                    break;
                }
            }
            let mut runner2 = BehaviorRunner::new(tree2.clone());
            runner2
                .blackboard_mut()
                .set("position", BlackboardValue::into_point(starting_position));
            while let Some(BlackboardValue::Point(pos)) = runner2.blackboard().get("position") {
                eprintln!("position = {pos:?}\nrunner = {runner2:?}");
                if let Some(res) = runner2.proceed(&mut commands) {
                    // we should succeed
                    check!(res);
                    break;
                }
            }
        }
    }
}

File addition: simple_bt (d--x------)
[4.15]

File addition: composite.rs (----------)

[0.8458]

//! Implementations of composite nodes
// We do a little thin runner so nodes are thick
use std::sync::Arc;
use super::{BehaviorArc, BehaviorNode, NodeResult};
pub struct Sequence {
    sub: Arc<[Arc<dyn BehaviorNode>]>,
}
impl std::fmt::Debug for Sequence {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct(&format!("Sequence<{:p}>", self.sub.as_ref()))
            .field("sub", &self.sub)
            .finish()
    }
}
impl<I: Into<Arc<dyn BehaviorNode>>> FromIterator<I> for Sequence {
    fn from_iter<T: IntoIterator<Item = I>>(iter: T) -> Self {
        Self {
            sub: Arc::from(iter.into_iter().map(Into::into).collect::<Vec<_>>()),
        }
    }
}
impl Sequence {
    fn resume(seq: Arc<[Arc<dyn BehaviorNode>]>, index: usize, resume: BehaviorArc) -> BehaviorArc {
        SequenceResume { seq, resume, index }.into()
    }
}
impl BehaviorNode for Sequence {
    fn tick(
        &self,
        blackboard: &mut super::Blackboard,
        commands: &mut bevy::prelude::Commands,
    ) -> NodeResult {
        for (idx, sub) in self.sub.iter().enumerate() {
            match sub.tick(blackboard, commands) {
                NodeResult::Success => {}
                NodeResult::Failure => return NodeResult::Failure,
                NodeResult::Running(resume) => {
                    return NodeResult::Running(Self::resume(self.sub.clone(), idx, resume))
                }
            }
        }
        NodeResult::Success
    }
}
struct SequenceResume {
    seq: Arc<[Arc<dyn BehaviorNode>]>,
    resume: BehaviorArc,
    index: usize,
}
impl std::fmt::Debug for SequenceResume {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct(&format!("SequenceResume<{:p}>", self.seq.as_ref()))
            .field("resume", &self.resume)
            .field("index", &self.index)
            .finish_non_exhaustive()
    }
}
impl BehaviorNode for SequenceResume {
    fn tick(
        &self,
        blackboard: &mut super::Blackboard,
        commands: &mut bevy::prelude::Commands,
    ) -> NodeResult {
        // Tick the node we want to resume on
        match self.resume.0.tick(blackboard, commands) {
            NodeResult::Success => {}
            NodeResult::Failure => return NodeResult::Failure,
            NodeResult::Running(resume) => {
                return NodeResult::Running(Sequence::resume(self.seq.clone(), self.index, resume))
            }
        }
        for (idx, sub) in self.seq.iter().enumerate().skip(self.index) {
            match sub.tick(blackboard, commands) {
                NodeResult::Success => {}
                NodeResult::Failure => return NodeResult::Failure,
                NodeResult::Running(resume) => {
                    return NodeResult::Running(Sequence::resume(self.seq.clone(), idx, resume))
                }
            }
        }
        NodeResult::Success
    }
}

Replacement in src/movement.rs at line 40 [5.368]
B:BD[3.854] → [3.854:886]
```
pub const MIN_SPEED: f32 = 1.0;
```
[3.854]
[3.886]
```
pub const MIN_SPEED: f32 = 0.5;
```

Insertion in src/movement.rs at line 43 [5.368]

[3.984]

/// Minimum acceleration to respect
pub const MIN_ACCEL: f32 = 5.0;

Replacement in src/movement.rs at line 49 [5.368]

B:BD[3.1127] → [3.1127:1254]

    const MU: f32 = 0.7;
    const MU_STATIC: f32 = 0.9;
    const GRAVITY: f32 = 9.8; // m/s^2 on Earth, TODO adjust for feel

[3.1127]

[3.1254]

    const MU: f32 = 0.75;
    const MU_STATIC: f32 = 1.0;
    const GRAVITY: f32 = 10.;

Replacement in src/movement.rs at line 76 [5.368]

B:BD[3.2007] → [3.2007:2072]

        movable.velocity += acceleration * time.delta_seconds();

[3.2007]

[3.2072]

        if movable.velocity.length() > MIN_SPEED || acceleration.length() > MIN_ACCEL {
            movable.velocity += acceleration * time.delta_seconds();
        }

Insertion in src/main.rs at line 14 [4.49]
[6.1560]
[7.17]
```
mod simple_bt;
```

Replacement in src/debug.rs at line 16 [10.120]

B:BD[8.589] → [9.262:308]

        app.add_systems(Startup, setup_debug)

[8.589]

[9.308]

        app.add_event::<MakeABoxTrigger>()
            .add_systems(Startup, setup_debug)
            .add_systems(Update, make_a_box)

Insertion in src/debug.rs at line 69 [10.120]

[9.1880]

[11.1482]

#[derive(Event)]
struct MakeABoxTrigger {
    mass: f32,
}
fn make_a_box(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<ColorMaterial>>,
    mut reader: EventReader<MakeABoxTrigger>,
) {
    for box_trigger in reader.read() {
        commands.spawn((
            movement_pointer::MovementDirection(Vec2::ZERO, 0.0),
            MaterialMesh2dBundle {
                mesh: meshes
                    .add(Rectangle {
                        half_size: (16.0, 24.0).into(),
                    })
                    .into(),
                // Be careful not to overwrite the LDtk transform
                // Change our origin
                material: materials.add(Color::TURQUOISE),
                // Polly is above us all.
                transform: Transform::from_translation(Vec3::Z * 100.0),
                ..default()
            },
            collision::Collidable {
                offset: Vec2::Y * 8.0,
                extents: Vec2::splat(32.0),
            },
            movement::Movable {
                mass: box_trigger.mass,
                ..default()
            },
            spawn_children(|cb| {
                cb.spawn(movement_pointer::MovementPointerBundle::new(
                    materials.add(Color::ORANGE_RED),
                ));
            }),
        ));
    }
}

Insertion in src/debug.rs at line 146 [10.120]
[12.643]
[10.642]
```
    mut writer: EventWriter<MakeABoxTrigger>,
```
Insertion in src/debug.rs at line 149 [10.120]
[2.381]
[10.694]
```
    mut box_mass: Local<f32>,
```

Insertion in src/debug.rs at line 167 [10.120]

[9.1955]

        ui.collapsing("Box Mania", |ui| {
            ui.add(egui::Slider::new(&mut *box_mass, 5.0..=100.0).text("Mass"));
            if ui.button("Make A Box").clicked() {
                writer.send(MakeABoxTrigger { mass: *box_mass });
            }
        });

Insertion in Cargo.toml at line 77 [4.131]
[13.1779]
```
[dev-dependencies]
assert2 = "0.3.14"
```
Insertion in Cargo.lock at line 79 [4.363]
[4.2368]
[4.2368]
```
 "assert2",
```

Insertion in Cargo.lock at line 274 [4.363]

[4.5871]

]
[[package]]
name = "assert2"
version = "0.3.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "844ca3172d927ddd9d01f63b6c80f4ebd3e01c3f787c204626635450dfe3edba"
dependencies = [
 "assert2-macros",
 "diff",
 "is-terminal",
 "yansi",
]
[[package]]
name = "assert2-macros"
version = "0.3.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9ec0e42bd0fe1c8d72c7bde53ac8686764cea0fd86f412b92fcad20fea08b489"
dependencies = [
 "proc-macro2",
 "quote",
 "rustc_version",
 "syn 1.0.109",

Insertion in Cargo.lock at line 1929 [4.363]

[4.35766]


[[package]]
name = "diff"
version = "0.1.13"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8"

Insertion in Cargo.lock at line 2779 [4.363]

[14.6133]

]
[[package]]
name = "is-terminal"
version = "0.4.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f23ff5ef2b80d608d61efee834934d862cd92461afc0560dedf493e4c033738b"
dependencies = [
 "hermit-abi",
 "libc",
 "windows-sys 0.52.0",

Insertion in Cargo.lock at line 5567 [4.363]

[4.99573]

[15.21747]


[[package]]
name = "yansi"
version = "0.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "09041cd90cf85f7f8b2df60c646f853b7f535ce68f85244eb6731cf89fa498ec"

feat: start a simple behavior tree implementation

Dependencies

In channels

Change contents

File addition: simple_bt.rs (----------)

File addition: simple_bt (d--x------)

File addition: composite.rs (----------)

Replacement in src/movement.rs at line 40 [5.368]

Insertion in src/movement.rs at line 43 [5.368]

Replacement in src/movement.rs at line 49 [5.368]

Replacement in src/movement.rs at line 76 [5.368]

Insertion in src/main.rs at line 14 [4.49]

Replacement in src/debug.rs at line 16 [10.120]

Insertion in src/debug.rs at line 69 [10.120]

Insertion in src/debug.rs at line 146 [10.120]

Insertion in src/debug.rs at line 149 [10.120]

Insertion in src/debug.rs at line 167 [10.120]

Insertion in Cargo.toml at line 77 [4.131]

Insertion in Cargo.lock at line 79 [4.363]

Insertion in Cargo.lock at line 274 [4.363]

Insertion in Cargo.lock at line 1929 [4.363]

Insertion in Cargo.lock at line 2779 [4.363]

Insertion in Cargo.lock at line 5567 [4.363]