bevy_gearbox 0.1.1

State machine system for the bevy game engine
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

use std::marker::PhantomData;

use bevy::prelude::*;
use bevy_ecs::system::{EntityCommand, EntityCommands};


// Extended trait to include both transition and enter commands.
pub trait StateTransitionCommandsExt<T: Component> {
    fn transition(&mut self, state: T);
}

impl<'w, T: Component>
    StateTransitionCommandsExt<T>
    for EntityCommands<'w>
{
    fn transition(&mut self, state: T) {
        self.queue(TransitionStateCommand { state });
    }
}

#[derive(Event)]
pub struct Transition<T: Component>(pub T);

pub struct TransitionStateCommand<T: Component> {
    state: T,
}

impl<T: Component> EntityCommand for TransitionStateCommand<T> {
    fn apply(self, id: Entity, world: &mut World) {
        world.trigger_targets(Transition(self.state), id);
    }
}














pub struct TryExitStateCommand<T, N> {
    new_state: N,
    _pd: PhantomData<T>,
}

impl<T: Component + Clone, N: Component + Clone> EntityCommand for TryExitStateCommand<T, N> {
    fn apply(self, id: Entity, world: &mut World) {
        if let Some(current_state) = world.entity(id).get::<T>() {
            // “Exit” old state
            world.trigger_targets(OnExitState(current_state.clone()), id);

            // Remove + insert via entity_mut instead of world.commands():
            let mut e = world.entity_mut(id);
            e.remove::<T>();
            e.insert(self.new_state.clone());

            // “Enter” new state
            world.trigger_targets(OnEnterState(self.new_state), id);
        }
    }
}

pub trait StateExitCommandsExt<N: Component + Clone> {
    fn try_exit_state<T: Component + Clone>(&mut self, new_state: N);
}

impl<'w, N: Component + Clone>
    StateExitCommandsExt<N>
    for EntityCommands<'w>
{
    fn try_exit_state<T: Component + Clone>(&mut self, new_state: N) {
        self.queue(TryExitStateCommand { new_state, _pd: PhantomData::<T> });
    }
}

#[derive(Event)]
pub struct OnExitState<T: Component>(pub T);








#[derive(Event)]
pub struct OnEnterState<T: Component>(pub T);