Jengamon/acerola_jam0_gam - Change VYN2QOQBFRE5AAQO76D63IV3C4JF3YMXFHJZZ5AHIZOCJRCTFOEAC

feat(debug,bt): free up bt Context, and give Polly a better brain

Created by Jengamon on March 8, 2024

VYN2QOQBFRE5AAQO76D63IV3C4JF3YMXFHJZZ5AHIZOCJRCTFOEAC

Dependencies

In channels

main

Change contents

Replacement in src/simple_bt.rs at line 9 [9.37]
∅:D[8.24] → [9.245:267]
B:BD[9.245] → [9.245:267]
```
pub enum NodeResult {
```
[8.24]
[9.267]
```
pub enum NodeResult {
```
Replacement in src/simple_bt.rs at line 13 [9.37]
B:BD[9.353] → [9.353:379]
```
 Running(BehaviorArc),
```
[9.353]
[9.379]
```
 Running(BehaviorArc),
```

Replacement in src/simple_bt.rs at line 20 [9.37]

B:BD[9.793] → [8.25:71]

pub type BehaviorArc = Arc<dyn BehaviorNode>;

[9.793]

[9.945]

pub type BehaviorArc<B> = Arc<dyn BehaviorNode<B> + Send + Sync>;

Replacement in src/simple_bt.rs at line 25 [9.37]

B:BD[9.1154] → [9.1154:1196]

B:BD[9.1196] → [8.72:135]

