fin for now

src/main.rs

@@ -1,7 +1,8 @@
 //#![allow(unused)]
 //use std::io;
 use std::fs;
-use toml::Table;
+use toml::{Table, Value};
+use std::collections::HashMap;
 
 fn print_type_of<T>(_: &T) {
     println!("{}", std::any::type_name::<T>());
@@ -9,6 +10,100 @@ fn print_type_of<T>(_: &T) {
 
 fn main() {
     let toml_str: String = fs::read_to_string("data.toml").expect("error");
-    let toml_data = toml_str.parse::<Table>().unwrap();
+    let mut toml_data = toml_str.parse::<Table>().unwrap();
-    println!("debug: {}",toml_data["base_bonuses"]["beans"]);
+    let mut throws = HashMap::new();
+    let mut skills = HashMap::new();
+
+    let binding = toml_data.clone();
+    //for whatever reason. if i dont have this as a var, and instead put toml_data.clone in the
+    //loop below, the throws.insert makes a borrow error. i dont get it
+    for (key,val) in &binding{
+        match key.as_str(){
+            "base_bonuses" => {
+                if let Some(base_bonuses) = val.as_table() {
+                    for (base_key, base_val) in base_bonuses {
+                        //toml_data["str"] = toml::Value::Integer(base_val);
+                        if let (Some(existing_num), Some(base_num)) = (toml_data[base_key].as_integer(), base_val.as_integer()) {
+                            toml_data[base_key] = Value::Integer(existing_num + base_num);
+                        }
+
+                    }
+                }
+                //   for (base_key, base_val) in val.as_table_mut().unwrap_or(&Default::default()) {
+                //   toml_data["str"] = Value::Integer(0);
+                //   }
+
+                //print_type_of(&val.get("base_bonuses"));
+            },
+            "base_modifiers" =>{
+                if let Some(base_modifiers) = val.as_table(){
+                    for(base_key, base_val) in base_modifiers{
+                        if let (Some(profiency), Some(base_num)) = (toml_data["profiency"].as_integer(), base_val.as_integer()) {
+                            if toml_data["prof_throws"]
+                                .as_array()
+                                    .map_or(false, |arr| arr.iter().any(|val2| val2.as_str().map_or(false, |s| s.contains(base_key))))
+                            {
+                                throws.insert(base_key,profiency + base_num);
+                            } else {
+                                throws.insert(base_key,base_num);
+                            }
+                        }
+                    }
+
+                }
+            },
+            "list" =>{
+                if let Some(list) = val.as_table(){
+                    if let Some(base_skills) = list["skills"].as_array(){
+                        for skill in base_skills{
+                            //make this cleaner
+                            if let (Some(skill_name),Some(skill_mod),Some(base_modifiers),Some(profiency),Some(skill_bonus)) = (skill[0].as_str(),skill[1].as_str(),toml_data["base_modifiers"].as_table(),toml_data["profiency"].as_integer(),toml_data["skill_prof_bonuses"].as_array()){
+
+                                let mut add_number=0;
+                                if toml_data["prof_skills"]
+                                    .as_array()
+                                        .map_or(false, |arr| arr.iter().any(|val2| val2.as_str().map_or(false, |s| s.contains(&String::from(skill_name)))))
+                                {
+                                    add_number = add_number + base_modifiers[skill_mod].as_integer().expect("none") + profiency;
+                                } else {
+                                    add_number = add_number + base_modifiers[skill_mod].as_integer().expect("none");
+                                }
+                                for bone in skill_bonus{
+                                    if skill_mod == bone[1].as_str().expect("none"){
+                                        add_number = add_number + base_modifiers[bone[0].as_str().expect("none")].as_integer().expect("none");
+                                    }
+                                }
+                                skills.insert(skill_name,add_number);
+                            }
+                        }
+                    }
+                }
+            }
+            _ => {},
+        }
+    }
+
+    //fin
+    for (key,val) in toml_data{
+        match key.as_str(){
+            "str" => println!("{}:{}",key,val),
+            "dex" => println!("{}:{}",key,val),
+            "consti" => println!("{}:{}",key,val),
+            "intell" => println!("{}:{}",key,val),
+            "wis" => println!("{}:{}",key,val),
+            "charis" => println!("{}:{}",key,val),
+            "profiency" => println!("{}:{}",key,val),
+            _ => {},
+        }
+    }
+    println!("-------");
+
+    for (key,val) in throws.iter(){
+        println!("throws: {}::{}",key,val);
+    }
+    println!("-------");
+
+    for (key,val) in skills.iter(){
+        println!("skills: {}::{}",key,val);
+    }
 }