chainmailer 0.2.1

If You Do Not Send This Letter To Ten Recipients You Will Regret It
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
137
138
139
140
141
142
143
144
145
146

use bevy::prelude::*;
use rand::seq::{IteratorRandom, SliceRandom};
use tachyonfx::Shader;

use crate::{
    constants::{BLESSING_RANGE, CURSE_RANGE, DECOY_RANGE},
    interface::widgets::{letter::LetterWidgetState, prompt::Prompt},
    letters::{CurrentLetter, Flavor, LetterAssets, LetterBag, Name, TestimonialStub, WordBag},
    rng::RngResource,
    scene::spawning::WordCube,
    sound::SoundEffect,
};

pub(super) fn plugin(app: &mut App) {
    app.init_state::<GameStates>()
        .init_resource::<Statistics>()
        .add_observer(letter_cleared_observer)
        .add_observer(letter_failed_observer)
        .add_systems(
            OnEnter(GameStates::Printing),
            generate_current_letter_system,
        )
        .add_systems(
            Update,
            resetting_timer_system.run_if(in_state(GameStates::Resetting)),
        )
        .add_systems(OnEnter(GameStates::Resetting), clear_prompt_system)
        .add_systems(OnExit(GameStates::Resetting), clear_word_cubes_system);
}

#[derive(Default, States, Clone, Debug, Hash, Eq, PartialEq)]
pub enum GameStates {
    #[default]
    Loading,
    Info,
    Printing,
    Playing,
    Resetting,
}

#[derive(Event, Debug)]
pub struct LetterCleared;

#[derive(Event, Debug)]
pub struct LetterFailed;

#[derive(Resource, Default, Debug)]
pub struct Statistics {
    pub score: i32,
    pub money: i32,
    pub income: i32,
}

pub fn generate_current_letter_system(
    mut commands: Commands,
    mut letter_bag: ResMut<LetterBag>,
    letter_assets: Res<LetterAssets>,
    testimonials: Res<Assets<TestimonialStub>>,
    names: Res<Assets<Name>>,
    flavors: Res<Assets<Flavor>>,
    mut letter_widget_state: NonSendMut<LetterWidgetState>,
    mut rng: Local<RngResource>,
) {
    let blessing_amount = BLESSING_RANGE
        .choose(&mut rng.0)
        .expect("min blessing amount should not be higher than max");
    let curse_amount = CURSE_RANGE
        .choose(&mut rng.0)
        .expect("min curse amount should not be higher than max");
    let decoy_amount = DECOY_RANGE
        .choose(&mut rng.0)
        .expect("min decoy amount should not be higher than max");

    let decoys: Vec<_> = (0..decoy_amount)
        .map(|_| {
            let decoy_handle = letter_assets
                .decoys
                .choose(&mut rng.0)
                .expect("decoys list should not be empty")
                .clone();

            let decoy = testimonials.get(&decoy_handle).unwrap();

            decoy
                .message
                .split_whitespace()
                .nth(decoy.targets[0])
                .expect("target word index must be valid")
        })
        .collect();

    let letter = letter_bag.pull_letter(
        &testimonials,
        flavors,
        names,
        &mut rng.0,
        blessing_amount,
        curse_amount,
    );

    commands.trigger(SoundEffect::Window);
    commands.insert_resource(WordBag::new(
        &letter.blessings,
        &letter.curses,
        &decoys,
        &mut rng.0,
    ));
    commands.insert_resource(CurrentLetter(letter));
    *letter_widget_state = LetterWidgetState::default();
}

pub fn letter_cleared_observer(
    _trigger: Trigger<LetterCleared>,
    mut commands: Commands,
    mut stats: ResMut<Statistics>,
) {
    stats.money += stats.income;
    commands.trigger(SoundEffect::LetterClear);
    commands.set_state(GameStates::Resetting);
}

pub fn letter_failed_observer(_trigger: Trigger<LetterFailed>, mut commands: Commands) {
    commands.trigger(SoundEffect::LetterFail);
    commands.set_state(GameStates::Resetting);
}

pub fn resetting_timer_system(
    mut commands: Commands,
    mut current_letter_state: NonSendMut<LetterWidgetState>,
) {
    if let Some(timer) = current_letter_state.effect.timer_mut() {
        if timer.done() {
            commands.set_state(GameStates::Printing);
        }
    }
}

fn clear_prompt_system(mut prompt: ResMut<Prompt>) {
    prompt.text = "".into();
}

fn clear_word_cubes_system(mut commands: Commands, word_cubes: Query<Entity, With<WordCube>>) {
    for entity in &word_cubes {
        commands.entity(entity).despawn();
    }
}