Implement loading of cube data from JSON file

rc_services_room/src/persist/config/cubes.rs

@@ -0,0 +1,347 @@
+use std::collections::HashMap;
+
+use serde::{Serialize, Deserialize};
+
+use polariton::operation::{Typed, Dict};
+use polariton::serdes::TypePrefix;
+
+use super::{MovementCategoryData, MovementData, WeaponData};
+
+const CUBE_CONFIG_FILENAME: &str = "cubes.json";
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct CubeConfig {
+    cubes: HashMap<String, Cube>,
+    movement: HashMap<ItemCategory, MovementCategoryData>,
+    lerp_value: f32,
+}
+
+impl CubeConfig {
+    pub fn load(root: impl AsRef<std::path::Path>) -> std::io::Result<Self> {
+        let file = std::fs::File::open(root.as_ref().join(CUBE_CONFIG_FILENAME))?;
+        let buffered = std::io::BufReader::new(file);
+        let result = serde_json::from_reader(buffered)?;
+        Ok(result)
+    }
+
+    pub fn cube_list<C: Clone>(&self) -> Typed<C> {
+        Typed::Dict(Dict {
+            key_ty: TypePrefix::Str,
+            val_ty: TypePrefix::HashMap,
+            items: self.cubes.values().map(|cube| {
+                let cube_d: crate::data::cube_list::CubeInfo<C> = cube.info.clone().into();
+                cube_d.as_transmissible_key_val(cube.id)
+            }).collect(),
+        })
+    }
+
+    pub fn movement_list<C: Clone>(&self) -> Typed<C> {
+        let mut movements_stats = HashMap::<ItemCategory, HashMap<ItemTier, MovementData>>::new();
+        for cube in self.cubes.values() {
+            if let Some(movement_data) = &cube.movement {
+                let category_map = if let Some(x) = movements_stats.get_mut(&cube.info.category) {
+                    x
+                } else {
+                    movements_stats.insert(cube.info.category, HashMap::new());
+                    movements_stats.get_mut(&cube.info.category).unwrap()
+                };
+                category_map.insert(cube.info.size, movement_data.to_owned());
+            }
+        }
+        let mut movement_cat_stats = Vec::with_capacity(self.movement.len());
+        for (k, v) in self.movement.iter() {
+            let stats: Vec<_> = if let Some(stats) = movements_stats.get(&k) {
+                stats.iter().map(|(k, v)| (k.to_owned(), v.to_owned())).collect()
+            } else {
+                Vec::default()
+            };
+            let key: crate::data::weapon_list::ItemCategory = k.to_owned().into();
+            let key_typed = Typed::<C>::Str(key.as_str().into());
+
+            let value_data = v.to_owned().into_data(stats);
+            movement_cat_stats.push((key_typed, value_data.as_transmissible()));
+        }
+        Typed::Dict(Dict {
+            key_ty: TypePrefix::Str,
+            val_ty: TypePrefix::HashMap,
+            items: vec![
+                (Typed::Str("Global".into()), Typed::HashMap(vec![
+                    (Typed::Str("lerpValue".into()), Typed::Float(self.lerp_value)),
+                ].into())),
+                (Typed::Str("Movements".into()), Typed::HashMap(movement_cat_stats.into())),
+            ],
+        })
+    }
+
+    pub fn weapon_list<C: Clone>(&self) -> Typed<C> {
+        let mut weapon_stats = HashMap::new();
+        for cube in self.cubes.values() {
+            if let Some(weapon_data) = &cube.weapon {
+                let category_map = if let Some(x) = weapon_stats.get_mut(&cube.info.category) {
+                    x
+                } else {
+                    weapon_stats.insert(cube.info.category, HashMap::new());
+                    weapon_stats.get_mut(&cube.info.category).unwrap()
+                };
+                category_map.insert(cube.info.size, weapon_data.to_owned());
+            }
+        }
+        let mut weapons_vec: Vec<(Typed<C>, Typed<C>)> = Vec::with_capacity(weapon_stats.len());
+        for (k, v) in weapon_stats {
+            let cat_data: crate::data::weapon_list::ItemCategory = k.into();
+            let mut tiers_vec = Vec::with_capacity(v.len());
+            for (k, v) in v {
+                let tier_data: crate::data::cube_list::ItemTier = k.into();
+                let val_data: crate::data::weapon_list::WeaponData = v.into();
+                tiers_vec.push((Typed::Str(tier_data.as_str().into()), val_data.as_transmissible()));
+            }
+            weapons_vec.push((Typed::Str(cat_data.as_str().into()), Typed::HashMap(tiers_vec.into())));
+        }
+        Typed::Dict(Dict {
+            key_ty: TypePrefix::Str,
+            val_ty: TypePrefix::HashMap,
+            items: weapons_vec,
+        })
+    }
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug)]
+pub struct Cube {
+    pub id: u32,
+    pub info: CubeInfo,
+    pub weapon: Option<WeaponData>,
+    pub movement: Option<MovementData>,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug)]
+pub struct CubeInfo {
+    #[serde(default = "default_1")]
+    pub cpu: u32,
+    #[serde(default = "default_1")]
+    pub health: u32,
+    #[serde(default = "default_1_0")]
+    pub health_boost: f32,
+    #[serde(default)]
+    pub grey_out_in_tutorial: bool,
+    #[serde(default)]
+    pub visibility: VisibilityMode,
+    #[serde(default)]
+    pub indestructible: bool,
+    #[serde(default)]
+    pub category: ItemCategory,
+    #[serde(default = "default_63")]
+    pub placements: u32,
+    #[serde(default)]
+    pub protonium: bool,
+    #[serde(default)]
+    pub unlocked_by_league: bool,
+    #[serde(default)]
+    pub league_unlock_index: i32,
+    pub stats: HashMap<String, serde_json::Value>,
+    pub description: String,
+    pub size: ItemTier,
+    #[serde(rename = "type", alias = "type_")]
+    pub type_: ItemType,
+    #[serde(default)]
+    pub ranking: i32,
+    #[serde(default)]
+    pub cosmetic: bool,
+    #[serde(default)]
+    pub variant_of: u32, // cube id (in hex)
+    #[serde(default = "default_true")]
+    pub ignore_in_weapon_list: bool,
+}
+
+fn default_1() -> u32 {
+    1
+}
+
+fn default_1_0() -> f32 {
+    1.0
+}
+
+fn default_63() -> u32 {
+    63
+}
+
+fn default_true() -> bool {
+    true
+}
+
+impl <C: Clone> std::convert::Into<crate::data::cube_list::CubeInfo<C>> for CubeInfo {
+    fn into(self) -> crate::data::cube_list::CubeInfo<C> {
+        crate::data::cube_list::CubeInfo {
+            cpu: self.cpu,
+            health: self.health,
+            health_boost: self.health_boost,
+            grey_out_in_tutorial: self.grey_out_in_tutorial,
+            visibility: self.visibility.into(),
+            indestructible: self.indestructible,
+            category: self.category.into(),
+            placements: self.placements, // default 63
+            protonium: self.protonium,
+            unlocked_by_league: self.unlocked_by_league,
+            league_unlock_index: self.league_unlock_index,
+            stats: self.stats.into_iter().map(|(k, v)| {
+                let new_v = match v {
+                    serde_json::Value::Bool(b) => Typed::Bool(b),
+                    serde_json::Value::Number(n) => if let Some(n_i64) = n.as_i64() {
+                        Typed::Long(n_i64)
+                    } else if let Some(n_f64) = n.as_f64() {
+                        Typed::Double(n_f64)
+                    } else {
+                        panic!("Invalid json number")
+                    },
+                    serde_json::Value::String(s) => Typed::Str(s.into()),
+                    _ => Typed::Null, // TODO is support for Object/Array/Null necessary?
+                };
+                (k, new_v)
+            }).collect(),
+            description: self.description,
+            size: self.size.into(),
+            type_: self.type_.into(),
+            ranking: self.ranking,
+            cosmetic: self.cosmetic,
+            variant_of: hex::encode(self.variant_of.to_be_bytes()).into(),
+            ignore_in_weapon_list: self.ignore_in_weapon_list,
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize, Clone, Copy, Debug, Default)]
+pub enum VisibilityMode {
+    Mothership,
+    #[default]
+    All,
+    Tutorial,
+    None,
+}
+
+impl std::convert::Into<crate::data::cube_list::VisibilityMode> for VisibilityMode {
+    fn into(self) -> crate::data::cube_list::VisibilityMode {
+        match self {
+            Self::Mothership => crate::data::cube_list::VisibilityMode::Mothership,
+            Self::All => crate::data::cube_list::VisibilityMode::All,
+            Self::Tutorial => crate::data::cube_list::VisibilityMode::Tutorial,
+            Self::None => crate::data::cube_list::VisibilityMode::None,
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize, Clone, Copy, Debug, Default, Hash, PartialEq, Eq)]
+pub enum ItemTier {
+    #[default]
+    NoTier = 0,
+    T0 = 100,
+    T1 = 200,
+    T2 = 300,
+    T3 = 400,
+    T4 = 500,
+    T5 = 600,
+}
+
+impl std::convert::Into<crate::data::cube_list::ItemTier> for ItemTier {
+    fn into(self) -> crate::data::cube_list::ItemTier {
+        match self {
+            Self::NoTier => crate::data::cube_list::ItemTier::NoTier,
+            Self::T0 => crate::data::cube_list::ItemTier::T0,
+            Self::T1 => crate::data::cube_list::ItemTier::T1,
+            Self::T2 => crate::data::cube_list::ItemTier::T2,
+            Self::T3 => crate::data::cube_list::ItemTier::T3,
+            Self::T4 => crate::data::cube_list::ItemTier::T4,
+            Self::T5 => crate::data::cube_list::ItemTier::T5,
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize, Clone, Copy, Debug, Default)]
+pub enum ItemType {
+    #[default]
+    NotAFunctionalItem,
+    Weapon,
+    Module,
+    Movement,
+    Cosmetic,
+}
+
+impl std::convert::Into<crate::data::cube_list::ItemType> for ItemType {
+    fn into(self) -> crate::data::cube_list::ItemType {
+        match self {
+            Self::NotAFunctionalItem => crate::data::cube_list::ItemType::NoFunction,
+            Self::Weapon => crate::data::cube_list::ItemType::Weapon,
+            Self::Module => crate::data::cube_list::ItemType::Module,
+            Self::Movement => crate::data::cube_list::ItemType::Movement,
+            Self::Cosmetic => crate::data::cube_list::ItemType::Cosmetic,
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize, Clone, Copy, Debug, Default, Hash, PartialEq, Eq)]
+pub enum ItemCategory {
+    #[default]
+    NotAFunctionalItem = 0,
+    Wheel = 1,
+    Hover = 2,
+    Wing = 3,
+    Rudder = 4,
+    Thruster = 5,
+    InsectLeg = 6,
+    MechLeg = 7,
+    Ski = 8,
+    TankTrack = 9,
+    Rotor = 10,
+    SprinterLeg = 11,
+    Propeller = 12,
+    Laser = 100,
+    Plasma = 200,
+    Mortar = 250,
+    Rail = 300,
+    Nano = 400,
+    Tesla = 500,
+    Aeroflak = 600,
+    Ion = 650,
+    Seeker = 701,
+    Chaingun = 750,
+    ShieldModule = 800,
+    GhostModule = 801,
+    BlinkModule = 802,
+    EmpModule = 803,
+    WindowmakerModule = 804,
+    EnergyModule = 900,
+}
+
+impl std::convert::Into<crate::data::weapon_list::ItemCategory> for ItemCategory {
+    fn into(self) -> crate::data::weapon_list::ItemCategory {
+        match self {
+            Self::NotAFunctionalItem => crate::data::weapon_list::ItemCategory::NoFunction,
+            Self::Wheel => crate::data::weapon_list::ItemCategory::Wheel,
+            Self::Hover => crate::data::weapon_list::ItemCategory::Hover,
+            Self::Wing => crate::data::weapon_list::ItemCategory::Wing,
+            Self::Rudder => crate::data::weapon_list::ItemCategory::Rudder,
+            Self::Thruster => crate::data::weapon_list::ItemCategory::Thruster,
+            Self::InsectLeg => crate::data::weapon_list::ItemCategory::InsectLeg,
+            Self::MechLeg => crate::data::weapon_list::ItemCategory::MechLeg,
+            Self::Ski => crate::data::weapon_list::ItemCategory::Ski,
+            Self::TankTrack => crate::data::weapon_list::ItemCategory::TankTrack,
+            Self::Rotor => crate::data::weapon_list::ItemCategory::Rotor,
+            Self::SprinterLeg => crate::data::weapon_list::ItemCategory::SprinterLeg,
+            Self::Propeller => crate::data::weapon_list::ItemCategory::Propeller,
+            Self::Laser => crate::data::weapon_list::ItemCategory::Laser,
+            Self::Plasma => crate::data::weapon_list::ItemCategory::Plasma,
+            Self::Mortar => crate::data::weapon_list::ItemCategory::Mortar,
+            Self::Rail => crate::data::weapon_list::ItemCategory::Rail,
+            Self::Nano => crate::data::weapon_list::ItemCategory::Nano,
+            Self::Tesla => crate::data::weapon_list::ItemCategory::Tesla,
+            Self::Aeroflak => crate::data::weapon_list::ItemCategory::Aeroflak,
+            Self::Ion => crate::data::weapon_list::ItemCategory::Ion,
+            Self::Seeker => crate::data::weapon_list::ItemCategory::Seeker,
+            Self::Chaingun => crate::data::weapon_list::ItemCategory::Chaingun,
+            Self::ShieldModule => crate::data::weapon_list::ItemCategory::ShieldModule,
+            Self::GhostModule => crate::data::weapon_list::ItemCategory::GhostModule,
+            Self::BlinkModule => crate::data::weapon_list::ItemCategory::BlinkModule,
+            Self::EmpModule => crate::data::weapon_list::ItemCategory::EmpModule,
+            Self::WindowmakerModule => crate::data::weapon_list::ItemCategory::WindowmakerModule,
+            Self::EnergyModule => crate::data::weapon_list::ItemCategory::EnergyModule,
+        }
+    }
+}