update for new Boot Types

Author: CodingDepot

src/constants.rs

@@ -1,5 +1,5 @@
 pub const BOOT_IDS: [(f32, &str); 8] = [
-    (1001., "Boots"),
+    (1001., "Boots"),   // Placeholder for no T2 boots, also result for Cassiopeia
     (3006., "Berserker's Greaves"),
     (3009., "Boots of Swiftness"),
     (3020., "Sorcerer's Shoes"),
@@ -8,4 +8,8 @@ pub const BOOT_IDS: [(f32, &str); 8] = [
     (3117., "Mobility Boots"),
     (3158., "Ionian Boots of Lucidity"),
 ];
-pub const MAPPING_FILE: &str = "snowflake_puuid.txt";
+pub const MAPPING_FILE: &str = "snowflake_puuid.txt";
+
+pub const REPLACEMENTS: [(f32, f32); 1] = [
+    (3172., 3006.),  // Treat every Zephyr as Berserker's Greaves
+];

src/prediction.rs

@@ -12,7 +12,7 @@ use self::data::get_current_match_data;
 pub mod data;
 
 const MODEL_FILE_NAME: &str = "model.bin";
-const GOETHE: &str = "qan7meW9JWz1XI1nmZ8yD000EXpxLGkSbirRVPaRjCwcr9WeIcg32KQOTtJV71OEyov3LwCnRq5o5Q";
+const GOETHE: &str = "C07uW6f7a9Gkj5nMkqsT-idkHGwc76DaX-fLAryZZOksdXob2bY5NDtG3j6SD7YsS3-N8x6X25z2JQ";
 
 fn predict_one(model: &DecisionTree<f32, String>, data: &Array1<f32>) -> String {
     let data_boxed: Array2<f32> = data.clone().into_shape((1, 13)).unwrap();
@@ -41,7 +41,16 @@ fn create_dataset(data: &Array2<f32>) -> DatasetBase<ArrayBase<OwnedRepr<f32>, D
 
     // create actual dataset (maps ids to String representation)
     let dataset = Dataset::new(features, labels)
-        .map_targets(|x| crate::constants::BOOT_IDS.iter().filter(|b| &b.0 == x).nth(0).map(|x| x.1).unwrap_or("No Boots").to_string())
+        .map_targets(
+            |x|
+            crate::constants::BOOT_IDS
+                .iter()
+                .filter(|b| &b.0 == x)
+                .nth(0)
+                .map(|x| x.1)
+                .unwrap_or("No Boots")
+                .to_string()
+        )
         .with_feature_names(feature_names);
 
     dataset
@@ -92,7 +101,7 @@ pub fn recreate_model(game_count: usize) {
         .expect("Could not fetch the Riot token");
     let base_path = env::var("CONFIG_PATH").unwrap_or(String::new());
     let snowflake_map = create_snowflake_puuid_map(&format!("{}{}", base_path, crate::constants::MAPPING_FILE));
-    let test_puuid = snowflake_map.values().filter(|id| id.starts_with("f7Xz")).nth(0).unwrap().clone();
+    let test_puuid = snowflake_map.values().filter(|id| id.starts_with("UtnLP")).nth(0).unwrap().clone();
 
     // Train a new model
     let start_time = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();

src/prediction/data.rs

@@ -6,7 +6,7 @@ use std::io::Write;
 use std::time::Duration;
 use std::thread::sleep;
 
-use crate::constants::BOOT_IDS;
+use crate::constants::{BOOT_IDS, REPLACEMENTS};
 
 const PAST_GAMES: u32 = 20;
 const DEFAULT_RETRY_TIME: u64 = 40;
@@ -259,10 +259,22 @@ fn prepare_training_data(games: Vec<Value>) -> Array2<f32> {
         // Add one data row for each participant
         for i in 0..participants.len() {
             let player: &Value = &participants[i];
-            let enemies: Vec<&Value> = participants.iter().filter(|p| p.get("teamId").unwrap() != player.get("teamId").unwrap()).collect();
+            let enemies: Vec<&Value> = participants
+                .iter()
+                .filter(
+                    |p|
+                    p.get("teamId").unwrap() != player.get("teamId").unwrap()
+                )
+                .collect();
 
-            let enemy_champs: Vec<f32> = enemies.iter()
-                .map(|e| from_value::<f32>(e.get("championId").unwrap().clone()).unwrap()).collect();
+            let enemy_champs: Vec<f32> = enemies
+                .iter()
+                .map(
+                    |e| from_value::<f32>(
+                        e.get("championId").unwrap().clone()
+                    ).unwrap()
+                )
+                .collect();
 
 
             let enemy_trees: Vec<f32> = enemies.iter()
@@ -278,7 +290,13 @@ fn prepare_training_data(games: Vec<Value>) -> Array2<f32> {
                 player_items.push(from_value::<f32>(player.get(format!("item{}", i)).unwrap().clone()).unwrap());
             }
             let boot_ids: Vec<f32> = BOOT_IDS.iter().map(|i| i.0).collect();
-            let player_boots: f32 = player_items.iter().filter(|item| boot_ids.contains(item)).nth(0).unwrap_or(&1001.).clone();
+            let player_boots: f32 = player_items
+                .iter()
+                .map(preprocess)
+                .filter(|item| boot_ids.contains(item))
+                .nth(0)
+                .unwrap_or(&1001.)
+                .clone();
 
             let mut entry: Vec<f32> = vec![
                 player_champ,
@@ -373,3 +391,13 @@ fn print_loading_bar(progress: usize, total: usize, duplicates: usize) {
     // Flush the output to make the progress visible without newline
     let _ = std::io::stdout().flush();
 }
+
+fn preprocess(item: &f32) -> &f32 {
+    // Currently only one step: replace any specified items
+    let replacements: Vec<&(f32, f32)> = REPLACEMENTS.iter().collect();
+    replacements
+        .iter()
+        .find(|r| &r.0 == item)
+        .map(|r| &r.1)
+        .unwrap_or(item)
+}