pub trait BehaviorNode: std::fmt::Debug {
    fn tick(&self, blackboard: &mut Blackboard) -> NodeResult;

[9.1154]

[9.1284]

pub trait BehaviorNode<B>: std::fmt::Debug {
    fn tick(&self, context: &mut B) -> NodeResult<B>;

Replacement in src/simple_bt.rs at line 28 [9.37]
B:BD[9.1285] → [9.1285:1327]
```
 fn arc(self) -> Arc<dyn BehaviorNode>
```
[9.1285]
[9.1327]
```
 fn arc(self) -> BehaviorArc
```
Replacement in src/simple_bt.rs at line 30 [9.37]
B:BD[9.1337] → [9.1337:1368]
```
        Self: Sized + 'static,
```
[9.1337]
[9.1368]
```
        Self: Sized + Send + Sync + 'static,
```

Deletion in src/simple_bt.rs at line 34 [9.37]

B:BD[9.1403] → [9.1403:1571]

B:BD[9.1571] → [3.30:163]

∅:D[3.163] → [9.1606:1709]

B:BD[9.1606] → [9.1606:1709]

}
// blackboard is how the behavior tree sees/shares information
#[derive(Debug, Clone, PartialEq, Copy)]
pub enum BlackboardValue {
    Integer(i64),
    Float(f64),
    // TODO we aren't going hogwild on these, we only need 32-bit resolution afaik
    Point(Point2<f32>),
    Vector(Vector2<f32>),
    Boolean(bool),
    // We want Copy, and strings are probably unneccessary
    // String(Arc<str>),

Deletion in src/simple_bt.rs at line 36 [9.37]

B:BD[9.1712] → [9.1712:1799]

B:BD[9.1799] → [3.164:201]

∅:D[3.201] → [9.1856:1858]

B:BD[9.1856] → [9.1856:1858]

B:BD[9.1858] → [3.202:388]

∅:D[3.388] → [9.1938:1944]

B:BD[9.1938] → [9.1938:1944]

B:BD[9.1944] → [3.389:503]

∅:D[3.503] → [9.1988:2020]

B:BD[9.1988] → [9.1988:2020]

B:BD[9.2020] → [3.504:567]

∅:D[3.567] → [9.2084:3435]

B:BD[9.2084] → [9.2084:3435]

// TODO If this ever librarifies, make this use mint
pub trait BlackboardValueVector {
    fn vector(self) -> Vector2<f32>;
}
pub trait BlackboardValuePoint {
    fn point(self) -> Point2<f32>;
}
impl<T: Into<Vector2<f32>>> BlackboardValueVector for T {
    fn vector(self) -> Vector2<f32> {
        self.into()
    }
}
impl<T: Into<Point2<f32>>> BlackboardValuePoint for T {
    fn point(self) -> Point2<f32> {
        self.into()
    }
}
impl BlackboardValue {
    fn into_point<T: BlackboardValuePoint>(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())
    }
}

Replacement in src/simple_bt.rs at line 38 [9.37]

B:BD[9.3496] → [9.3496:3624]

pub struct BehaviorRunner {
    tree: Arc<dyn BehaviorNode>,
    current_tick: Option<BehaviorArc>,
    blackboard: Blackboard,

[9.3496]

[9.3624]

pub struct BehaviorRunner<B> {
    tree: BehaviorArc<B>,
    current_tick: Option<BehaviorArc<B>>,

Replacement in src/simple_bt.rs at line 43 [9.37]

B:BD[9.3627] → [9.3627:3703]

impl BehaviorRunner {
    pub fn new(tree: Arc<dyn BehaviorNode>) -> Self {

[9.3627]

[9.3703]

impl<B> BehaviorRunner<B> {
    pub fn new(tree: BehaviorArc<B>) -> Self {

Deletion in src/simple_bt.rs at line 48 [9.37]
B:BD[9.3768] → [3.568:612]
```
            blackboard: Default::default(),
```

Replacement in src/simple_bt.rs at line 55 [9.37]

B:BD[9.3902] → [9.3902:4074]

B:BD[9.4074] → [8.136:255]

    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) -> Option<bool> {
        match node.tick(&mut self.blackboard) {

[9.3902]

[9.4228]

    fn tick_node(&mut self, node: &dyn BehaviorNode<B>, context: &mut B) -> Option<bool> {
        match node.tick(context) {

Replacement in src/simple_bt.rs at line 68 [9.37]

B:BD[9.4558] → [8.256:304]

    pub fn proceed(&mut self) -> Option<bool> {

[9.4558]

[9.4631]

    pub fn proceed(&mut self, context: &mut B) -> Option<bool> {

Replacement in src/simple_bt.rs at line 70 [9.37]

B:BD[9.4684] → [8.305:345]

            self.tick_node(bp.as_ref())

[9.4684]

[9.4736]

            self.tick_node(bp.as_ref(), context)

Replacement in src/simple_bt.rs at line 73 [9.37]

B:BD[9.4795] → [8.346:388]

            self.tick_node(node.as_ref())

[9.4795]

[9.4847]

            self.tick_node(node.as_ref(), context)

Replacement in src/simple_bt/composite/succeeder.rs at line 1 [10.313]
B:BD[10.313] → [8.389:451]
∅:D[8.451] → [10.389:409]
B:BD[10.389] → [10.389:409]
```
use crate::simple_bt::{BehaviorNode, Blackboard, NodeResult};
use std::sync::Arc;
```
[10.313]
[10.409]
```
use crate::simple_bt::{BehaviorArc, BehaviorNode, NodeResult};
```

Replacement in src/simple_bt/composite/succeeder.rs at line 4 [10.313]

B:BD[10.432] → [10.432:514]

#[derive(Debug)]
pub struct Succeeder {
    child: Option<Arc<dyn BehaviorNode>>,

[10.432]

[10.514]

pub struct Succeeder<B> {
    child: Option<BehaviorArc<B>>,

Replacement in src/simple_bt/composite/succeeder.rs at line 8 [10.313]

B:BD[10.517] → [10.517:546]

impl Default for Succeeder {

[10.517]

[10.546]

impl<B> std::fmt::Debug for Succeeder<B> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("Succeeder")
            .field("child", &self.child)
            .finish()
    }
}
impl<B> Default for Succeeder<B> {

Replacement in src/simple_bt/composite/succeeder.rs at line 22 [10.313]

B:BD[10.611] → [10.611:683]

impl Succeeder {
    pub fn new(child: Arc<dyn BehaviorNode>) -> Self {

[10.611]

[10.683]

impl<B> Succeeder<B> {
    pub fn new(child: BehaviorArc<B>) -> Self {

Replacement in src/simple_bt/composite/succeeder.rs at line 28 [10.313]

B:BD[10.885] → [10.885:919]

B:BD[10.919] → [8.452:534]

impl BehaviorNode for Succeeder {
    fn tick(&self, blackboard: &mut Blackboard) -> crate::simple_bt::NodeResult {

[10.885]

[10.1072]

impl<B: 'static> BehaviorNode<B> for Succeeder<B> {
    fn tick(&self, blackboard: &mut B) -> crate::simple_bt::NodeResult<B> {

Replacement in src/simple_bt/composite/sequence.rs at line 1 [11.257]

B:BD[11.257] → [11.258:333]

use crate::simple_bt::{BehaviorArc, BehaviorNode, Blackboard, NodeResult};

[11.257]

[11.333]

use crate::simple_bt::{BehaviorArc, BehaviorNode, NodeResult};

Replacement in src/simple_bt/composite/sequence.rs at line 4 [11.257]

B:BD[11.354] → [11.354:426]

pub struct Sequence {
    pub(crate) sub: Arc<[Arc<dyn BehaviorNode>]>,

[11.354]

[11.426]

pub struct Sequence<B> {
    pub(crate) sub: Arc<[BehaviorArc<B>]>,

Replacement in src/simple_bt/composite/sequence.rs at line 8 [11.257]
B:BD[11.429] → [11.429:465]
```
impl std::fmt::Debug for Sequence {
```
[11.429]
[11.465]
```
impl std::fmt::Debug for Sequence {
```

Replacement in src/simple_bt/composite/sequence.rs at line 16 [11.257]

B:BD[11.676] → [11.676:744]

impl<I: Into<Arc<dyn BehaviorNode>>> FromIterator<I> for Sequence {

[11.676]

[11.744]

impl<B, I: Into<BehaviorArc<B>>> FromIterator<I> for Sequence<B> {

Replacement in src/simple_bt/composite/sequence.rs at line 24 [11.257]
B:BD[11.923] → [11.923:939]
```
impl Sequence {
```
[11.923]
[11.939]
```
impl<B: 'static> Sequence {
```
Replacement in src/simple_bt/composite/sequence.rs at line 26 [11.257]
B:BD[11.965] → [11.965:1008]
```
 seq: Arc<[Arc<dyn BehaviorNode>]>,
```
[11.965]
[11.1008]
```
 seq: Arc<[BehaviorArc]>,
```

Replacement in src/simple_bt/composite/sequence.rs at line 28 [11.257]

B:BD[11.1030] → [11.1030:1082]

        resume: BehaviorArc,
    ) -> BehaviorArc {

[11.1030]

[8.678]

        resume: BehaviorArc<B>,
    ) -> BehaviorArc<B> {

Replacement in src/simple_bt/composite/sequence.rs at line 34 [11.257]

B:BD[11.1144] → [11.1144:1177]

B:BD[11.1177] → [8.731:795]

impl BehaviorNode for Sequence {
    fn tick(&self, blackboard: &mut Blackboard) -> NodeResult {

[11.1144]

[11.1312]

impl<B: 'static> BehaviorNode<B> for Sequence<B> {
    fn tick(&self, blackboard: &mut B) -> NodeResult<B> {

Replacement in src/simple_bt/composite/sequence.rs at line 49 [11.257]

B:BD[11.1748] → [11.1748:1869]

pub(crate) struct SequenceResume {
    pub(crate) seq: Arc<[Arc<dyn BehaviorNode>]>,
    pub(crate) resume: BehaviorArc,

[11.1748]

[11.1869]

pub(crate) struct SequenceResume<B> {
    pub(crate) seq: Arc<[BehaviorArc<B>]>,
    pub(crate) resume: BehaviorArc<B>,

Replacement in src/simple_bt/composite/sequence.rs at line 55 [11.257]
B:BD[11.1901] → [11.1901:1943]
```
impl std::fmt::Debug for SequenceResume {
```
[11.1901]
[11.1943]
```
impl std::fmt::Debug for SequenceResume {
```

Replacement in src/simple_bt/composite/sequence.rs at line 64 [11.257]

B:BD[11.2222] → [11.2222:2261]

B:BD[11.2261] → [8.838:902]

impl BehaviorNode for SequenceResume {
    fn tick(&self, blackboard: &mut Blackboard) -> NodeResult {

[11.2222]

[11.2396]

impl<B: 'static> BehaviorNode<B> for SequenceResume<B> {
    fn tick(&self, blackboard: &mut B) -> NodeResult<B> {

Replacement in src/simple_bt/composite/sequence.rs at line 90 [11.257]

B:BD[11.3303] → [8.991:1064]

    use crate::simple_bt::{BehaviorRunner, Blackboard, BlackboardValue};

[11.3303]

[11.3420]

    use crate::simple_bt::BehaviorRunner;

Deletion in src/simple_bt/composite/sequence.rs at line 99 [11.257]

B:BD[11.3557] → [11.3557:3593]

B:BD[11.3593] → [8.1065:1133]

∅:D[8.1133] → [11.3687:3841]

B:BD[11.3687] → [11.3687:3841]


    impl BehaviorNode for MoveTo {
        fn tick(&self, blackboard: &mut Blackboard) -> NodeResult {
            let Some(BlackboardValue::Point(position)) = blackboard.get_mut("position") else {
                return NodeResult::Failure;
            };

Replacement in src/simple_bt/composite/sequence.rs at line 100 [11.257]

B:BD[11.3842] → [3.613:831]

            let mut pos: Vec2 = (*position).into();
            let movement = (self.goal - pos) * self.part.recip();
            pos += movement;
            // Store position back
            *position = pos.into();

[11.3842]

[3.831]

    impl BehaviorNode<Vec2> for MoveTo {
        fn tick(&self, position: &mut Vec2) -> NodeResult<Vec2> {
            let movement = (self.goal - *position) * self.part.recip();
            *position += movement;

Replacement in src/simple_bt/composite/sequence.rs at line 106 [11.257]

B:BD[11.3987] → [3.833:885]

            if (self.goal - pos).length() < ERROR {

[11.3987]

[11.4045]

            if (self.goal - *position).length() < ERROR {

Replacement in src/simple_bt/composite/sequence.rs at line 135 [11.257]
B:BD[11.4899] → [11.4899:4930]
```
 .collect::<Sequence>()
```
[11.4899]
[11.4930]
```
 .collect::<Sequence<_>>()
```

Deletion in src/simple_bt/composite/sequence.rs at line 138 [11.257]

B:BD[11.4947] → [11.4947:5003]

B:BD[11.5003] → [7.22:181]

∅:D[7.181] → [11.5356:5367]

∅:D[8.1272] → [11.5356:5367]

B:BD[11.5356] → [11.5356:5367]

        // With no info, the node should fail
        {
            let mut runner = BehaviorRunner::new(tree.clone());
            check!(!runner.is_running());
            check!(runner.proceed() == Some(false));
        }

Replacement in src/simple_bt/composite/sequence.rs at line 139 [11.257]
B:BD[11.5396] → [11.5396:5443]
```
        let starting_position = Vec2::X * 5.0;
```
[11.5396]
[11.5443]
```
        let mut position = Vec2::X * 5.0;
```

Replacement in src/simple_bt/composite/sequence.rs at line 144 [11.257]

B:BD[7.246] → [7.246:265]

∅:D[7.265] → [11.6159:6275]

B:BD[11.6159] → [11.6159:6275]

B:BD[11.6275] → [7.266:486]

∅:D[7.486] → [11.6511:6630]

∅:D[8.1432] → [11.6511:6630]

B:BD[11.6511] → [11.6511:6630]

            runner
                .blackboard_mut()
                .set("position", BlackboardValue::into_point(starting_position));
            while let Some(BlackboardValue::Point(pos)) = runner.blackboard().get("position") {
                eprintln!("position = {pos:?}\nrunner = {runner:?}");
                if let Some(res) = runner.proceed() {
                    // we should succeed
                    check!(res);
                    break;
                }

[7.246]

[11.6630]

            let mut res = None;
            while res.is_none() {
                res = runner.proceed(&mut position);

Insertion in src/simple_bt/composite/sequence.rs at line 148 [11.257]
[11.6644]
[11.6644]
```
            check!(res.is_some_and(|v| v));
```

Replacement in src/simple_bt/composite/selector.rs at line 1 [11.6699]

B:BD[11.6699] → [11.6700:6775]

use crate::simple_bt::{BehaviorArc, BehaviorNode, Blackboard, NodeResult};

[11.6699]

[11.6775]

use crate::simple_bt::{BehaviorArc, BehaviorNode, NodeResult};

Replacement in src/simple_bt/composite/selector.rs at line 4 [11.6699]

B:BD[11.6796] → [11.6796:6868]

pub struct Selector {
    pub(crate) sub: Arc<[Arc<dyn BehaviorNode>]>,

[11.6796]

[11.6868]

pub struct Selector<B> {
    pub(crate) sub: Arc<[BehaviorArc<B>]>,

Replacement in src/simple_bt/composite/selector.rs at line 8 [11.6699]
B:BD[11.6871] → [11.6871:6907]
```
impl std::fmt::Debug for Selector {
```
[11.6871]
[11.6907]
```
impl std::fmt::Debug for Selector {
```

Replacement in src/simple_bt/composite/selector.rs at line 16 [11.6699]

B:BD[11.7118] → [11.7118:7186]

impl<I: Into<Arc<dyn BehaviorNode>>> FromIterator<I> for Selector {

[11.7118]

[11.7186]

impl<B, I: Into<BehaviorArc<B>>> FromIterator<I> for Selector<B> {

Replacement in src/simple_bt/composite/selector.rs at line 24 [11.6699]
B:BD[11.7365] → [11.7365:7381]
```
impl Selector {
```
[11.7365]
[11.7381]
```
impl<B: 'static> Selector {
```
Replacement in src/simple_bt/composite/selector.rs at line 26 [11.6699]
B:BD[11.7407] → [11.7407:7450]
```
 seq: Arc<[Arc<dyn BehaviorNode>]>,
```
[11.7407]
[11.7450]
```
 seq: Arc<[BehaviorArc]>,
```

Replacement in src/simple_bt/composite/selector.rs at line 28 [11.6699]

B:BD[11.7472] → [11.7472:7524]

        resume: BehaviorArc,
    ) -> BehaviorArc {

[11.7472]

[8.1433]

        resume: BehaviorArc<B>,
    ) -> BehaviorArc<B> {

Replacement in src/simple_bt/composite/selector.rs at line 34 [11.6699]

B:BD[11.7586] → [11.7586:7619]

B:BD[11.7619] → [8.1486:1550]

impl BehaviorNode for Selector {
    fn tick(&self, blackboard: &mut Blackboard) -> NodeResult {

[11.7586]

[11.7754]

impl<B: 'static> BehaviorNode<B> for Selector<B> {
    fn tick(&self, blackboard: &mut B) -> NodeResult<B> {

Replacement in src/simple_bt/composite/selector.rs at line 49 [11.6699]

B:BD[11.8190] → [11.8190:8311]

pub(crate) struct SelectorResume {
    pub(crate) seq: Arc<[Arc<dyn BehaviorNode>]>,
    pub(crate) resume: BehaviorArc,

[11.8190]

[11.8311]

pub(crate) struct SelectorResume<B> {
    pub(crate) seq: Arc<[BehaviorArc<B>]>,
    pub(crate) resume: BehaviorArc<B>,

Replacement in src/simple_bt/composite/selector.rs at line 55 [11.6699]
B:BD[11.8343] → [11.8343:8385]
```
impl std::fmt::Debug for SelectorResume {
```
[11.8343]
[11.8385]
```
impl std::fmt::Debug for SelectorResume {
```

Replacement in src/simple_bt/composite/selector.rs at line 64 [11.6699]

B:BD[11.8664] → [11.8664:8703]

B:BD[11.8703] → [8.1593:1657]

impl BehaviorNode for SelectorResume {
    fn tick(&self, blackboard: &mut Blackboard) -> NodeResult {

[11.8664]

[11.8838]

impl<B: 'static> BehaviorNode<B> for SelectorResume<B> {
    fn tick(&self, blackboard: &mut B) -> NodeResult<B> {

Replacement in src/simple_bt/composite/repeater.rs at line 1 [10.1531]

B:BD[10.1531] → [8.1746:1808]

use crate::simple_bt::{BehaviorNode, Blackboard, NodeResult};

[10.1531]

[10.1607]

use crate::simple_bt::{BehaviorArc, BehaviorNode, NodeResult};
use std::fmt::Debug;

Replacement in src/simple_bt/composite/repeater.rs at line 6 [10.1531]

B:BD[10.1660] → [10.1660:1699]

B:BD[10.1699] → [4.0:43]

∅:D[4.43] → [10.1699:1733]

B:BD[10.1699] → [10.1699:1733]

#[derive(Debug)]
pub struct Repeated {
    resume: Option<Arc<dyn BehaviorNode>>,
    child: Arc<dyn BehaviorNode>,

[10.1660]

[5.0]

pub struct Repeated<B> {
    resume: Option<BehaviorArc<B>>,
    child: BehaviorArc<B>,
}
impl<B> Debug for Repeated<B> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("Repeated")
            .field("child", &self.child)
            .finish()
    }

Replacement in src/simple_bt/composite/repeater.rs at line 19 [10.1531]

B:BD[5.3] → [5.3:74]

impl Repeated {
    pub fn new(child: Arc<dyn BehaviorNode>) -> Self {

[5.3]

[5.74]

impl<B> Repeated<B> {
    pub fn new(child: BehaviorArc<B>) -> Self {

Replacement in src/simple_bt/composite/repeater.rs at line 28 [10.1531]

B:BD[8.1812] → [8.1812:1909]

impl BehaviorNode for Repeated {
    fn tick(&self, blackboard: &mut Blackboard) -> NodeResult {

[8.1812]

[4.44]

impl<B: 'static> BehaviorNode<B> for Repeated<B> {
    fn tick(&self, blackboard: &mut B) -> NodeResult<B> {

Replacement in src/simple_bt/composite/repeater.rs at line 66 [10.1531]

B:BD[10.1780] → [10.1780:1860]

#[derive(Debug)]
pub struct LimitedRepeated {
    child: Arc<dyn BehaviorNode>,

[10.1780]

[10.1860]

pub struct LimitedRepeated<B> {
    child: BehaviorArc<B>,

Insertion in src/simple_bt/composite/repeater.rs at line 70 [10.1531]

[10.1900]

[8.1932]

}
impl<B> Debug for LimitedRepeated<B> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        todo!()
    }

Replacement in src/simple_bt/composite/repeater.rs at line 78 [10.1531]

B:BD[8.1935] → [8.1935:2039]

impl BehaviorNode for LimitedRepeated {
    fn tick(&self, blackboard: &mut Blackboard) -> NodeResult {

[8.1935]

[8.2039]

impl<B> BehaviorNode<B> for LimitedRepeated<B> {
    fn tick(&self, blackboard: &mut B) -> NodeResult<B> {

Replacement in src/simple_bt/composite/repeater.rs at line 85 [10.1531]

B:BD[10.1947] → [10.1947:2032]

#[derive(Debug)]
pub struct RepeatedUntilFailure {
    child: Arc<dyn BehaviorNode>,

[10.1947]

[8.2062]

pub struct RepeatedUntilFailure<B> {
    child: BehaviorArc<B>,
}
impl<B> Debug for RepeatedUntilFailure<B> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("RepeatedUntilFailure")
            .field("child", &self.child)
            .finish()
    }

Replacement in src/simple_bt/composite/repeater.rs at line 97 [10.1531]

B:BD[8.2065] → [8.2065:2174]

impl BehaviorNode for RepeatedUntilFailure {
    fn tick(&self, blackboard: &mut Blackboard) -> NodeResult {

[8.2065]

[8.2174]

impl<B> BehaviorNode<B> for RepeatedUntilFailure<B> {
    fn tick(&self, blackboard: &mut B) -> NodeResult<B> {

Replacement in src/simple_bt/composite/inverter.rs at line 1 [11.9703]
B:BD[11.9703] → [8.2197:2259]
∅:D[8.2259] → [11.9779:9799]
B:BD[11.9779] → [11.9779:9799]
```
use crate::simple_bt::{BehaviorNode, Blackboard, NodeResult};
use std::sync::Arc;
```
[11.9703]
[11.9799]
```
use crate::simple_bt::{BehaviorArc, BehaviorNode, NodeResult};
```
Replacement in src/simple_bt/composite/inverter.rs at line 6 [11.9703]
∅:D[10.2121] → [11.9800:9873]
B:BD[11.9800] → [11.9800:9873]
```
#[derive(Debug)]
pub struct Inverter {
 child: Arc<dyn BehaviorNode>,
```
[10.2121]
[11.9873]
```
pub struct Inverter {
 child: BehaviorArc,
```

Replacement in src/simple_bt/composite/inverter.rs at line 10 [11.9703]

B:BD[11.9876] → [11.9876:9947]

impl Inverter {
    pub fn new(child: Arc<dyn BehaviorNode>) -> Self {

[11.9876]

[11.9947]

impl<B> std::fmt::Debug for Inverter<B> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("Inverter")
            .field("child", &self.child)
            .finish()
    }
}
impl<B> Inverter<B> {
    pub fn new(child: BehaviorArc<B>) -> Self {

Replacement in src/simple_bt/composite/inverter.rs at line 24 [11.9703]

B:BD[11.10129] → [11.10129:10162]

B:BD[11.10162] → [8.2260:2342]

impl BehaviorNode for Inverter {
    fn tick(&self, blackboard: &mut Blackboard) -> crate::simple_bt::NodeResult {

[11.10129]

[8.2342]

impl<B: 'static> BehaviorNode<B> for Inverter<B> {
    fn tick(&self, blackboard: &mut B) -> NodeResult<B> {

Insertion in src/debug.rs at line 1 [12.120]

[12.120]

[6.2120]

use crate::simple_bt::composite::{Repeated, Sequence};
use crate::simple_bt::{BehaviorNode, BehaviorRunner, NodeResult};

Insertion in src/debug.rs at line 37 [12.120]

[13.457]

#[derive(Component)]
struct PollyBrain {
    thinking: bool,
    runner: BehaviorRunner<(Vec2, Vec2)>,
}

Insertion in src/debug.rs at line 51 [12.120]

[13.662]

[2.0]

        PollyBrain {
            thinking: false,
            runner: BehaviorRunner::new(
                Repeated::new(
                    [
                        MoveTo {
                            speed: 250.,
                            goal: Vec2::X * 300.0,
                        }
                        .arc(),
                        MoveTo {
                            speed: 250.,
                            goal: Vec2::NEG_X * 300.0,
                        }
                        .arc(),
                    ]
                    .into_iter()
                    .collect::<Sequence<_>>()
                    .arc(),
                )
                .arc(),
            ),
        },

Insertion in src/debug.rs at line 157 [12.120]

[14.307]

[15.832]

}
#[derive(Debug, Clone)]
struct MoveTo {
    speed: f32,
    goal: Vec2,
}
impl BehaviorNode<(Vec2, Vec2)> for MoveTo {
    fn tick(&self, (position, velocity): &mut (Vec2, Vec2)) -> NodeResult<(Vec2, Vec2)> {
        let dist = (self.goal - *position).length();
        const ERROR: f32 = 10.0;
        if dist <= ERROR {
            NodeResult::Success
        } else {
            let desired_vel = (self.goal - *position).normalize_or_zero() * self.speed;
            debug!("{desired_vel:?} {velocity:?}");
            let dvn = desired_vel.normalize_or_zero();
            let vn = velocity.normalize_or_zero();
            let dvl = desired_vel.length();
            let vl = velocity.length();
            const KEEP: f32 = 0.9;
            if dvn.dot(vn) <= 0.0 || vl < dvl {
                *velocity *= KEEP;
                *velocity += (desired_vel - *velocity) * (1.0 - KEEP);
            }
            NodeResult::Running(self.clone().arc())
        }
    }

Insertion in src/debug.rs at line 202 [12.120]
[16.2529]
[16.2529]
```
            &mut Transform,
```
Insertion in src/debug.rs at line 205 [12.120]
[16.2616]
[16.2616]
```
            &mut PollyBrain,
```

Replacement in src/debug.rs at line 246 [12.120]

B:BD[13.2001] → [16.2656:2730]

            let (polly_entity, cam_target, movable) = polly.single_mut();

[13.2001]

[13.2062]

            let (polly_entity, transform, cam_target, mut movable, mut thunk) = polly.single_mut();

Replacement in src/debug.rs at line 263 [12.120]

B:BD[16.2746] → [16.2746:2795]

            if let Some(mut movable) = movable {

[16.2746]

[16.2795]

            if let Some(movable) = movable.as_mut() {

Insertion in src/debug.rs at line 269 [12.120]
[16.3034]
[16.3034]
```
                movable.acceleration *= 0.1;
```

Insertion in src/debug.rs at line 275 [12.120]

[16.3246]

[13.2668]

            }
            if ui
                .toggle_value(&mut thunk.thinking, "Has Thought")
                .changed()
            {
                if movable.is_none() && thunk.thinking {
                    commands.entity(polly_entity).insert(movement::Movable {
                        mass: 20.0,
                        ..default()
                    });
                }

Insertion in src/debug.rs at line 288 [12.120]

[13.2682]


            if thunk.thinking {
                if let Some(movable) = movable.as_mut() {
                    let mut context = (transform.translation.truncate(), movable.velocity);
                    if let Some(res) = thunk.runner.proceed(&mut context) {
                        info!("Thunking complete step: {context:?} {res}");
                    }
                    movable.velocity = context.1;
                }
            }