test for seldom_state AnyState command

seldom_state_anystate_test.rs

//  RUST_LOG=info cargo test -- --nocapture test_state_machine
#[cfg(test)]
mod test {
    use super::*;

    #[derive(Resource, Default)]
    struct Test {
        on_b: bool,
        on_any: bool,
    }

    #[derive(Clone, Debug)]
    struct MyCommand {
        on_any: bool,
    }

    impl Command for MyCommand {
        fn apply(self, world: &mut World) {
            warn!("Command applied: {self:?}");
            let mut test = world.resource_mut::<Test>();
            if self.on_any {
                test.on_any = true;
            } else {
                test.on_b = true;
            }
        }
    }

    #[test]
    fn test_state_machine() {
        #[derive(Component, Clone)]
        struct A;
        #[derive(Component, Clone)]
        struct B;
        #[derive(Component, Clone)]
        struct C;
        #[derive(Component, Clone)]
        struct D;

        let mut app = App::new();
        app.init_resource::<Test>();
        app.add_plugins((
            MinimalPlugins,
            bevy::log::LogPlugin::default(),
            StateMachinePlugin,
        ));
        app.update();

        fn yes_trigger() -> impl EntityTrigger<Out = bool> {
            (|| true).into_trigger()
        }

        let fsm = StateMachine::default()
            .trans::<A, _>(yes_trigger(), B)
            .trans::<B, _>(yes_trigger(), C)
            .trans::<C, _>(yes_trigger(), D)
            .command_on_enter::<B>(MyCommand { on_any: false })
            .command_on_enter::<AnyState>(MyCommand { on_any: true })
            .set_trans_logging(true);

        let initial_state = A;
        let e = app.world_mut().spawn((initial_state, fsm)).id();
        app.update();
        app.update();
        app.update();
        assert!(app.world().get::<A>(e).is_none());
        assert!(app.world().get::<B>(e).is_none());
        assert!(app.world().get::<C>(e).is_none());
        assert!(app.world().get::<D>(e).is_some());

        let test = app.world().resource::<Test>();
        assert!(test.on_b, "on_b should be true");
        assert!(test.on_any, "on_any should be true");
    }
}