pyri_state 0.6.0

A flexible `bevy_state` alternative
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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

//! Write a [`StateFlushMessage`] on state flush.

#[cfg(feature = "bevy_app")]
pub use app::*;

#[cfg(feature = "bevy_app")]
mod app {
    use core::marker::PhantomData;

    use bevy_app::{App, Plugin};

    use crate::schedule::StateFlush;

    use super::*;

    /// A plugin that adds a [`StateFlushMessage<S>`] writing system for the [`State`] type `S`
    /// to the [`StateFlush`] schedule.
    ///
    /// Calls [`schedule_flush_message<S>`].
    pub struct FlushMessagePlugin<S: State + Clone>(PhantomData<S>);

    impl<S: State + Clone> Plugin for FlushMessagePlugin<S> {
        fn build(&self, app: &mut App) {
            app.add_message::<StateFlushMessage<S>>();
            schedule_flush_message::<S>(app.get_schedule_mut(StateFlush).unwrap());
        }
    }

    impl<S: State + Clone> Default for FlushMessagePlugin<S> {
        fn default() -> Self {
            Self(PhantomData)
        }
    }

    /// A plugin that adds a [`LocalStateFlushMessage<S>`] writing system for the [`State`] type `S`
    /// to the [`StateFlush`] schedule.
    ///
    /// Calls [`schedule_local_flush_message<S>`].
    pub struct LocalFlushMessagePlugin<S: State + Clone>(PhantomData<S>);

    impl<S: LocalState + Clone> Plugin for LocalFlushMessagePlugin<S> {
        fn build(&self, app: &mut App) {
            app.add_message::<LocalStateFlushMessage<S>>();
            schedule_local_flush_message::<S>(app.get_schedule_mut(StateFlush).unwrap());
        }
    }

    impl<S: LocalState + Clone> Default for LocalFlushMessagePlugin<S> {
        fn default() -> Self {
            Self(PhantomData)
        }
    }
}

use bevy_ecs::{
    entity::Entity,
    message::{Message, MessageWriter},
    schedule::{IntoScheduleConfigs as _, Schedule},
    system::{Query, StaticSystemParam},
};

use crate::{
    access::FlushRef,
    next_state::{NextState, TriggerStateFlush},
    schedule::ResolveStateSystems,
    state::{LocalState, State},
};

/// A message written whenever the [`State`] type `S` flushes.
///
/// Added [by default](pyri_state_derive::State) by [`FlushMessagePlugin<S>`].
#[derive(Message)]
#[cfg_attr(feature = "bevy_reflect", derive(bevy_reflect::Reflect))]
pub struct StateFlushMessage<S: State> {
    /// The state before the flush, or `None` if disabled.
    pub old: Option<S>,
    /// The state after the flush, or `None` if disabled.
    pub new: Option<S>,
}

/// A message written whenever a local [`State`] type `S` flushes.
///
/// Added [by default](pyri_state_derive::State) by [`LocalFlushMessagePlugin<S>`].
#[derive(Message)]
#[cfg_attr(feature = "bevy_reflect", derive(bevy_reflect::Reflect))]
pub struct LocalStateFlushMessage<S: LocalState> {
    /// The entity for which the state flush occurred.
    pub entity: Entity,
    /// The state before the flush, or `None` if disabled.
    pub old: Option<S>,
    /// The state after the flush, or `None` if disabled.
    pub new: Option<S>,
}

fn write_flush_message<S: State + Clone>(
    state: FlushRef<S>,
    mut message: MessageWriter<StateFlushMessage<S>>,
) {
    let (old, new) = state.get();
    message.write(StateFlushMessage {
        old: old.cloned(),
        new: new.cloned(),
    });
}

/// Add a [`StateFlushMessage<S>`] writing system for the [`State`] type `S` to a schedule.
///
/// Used in [`FlushMessagePlugin<S>`].
pub fn schedule_flush_message<S: State + Clone>(schedule: &mut Schedule) {
    schedule.add_systems(write_flush_message::<S>.in_set(ResolveStateSystems::<S>::AnyFlush));
}

fn write_local_flush_message<S: LocalState + Clone>(
    next_param: StaticSystemParam<<S::Next as NextState>::Param>,
    state_query: Query<(Entity, Option<&S>, &S::Next, &TriggerStateFlush<S>)>,
    mut messages: MessageWriter<LocalStateFlushMessage<S>>,
) {
    for (entity, current, next, trigger) in &state_query {
        if !trigger.0 {
            continue;
        }

        messages.write(LocalStateFlushMessage {
            entity,
            old: current.cloned(),
            new: next.next_state(&next_param).cloned(),
        });
    }
}

/// Add a local [`StateFlushMessage<S>`] writing system for the [`State`] type `S` to a schedule.
///
/// Used in [`LocalFlushMessagePlugin<S>`].
pub fn schedule_local_flush_message<S: LocalState + Clone>(schedule: &mut Schedule) {
    schedule.add_systems(write_local_flush_message::<S>.in_set(ResolveStateSystems::<S>::Flush));
}