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

//! Use pattern-matching and run conditions to schedule state flush hooks.

use bevy::{input::common_conditions::input_just_pressed, prelude::*};
use pyri_state::prelude::*;

fn main() -> AppExit {
    App::new()
        .add_plugins((DefaultPlugins, StatePlugin))
        .insert_resource(StateDebugSettings {
            log_flush: true,
            ..default()
        })
        .init_state::<Level>()
        .init_resource::<LevelMeta>()
        .add_systems(
            StateFlush,
            (
                // Schedule the basic level teardown / setup.
                Level::ANY.on_edge(tear_down_old_level, load_new_level),
                // Level 10 is the final boss fight, so play boss music.
                Level(10).on_enter(play_boss_music),
                // Levels 4, 7, and 10 are checkpoints, so save progress.
                state!(Level(4 | 7 | 10)).on_enter(save_checkpoint),
                // Even numbered levels introduce new game mechanics.
                Level::with(|x| x.0 % 2 == 0).on_enter(spawn_tutorial_popup),
                // Spawn an easter egg for very specific level transitions.
                state!(Level(x @ (2 | 5..=8)) => y if y.0 == 10 - x).on_enter(spawn_easter_egg),
                // Play a sound effect when progressing to a later level.
                Level::when(|x, y| y.0 > x.0).on_enter(play_progress_sfx),
                // Randomly generate the next level before loading it, if necessary.
                Level::ANY.on_enter(generate_new_level.before(load_new_level).run_if(
                    |level: NextRef<Level>, meta: Res<LevelMeta>| !meta.generated[level.unwrap().0],
                )),
            ),
        )
        .add_systems(
            Update,
            (
                Level(1).enter().run_if(input_just_pressed(KeyCode::Digit1)),
                Level(2).enter().run_if(input_just_pressed(KeyCode::Digit2)),
                Level(3).enter().run_if(input_just_pressed(KeyCode::Digit3)),
                Level(4).enter().run_if(input_just_pressed(KeyCode::Digit4)),
                Level(5).enter().run_if(input_just_pressed(KeyCode::Digit5)),
                Level(6).enter().run_if(input_just_pressed(KeyCode::Digit6)),
                Level(7).enter().run_if(input_just_pressed(KeyCode::Digit7)),
                Level(8).enter().run_if(input_just_pressed(KeyCode::Digit8)),
                Level(9).enter().run_if(input_just_pressed(KeyCode::Digit9)),
                Level(10)
                    .enter()
                    .run_if(input_just_pressed(KeyCode::Digit0)),
            ),
        )
        .run()
}

#[derive(State, Reflect, Clone, PartialEq, Eq, Debug)]
#[state(log_flush)]
#[reflect(Resource)]
struct Level(usize);

impl Default for Level {
    fn default() -> Self {
        Self(1)
    }
}

#[derive(Resource, Reflect)]
#[reflect(Resource)]
struct LevelMeta {
    generated: Vec<bool>,
}

impl Default for LevelMeta {
    fn default() -> Self {
        Self {
            generated: vec![false; 11],
        }
    }
}

fn tear_down_old_level(_level: CurrentRef<Level>) {
    info!("tear_down_old_level")
}

fn load_new_level(_level: NextRef<Level>) {
    info!("load_new_level")
}

fn play_boss_music() {
    info!("play_boss_music");
}

fn play_progress_sfx() {
    info!("play_progress_sfx");
}

fn save_checkpoint() {
    info!("save_checkpoint");
}

fn spawn_tutorial_popup() {
    info!("spawn_tutorial_popup");
}

fn spawn_easter_egg() {
    info!("spawn_easter_egg");
}

fn generate_new_level(level: NextRef<Level>, mut meta: ResMut<LevelMeta>) {
    info!("generate_new_level");
    meta.generated[level.unwrap().0] = true;
}