feat: new type of challenge: symbols, plus some refatcoring to make i…

…t easier to add challenges

src/random/letters.rs

@@ -0,0 +1,26 @@
+use rand::Rng;
+
+pub fn random_letters_inner(max: u32) -> String {
+    let mut rng = rand::thread_rng();
+    let mut s: String = "".into();
+    for _i in 0..max {
+        let letter: char = rng.gen_range(b'A'..=b'Z') as char;
+        let manipulated = big_small_space(letter);
+        s.push(manipulated)
+    }
+    s.trim().to_owned()
+}
+
+fn big_small_space(letter: char) -> char {
+    let mut rng = rand::thread_rng();
+    let lr = rng.gen_range(0..3);
+    match lr {
+        0 => letter,
+        1 => {
+            let chars: Vec<char> = letter.to_lowercase().to_string().chars().collect();
+            chars[0]
+        }
+        2 => ' ',
+        _ => letter,
+    }
+}

src/random/mod.rs

@@ -1,51 +1,58 @@
-use rand::Rng;
-
-use self::sentences::random_sentence;
-
-pub mod sentences;
-
-pub fn random_letters(max: u32) -> String {
-    let mut rng = rand::thread_rng();
-    let mut s: String = "".into();
-    for _i in 0..max {
-        let letter: char = rng.gen_range(b'A'..=b'Z') as char;
-        let manipulated = big_small_space(letter);
-        s.push(manipulated)
-    }
-    s.trim().to_string()
-}
-
-fn big_small_space(letter: char) -> char {
-    let mut rng = rand::thread_rng();
-    let lr = rng.gen_range(0..3);
-    match lr {
-        0 => letter,
-        1 => {
-            let chars: Vec<char> = letter.to_lowercase().to_string().chars().collect();
-            chars[0]
-        }
-        2 => ' ',
-        _ => letter,
-    }
+use self::{
+    letters::random_letters_inner, sentences::random_english_sentences, symbols::random_symbols,
+    words::random_english_words,
+};
+
+mod letters;
+mod sentences;
+mod symbols;
+mod words;
+
+#[derive(Clone, Copy)]
+pub struct Algorithm {
+    pub id: &'static str,
+    pub version: &'static str,
+    pub description: &'static str,
+    pub lang: &'static str,
+    pub out_size: &'static u32,
+    pub random_function: &'static dyn Fn(u32) -> String,
 }
 
-pub fn random_english_words(max: u32) -> String {
-    let mut random_words = String::new();
-    for _i in 0..max {
-        random_words.push_str(random_word::gen());
-        random_words.push_str(&' '.to_string());
-    }
-
-    random_words.trim_end().into()
-}
-
-pub fn random_english_sentences(max: u32) -> String {
-    let mut new_string = String::new();
-    let new_max = if max > 20 { max / 2 } else { max };
-
-    for _i in 0..new_max {
-        new_string.push_str(&random_sentence());
-    }
-
-    new_string.trim().into()
+pub const ALGS: [Algorithm; 4] = [
+    Algorithm {
+        id: "letters",
+        version: "0.1",
+        description: "some letters :)",
+        lang: "human",
+        out_size: &1,
+        random_function: &random_letters_inner,
+    },
+    Algorithm {
+        id: "words",
+        version: "0.1",
+        description: "some english words",
+        lang: "eng",
+        out_size: &2,
+        random_function: &random_english_words,
+    },
+    Algorithm {
+        id: "sentences",
+        version: "0.1",
+        description: "some english sentences",
+        lang: "eng",
+        out_size: &3,
+        random_function: &random_english_sentences,
+    },
+    Algorithm {
+        id: "symbols",
+        version: "0.1",
+        description: "some symbols",
+        lang: "well not really human",
+        out_size: &2,
+        random_function: &random_symbols,
+    },
+];
+
+pub fn none(_max: u32) -> String {
+    "this algorithm does not exist".to_owned()
 }

src/random/sentences.rs

@@ -2,6 +2,17 @@ use rand::{seq::IteratorRandom, thread_rng};
 
 //He (subject) obtained (verb) his degree (object
 
+pub fn random_english_sentences(max: u32) -> String {
+    let mut new_string = String::new();
+    let new_max = if max > 20 { max / 2 } else { max };
+
+    for _i in 0..new_max {
+        new_string.push_str(&random_sentence());
+    }
+
+    new_string.trim().into()
+}
+
 fn random_sub() -> Option<String> {
     let mut rng = thread_rng();
     let subs = ["He", "She", "I", "They", "We"];

src/random/symbols.rs

@@ -0,0 +1,41 @@
+use rand::Rng;
+
+pub fn random_symbols(max: u32) -> String {
+    let mut s: String = "".into();
+    for _i in 0..max {
+        let letter: char = some_symbol();
+        let manipulated = letter_or_space(letter);
+        s.push(manipulated)
+    }
+    s.trim().to_owned()
+}
+
+fn letter_or_space(letter: char) -> char {
+    let mut rng = rand::thread_rng();
+    let lr = rng.gen_range(0..1);
+    match lr {
+        0 => letter,
+        1 => ' ',
+        _ => letter,
+    }
+}
+
+fn some_symbol() -> char {
+    let mut rng = rand::thread_rng();
+    let lr = rng.gen_range(0..11);
+    match lr {
+        0 => '{',
+        1 => '}',
+        2 => '.',
+        3 => ',',
+        4 => ';',
+        5 => '-',
+        6 => '_',
+        7 => '[',
+        8 => ']',
+        9 => '!',
+        10 => '(',
+        11 => ')',
+        _ => ' ',
+    }
+}

src/random/words.rs

@@ -0,0 +1,9 @@
+pub fn random_english_words(max: u32) -> String {
+    let mut random_words = String::new();
+    for _i in 0..max {
+        random_words.push_str(random_word::gen());
+        random_words.push_str(&' '.to_string());
+    }
+
+    random_words.trim_end().into()
+}

src/scoring/mod.rs

@@ -13,6 +13,6 @@ impl Score {
     }
 
     pub fn won(&mut self, settings: &TFSetting) {
-        self.score += settings.level.score(settings.size) as u128;
+        self.score += (settings.level.out_size * settings.size) as u128;
     }
 }

src/settings/mod.rs

@@ -1,48 +1,22 @@
 use egui::Ui;
 
-use crate::random::{random_english_sentences, random_english_words, random_letters};
+use crate::random::{none, Algorithm, ALGS};
 
 #[derive(serde::Deserialize, serde::Serialize)]
 #[serde(default)] // if we add new fields, give them default values when deserializing old state
 pub struct TFSetting {
     pub command: String,
-    pub level: Level,
+    #[serde(skip)]
+    pub level: Algorithm,
     pub size: u32,
     last_command: String,
 }
 
-#[derive(serde::Deserialize, serde::Serialize, PartialEq, Eq)]
-pub enum Level {
-    Letters,
-    EnglishWords,
-    EnglishSentences,
-}
-
-impl Level {
-    fn as_str(&self) -> &'static str {
-        match self {
-            Level::Letters => "Letters",
-            Level::EnglishWords => "English words",
-            Level::EnglishSentences => "English sentences",
-        }
-    }
-
-    pub fn score(&self, size: u32) -> u32 {
-        let modifier = match self {
-            Level::Letters => 1,
-            Level::EnglishWords => 3,
-            Level::EnglishSentences => 5,
-        };
-
-        modifier * size
-    }
-}
-
 impl Default for TFSetting {
     fn default() -> Self {
         Self {
             command: Default::default(),
-            level: Level::Letters,
+            level: ALGS[0],
             size: 2,
             last_command: Default::default(),
         }
@@ -58,7 +32,7 @@ impl TFSetting {
                 ui.label(self.last_command.clone());
                 ui.label("|-|");
                 ui.label("level");
-                ui.label(self.level.as_str());
+                ui.label(self.level.description);
                 ui.label("|-|");
                 ui.label("size");
                 ui.label(format!("{}", self.size));
@@ -75,29 +49,28 @@ impl TFSetting {
         }
 
         if command.contains("level") {
-            if command.contains("letters;") {
-                self.change_level(Level::Letters);
-            }
-            if command.contains("words;") {
-                self.change_level(Level::EnglishWords);
-            }
-            if command.contains("sentences;") {
-                self.change_level(Level::EnglishSentences);
-            }
+            let new_level = match ALGS.into_iter().find(|alg| command.contains(alg.id)) {
+                Some(alg) => alg,
+                None => Algorithm {
+                    id: "None",
+                    version: "0",
+                    description: "this algorithm does not exist",
+                    lang: "mhh",
+                    out_size: &0,
+                    random_function: &none,
+                },
+            };
+            self.change_level(new_level)
         }
     }
+
     pub fn command_helpers(&mut self, ui: &mut Ui) {
         ui.spacing_mut().item_spacing.x = 0.5;
-        if ui.button("level letters").clicked() {
-            self.command = "level letters".into();
-        }
 
-        if ui.button("level words").clicked() {
-            self.command = "level words".into();
-        }
-
-        if ui.button("level sentences").clicked() {
-            self.command = "level sentences".into();
+        for alg in ALGS {
+            if ui.button(alg.description).clicked() {
+                self.command = "level".to_owned() + " " + alg.id
+            }
         }
 
         if ui.button("run command").clicked() {
@@ -107,16 +80,14 @@ impl TFSetting {
         ui.add(egui::DragValue::new(&mut self.size));
     }
 
+    #[allow(clippy::let_and_return)]
     pub fn provide_next_string(&self) -> String {
-        match self.level {
-            Level::Letters => random_letters(self.size),
-            Level::EnglishWords => random_english_words(self.size),
-            Level::EnglishSentences => random_english_sentences(self.size),
-        }
+        let next = (self.level.random_function)(self.size);
+        next
     }
 
-    pub fn change_level(&mut self, new_level: Level) {
-        if !self.level.eq(&new_level) {
+    pub fn change_level(&mut self, new_level: Algorithm) {
+        if !self.level.id.eq(new_level.id) {
             self.size = 2;
         }
         self.level = new_level