numples 1.2.0

Yet another colourful sudoku playing game.
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

use bevy::input::keyboard::{Key, KeyboardInput};
use bevy::prelude::*;

use crate::consts::{BACKGROUND_COLOR, WIN_COLOR};
use crate::game::{Colors, Cursor};
use crate::gameplay::{BGFlag, ClockDisplay, Gameplay};
use crate::states::GameState;

#[derive(Debug, Clone, Resource)]
pub struct GameOverCheck(pub bool);

#[derive(Debug, Clone, Copy)]
pub struct GameOverPlugin;

impl Plugin for GameOverPlugin {
    fn build(&self, app: &mut App) {
        app
            .add_systems(OnEnter(GameState::GameOver), GameOver::load)
            .add_systems(OnExit(GameState::GameOver), GameOver::unload)
            .add_systems(
                Update,
                GameOver::keybinding.run_if(in_state(GameState::GameOver)),
            )
        ;
    }
}

#[derive(Debug, Clone, Copy, Component)]
struct GameOver;

impl GameOver {

    fn load(
        mut commands: Commands,
        mut bg_query: Query<&mut BackgroundColor>,
        mut fg_query: Query<&mut MeshMaterial2d<ColorMaterial>, With<BGFlag>>,
        mut clock: Single<&mut Visibility, With<ClockDisplay>>,
        cursor: Single<Entity, With<Cursor>>,
        colors: Res<Colors>,
    ) {
        commands.entity(*cursor).despawn();
        **clock = Visibility::Visible;
        for mut color in &mut bg_query {
            color.0 = WIN_COLOR.clone();
        }
        for mut color in &mut fg_query {
            color.0 = colors.win().clone_weak();
        }
    }

    fn unload(
        mut commands: Commands,
        mut query: Query<Entity, With<Gameplay>>,
        mut bg_query: Query<&mut BackgroundColor>,
    ) {
        for mut color in &mut bg_query {
            color.0 = BACKGROUND_COLOR.clone();
        }
        for entity in query.iter_mut() {
            commands.entity(entity).despawn();
        }
    }


    fn keybinding(
        mut keyboard: EventReader<KeyboardInput>,
        mut next_state: ResMut<NextState<GameState>>,
    ) {
        for (input, _) in keyboard.par_read() {
            if input.state.is_pressed() && !input.repeat {
                match input.logical_key {
                    Key::Escape => {
                        next_state.set(GameState::Title);
                        return;
                    },
                    _ => (),
                }
            }
        }
    }}