Jengamon/acerola_jam0_gam - Change LWRZHNHAX3O27GSO6GSJRO2KQLLC5D7GT5MMURNK6DZDN4LBORMAC

feat(bt): simplify internals, make the AI not reliant on the world

Created by Jengamon on March 6, 2024

LWRZHNHAX3O27GSO6GSJRO2KQLLC5D7GT5MMURNK6DZDN4LBORMAC

Dependencies

In channels

main

Change contents

Replacement in src/simple_bt.rs at line 8 [3.37]
B:BD[3.200] → [3.200:245]
```
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
```
[3.200]
[3.245]
```
#[derive(Debug, Clone)]
```

Deletion in src/simple_bt.rs at line 18 [3.37]

B:BD[3.456] → [3.456:753]

}
/// 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)
    }

Deletion in src/simple_bt.rs at line 19 [3.37]
B:BD[3.755] → [3.755:792]
```
impl std::cmp::Eq for BehaviorArc {}
```

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

B:BD[3.793] → [3.793:945]

impl std::hash::Hash for BehaviorArc {
    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
        std::ptr::hash(self.0.as_ref(), state)
    }
}

[3.793]

[3.945]

pub type BehaviorArc = Arc<dyn BehaviorNode>;

Deletion in src/simple_bt.rs at line 22 [3.37]

B:BD[3.946] → [3.946:1075]

impl<T: BehaviorNode + 'static> From<T> for BehaviorArc {
    fn from(value: T) -> Self {
        Self(Arc::new(value))
    }
}

Replacement in src/simple_bt.rs at line 26 [3.37]

B:BD[3.1196] → [3.1196:1284]

    fn tick(&self, blackboard: &mut Blackboard, commands: &mut Commands) -> NodeResult;

[3.1196]

[3.1284]

    fn tick(&self, blackboard: &mut Blackboard) -> NodeResult;

Replacement in src/simple_bt.rs at line 150 [3.37]

B:BD[3.4074] → [3.4074:4228]

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

[3.4074]

[3.4228]

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

Replacement in src/simple_bt.rs at line 163 [3.37]

B:BD[3.4558] → [3.4558:4631]

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

[3.4558]

[3.4631]

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

Replacement in src/simple_bt.rs at line 165 [3.37]

B:BD[3.4684] → [3.4684:4736]

            self.tick_node(bp.0.as_ref(), commands)

[3.4684]

[3.4736]

            self.tick_node(bp.as_ref())

Replacement in src/simple_bt.rs at line 168 [3.37]

B:BD[3.4795] → [3.4795:4847]

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

[3.4795]

[3.4847]

            self.tick_node(node.as_ref())

Deletion in src/simple_bt.rs at line 172 [3.37]
B:BD[3.4865] → [3.4865:4891]
B:BD[3.4891] → [4.23:80]
∅:D[4.80] → [3.5033:5034]
B:BD[3.5033] → [3.5033:5034]
B:BD[3.5034] → [4.81:142]
∅:D[4.142] → [3.5190:5238]
B:BD[3.5190] → [3.5190:5238]
B:BD[3.8428] → [3.8428:8436]
```
#[cfg(test)]
mod tests {
    use bevy::ecs::{system::CommandQueue, world::World};
    pub fn create_testing_state() -> (CommandQueue, World) {
        (CommandQueue::default(), World::new())
    }
}
```

Replacement in src/simple_bt/composite/succeeder.rs at line 1 [2.313]

B:BD[2.313] → [2.314:389]

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

[2.313]

[2.389]

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

Deletion in src/simple_bt/composite/succeeder.rs at line 19 [2.313]

