UPD failure values

src/dice_roller/roller/fn_roll.rs

@@ -32,7 +32,12 @@ impl Roller {
                     };
                     successes.push(value);
                 } else {
-                    successes.push(0);
+                    let value = self.failure_values.get(x);
+                    let value = match value {
+                        None => 0_i8,
+                        Some(value) => *value,
+                    };
+                    successes.push(value);
                 }
             });
             sum = successes.iter().sum::<i8>() as i16;

src/dice_roller/roller/impl_from_str.rs

@@ -44,6 +44,9 @@ impl FromStr for Roller {
         // parsing success values
         let success_values_descriptor = Roller::parse_success_values(&descriptor);
 
+        // parsing failure values
+        let failure_values_descriptor = Roller::parse_failure_values(&descriptor);
+
         // output
         let descriptor: (u32, i32, Option<i32>) = match tokens.len() {
             2 => (
@@ -70,6 +73,7 @@ impl FromStr for Roller {
             .take_max(take_max_descriptor)
             .take_min(take_min_descriptor)
             .take_mid(take_mid_descriptor)
-            .add_success_values(success_values_descriptor))
+            .add_success_values(success_values_descriptor)
+            .add_failure_values(failure_values_descriptor))
     }
 }

src/dice_roller/roller/mod.rs

@@ -46,6 +46,9 @@ pub struct Roller {
 
     /// hash with success values
     success_values: HashMap<u8, i8>,
+
+    /// hash with failure values
+    failure_values: HashMap<u8, i8>,
 }
 
 impl Roller {
@@ -62,6 +65,7 @@ impl Roller {
             take_mid: None,
             rng: thread_rng(),
             success_values: HashMap::new(),
+            failure_values: HashMap::new(),
         }
     }
 
@@ -107,6 +111,18 @@ impl Roller {
         self
     }
 
+    fn add_failure_values(mut self, values: Option<Vec<(u8, i8)>>) -> Self {
+        if let Some(values) = values {
+            values.iter().for_each(|x| {
+                self.failure_values.insert(x.0, x.1);
+            });
+        } else {
+            self.failure_values.clear();
+        }
+
+        self
+    }
+
     fn parse_success_descriptor(descriptor: &str) -> Option<u32> {
         // sc handling
         let success_descriptor = descriptor
@@ -205,4 +221,28 @@ impl Roller {
 
         Some(success_values)
     }
+
+    fn parse_failure_values(descriptor: &str) -> Option<Vec<(u8, i8)>> {
+        let mut failure_values: Vec<(u8, i8)> = Vec::new();
+
+        descriptor
+            .split(&[' '])
+            .filter(|x| x.contains("fv"))
+            .map(|x| {
+                let tokens: Vec<_> = x.split(&[':']).collect();
+                (
+                    tokens[1].parse::<u8>().unwrap(),
+                    tokens[2].parse::<i8>().unwrap(),
+                )
+            })
+            .for_each(|x| {
+                failure_values.insert(0, x);
+            });
+
+        if failure_values.is_empty() {
+            return None;
+        }
+
+        Some(failure_values)
+    }
 }

src/dice_roller/roller/ts_parse.rs

@@ -100,6 +100,7 @@ fn success_values() {
     let r: super::Roller = String::from("3d6 sc5 sv:6:2").parse().unwrap();
     let value = r.success_values.get(&6);
     assert_eq!(value, Option::Some(&2));
+    assert_eq!(r.failure_values.len(), 0);
 }
 
 #[test]
@@ -109,4 +110,23 @@ fn multi_success_values() {
     assert_eq!(value, Option::Some(&1));
     let value = r.success_values.get(&6);
     assert_eq!(value, Option::Some(&2));
+    assert_eq!(r.failure_values.len(), 0);
+}
+
+#[test]
+fn failure_values() {
+    let r: super::Roller = String::from("3d6 sc5 fv:1:-1").parse().unwrap();
+    let value = r.failure_values.get(&1);
+    assert_eq!(value, Option::Some(&-1));
+    assert_eq!(r.success_values.len(), 0);
+}
+
+#[test]
+fn multi_failure_values() {
+    let r: super::Roller = String::from("3d6 sc5 fv:1:-2 fv:2:-1").parse().unwrap();
+    let value = r.failure_values.get(&1);
+    assert_eq!(value, Option::Some(&-2));
+    let value = r.failure_values.get(&2);
+    assert_eq!(value, Option::Some(&-1));
+    assert_eq!(r.success_values.len(), 0);
 }

src/dice_roller/roller/ts_roll.rs

@@ -252,3 +252,12 @@ fn success_values() {
     let roll_result = r.roll();
     assert_eq!(roll_result.outcome, 2);
 }
+
+#[test]
+fn failure_values() {
+    let mut r: super::Roller = String::from("d6 sc7 fv:1:-2 fv:2:-2 fv:3:-2 fv:4:-2 fv:5:-2 fv:6:-2 ")
+        .parse()
+        .unwrap();
+    let roll_result = r.roll();
+    assert_eq!(roll_result.outcome, -2);
+}