B:BD[2.719] → [2.719:876]

    }
}
impl From<BehaviorArc> for Succeeder {
    fn from(value: BehaviorArc) -> Self {
        Self {
            child: Some(value.0.clone()),
        }

Replacement in src/simple_bt/composite/succeeder.rs at line 23 [2.313]

B:BD[2.919] → [2.919:1072]

    fn tick(
        &self,
        blackboard: &mut Blackboard,
        commands: &mut bevy::prelude::Commands,
    ) -> crate::simple_bt::NodeResult {

[2.919]

[2.1072]

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

Replacement in src/simple_bt/composite/succeeder.rs at line 25 [2.313]

B:BD[2.1123] → [2.1123:1176]

            match child.tick(blackboard, commands) {

[2.1123]

[2.1176]

            match child.tick(blackboard) {

Replacement in src/simple_bt/composite/succeeder.rs at line 27 [2.313]

B:BD[2.1258] → [2.1258:1358]

                NodeResult::Running(resume) => NodeResult::Running(Succeeder::from(resume).into()),

[2.1258]

[2.1358]

                NodeResult::Running(resume) => NodeResult::Running(Succeeder::new(resume).arc()),

Replacement in src/simple_bt/composite/sequence.rs at line 30 [4.257]

B:BD[4.1082] → [4.1082:1135]

        SequenceResume { seq, resume, index }.into()

[4.1082]

[4.1135]

        SequenceResume { seq, resume, index }.arc()

Replacement in src/simple_bt/composite/sequence.rs at line 35 [4.257]

B:BD[4.1177] → [4.1177:1312]

    fn tick(
        &self,
        blackboard: &mut Blackboard,
        commands: &mut bevy::prelude::Commands,
    ) -> NodeResult {

[4.1177]

[4.1312]

    fn tick(&self, blackboard: &mut Blackboard) -> NodeResult {

Replacement in src/simple_bt/composite/sequence.rs at line 37 [4.257]

B:BD[4.1368] → [4.1368:1419]

            match sub.tick(blackboard, commands) {

[4.1368]

[4.1419]

            match sub.tick(blackboard) {

Replacement in src/simple_bt/composite/sequence.rs at line 65 [4.257]

B:BD[4.2261] → [4.2261:2396]

    fn tick(
        &self,
        blackboard: &mut Blackboard,
        commands: &mut bevy::prelude::Commands,
    ) -> NodeResult {

[4.2261]

[4.2396]

    fn tick(&self, blackboard: &mut Blackboard) -> NodeResult {

Replacement in src/simple_bt/composite/sequence.rs at line 67 [4.257]

B:BD[4.2442] → [4.2442:2499]

        match self.resume.0.tick(blackboard, commands) {

[4.2442]

[4.2499]

        match self.resume.tick(blackboard) {

Replacement in src/simple_bt/composite/sequence.rs at line 75 [4.257]

B:BD[4.2841] → [4.2841:2892]

            match sub.tick(blackboard, commands) {

[4.2841]

[4.2892]

            match sub.tick(blackboard) {

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

B:BD[4.3303] → [4.3303:3420]

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

[4.3303]

[4.3420]

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

Replacement in src/simple_bt/composite/sequence.rs at line 101 [4.257]

B:BD[4.3593] → [4.3593:3687]

        fn tick(&self, blackboard: &mut Blackboard, _commands: &mut Commands) -> NodeResult {

[4.3593]

[4.3687]

        fn tick(&self, blackboard: &mut Blackboard) -> NodeResult {

Replacement in src/simple_bt/composite/sequence.rs at line 117 [4.257]
B:BD[4.4270] → [4.4270:4299]
```
                    .into(),
```
[4.4270]
[4.4299]
```
                    .arc(),
```

Deletion in src/simple_bt/composite/sequence.rs at line 125 [4.257]

B:BD[4.4386] → [4.4386:4500]

        let (mut cq, world) = create_testing_state();
        let mut commands = Commands::new(&mut cq, &world);

Replacement in src/simple_bt/composite/sequence.rs at line 150 [4.257]

B:BD[4.5112] → [4.5112:5179]

            check!(runner1.proceed(&mut commands) == Some(false));

[4.5112]

[4.5179]

            check!(runner1.proceed() == Some(false));

Replacement in src/simple_bt/composite/sequence.rs at line 154 [4.257]

B:BD[4.5289] → [4.5289:5356]

            check!(runner2.proceed(&mut commands) == Some(false));

[4.5289]

[4.5356]

            check!(runner2.proceed() == Some(false));

Replacement in src/simple_bt/composite/sequence.rs at line 166 [4.257]

B:BD[4.5716] → [4.5716:5776]

            check!(runner1.proceed(&mut commands) == None);

[4.5716]

[4.5776]

            check!(runner1.proceed() == None);

Replacement in src/simple_bt/composite/sequence.rs at line 168 [4.257]

B:BD[4.5871] → [4.5871:5939]

                if let Some(res) = runner1.proceed(&mut commands) {

[4.5871]

[4.5939]

                if let Some(res) = runner1.proceed() {

Replacement in src/simple_bt/composite/sequence.rs at line 181 [4.257]

B:BD[4.6443] → [4.6443:6511]

                if let Some(res) = runner2.proceed(&mut commands) {

[4.6443]

[4.6511]

                if let Some(res) = runner2.proceed() {

Replacement in src/simple_bt/composite/selector.rs at line 30 [4.6699]

B:BD[4.7524] → [4.7524:7577]

        SelectorResume { seq, resume, index }.into()

[4.7524]

[4.7577]

        SelectorResume { seq, resume, index }.arc()

Replacement in src/simple_bt/composite/selector.rs at line 35 [4.6699]

B:BD[4.7619] → [4.7619:7754]

    fn tick(
        &self,
        blackboard: &mut Blackboard,
        commands: &mut bevy::prelude::Commands,
    ) -> NodeResult {

[4.7619]

[4.7754]

    fn tick(&self, blackboard: &mut Blackboard) -> NodeResult {

Replacement in src/simple_bt/composite/selector.rs at line 37 [4.6699]
B:BD[4.7810] → [4.7810:7861]
```
            match sub.tick(blackboard, commands) {
```
[4.7810]
[4.7861]
```
            match sub.tick(blackboard) {
```

Replacement in src/simple_bt/composite/selector.rs at line 65 [4.6699]

B:BD[4.8703] → [4.8703:8838]

    fn tick(
        &self,
        blackboard: &mut Blackboard,
        commands: &mut bevy::prelude::Commands,
    ) -> NodeResult {

[4.8703]

[4.8838]

    fn tick(&self, blackboard: &mut Blackboard) -> NodeResult {

Replacement in src/simple_bt/composite/selector.rs at line 67 [4.6699]

B:BD[4.8884] → [4.8884:8941]

        match self.resume.0.tick(blackboard, commands) {

[4.8884]

[4.8941]

        match self.resume.tick(blackboard) {

Replacement in src/simple_bt/composite/selector.rs at line 75 [4.6699]
B:BD[4.9283] → [4.9283:9334]
```
            match sub.tick(blackboard, commands) {
```
[4.9283]
[4.9334]
```
            match sub.tick(blackboard) {
```

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

B:BD[2.1531] → [2.1532:1607]

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

[2.1531]

[2.1607]

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

Insertion in src/simple_bt/composite/repeater.rs at line 8 [2.1531]

[2.1733]

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

Insertion in src/simple_bt/composite/repeater.rs at line 22 [2.1531]

[2.1900]

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

Insertion in src/simple_bt/composite/repeater.rs at line 34 [2.1531]

[2.2032]

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

Replacement in src/simple_bt/composite/inverter.rs at line 1 [4.9703]

B:BD[4.9703] → [4.9704:9779]

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

[4.9703]

[4.9779]

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

Deletion in src/simple_bt/composite/inverter.rs at line 15 [4.9703]

B:BD[4.9970] → [4.9970:10120]

    }
}
impl From<BehaviorArc> for Inverter {
    fn from(value: BehaviorArc) -> Self {
        Self {
            child: value.0.clone(),
        }

Replacement in src/simple_bt/composite/inverter.rs at line 19 [4.9703]

B:BD[4.10162] → [4.10162:10369]

    fn tick(
        &self,
        blackboard: &mut Blackboard,
        commands: &mut bevy::prelude::Commands,
    ) -> crate::simple_bt::NodeResult {
        match self.child.tick(blackboard, commands) {

[4.10162]

[4.10369]

    fn tick(&self, blackboard: &mut Blackboard) -> crate::simple_bt::NodeResult {
        match self.child.tick(blackboard) {

Replacement in src/simple_bt/composite/inverter.rs at line 23 [4.9703]

B:BD[4.10481] → [4.10481:10576]

            NodeResult::Running(resume) => NodeResult::Running(Inverter::from(resume).into()),

[4.10481]

[4.10576]

            NodeResult::Running(resume) => NodeResult::Running(Inverter::new(resume).arc()),