looping dmg

Cargo.toml

@@ -5,3 +5,5 @@ authors = ["ntr <ntr@smokestack.io>"]
 
 [dependencies]
 rand = "0.5.4"
+uuid = "0.6.5"
+serde_json = "1.0.24"

src/lib.rs

@@ -1,64 +1,91 @@
 extern crate rand;
+// extern crate serde_json;
 
 use rand::prelude::*;
 
-// items?
+#[derive(Debug,Clone)]
-// stranth + stam + intel + luck?
 struct Cryp {
-    name: String,
     dmg: u64,
     def: u64,
     stam: u64,
+    name: String,
 }
 
-pub struct Turn {
+struct Turn {
     dmg: u64,
     def: u64,
 }
 
-fn att_roll(rng: &mut ThreadRng, att: u64) -> u64 {
+// #[derive(Debug)]
+// pub struct Battle {
+//   cryps: Vec<Cryp>,
+// }
+
+fn att_roll(att: u64) -> u64 {
+    let mut rng = thread_rng();
     let roll: u64 = rng.gen();
-    println!("stat: {:b}", att);
-    println!("roll: {:b}", roll);
-    println!("outp: {:b}\n", att & roll);
     return att & roll;
 }
 
-fn cryp_turn(mut rng: &mut ThreadRng, c: Cryp) -> Turn {
+fn cryp_turn(c: &Cryp) -> Turn {
-    let dmg = att_roll(&mut rng, c.dmg);
+    let dmg = att_roll(c.dmg);
-    let def = att_roll(&mut rng, c.def);
+    let def = att_roll(c.def);
-    // att_roll(rng, c.stam);
+
+    println!("{:?}", c.name);
+    println!("dmg: {:b}", dmg);
+    println!("def: {:b}", def);
 
     return Turn { dmg, def }
 }
 
-fn battle(a: Cryp, b: Cryp) -> Vec<Turn> {
+fn assign_dmg(a: &Cryp, t: &Turn) -> Cryp {
-    let mut rng = thread_rng();
+  Cryp {
-    let mut turns = Vec::new();
+    dmg: a.dmg,
-
+    def: a.def,
-    turns.push(cryp_turn(&mut rng, a));
+    stam: match a.stam.checked_sub(t.dmg) {
-    turns.push(cryp_turn(&mut rng, b));
+      Some(v) => v,
-
+      None => 0,
-    return turns;
+    },
+    name: a.name.clone()
+  }
 }
 
-pub fn main() -> Vec<Turn> {
+fn combat_phase(a: Cryp, b: Cryp) -> (Cryp, Cryp) {
-    let a = Cryp {
+    let a_turn = cryp_turn(&a);
+    let b_turn = cryp_turn(&b);
+    return (
+      assign_dmg(&a, &b_turn),
+      assign_dmg(&b, &a_turn),
+    );
+}
+
+fn battle(a: Cryp, b: Cryp) -> (Cryp, Cryp) {
+    loop {
+        let combat = combat_phase(a.clone(), b.clone());
+        println!("{:?}", combat);
+        if combat.0.stam == 0 || combat.1.stam == 0 {
+          return combat;
+        }
+    }
+}
+
+pub fn main() {
+  let a = Cryp {
       name: "pronounced \"creeep\"".to_string(),
-      dmg: 213213213,
+      dmg: 10,
-      def: 129435899,
+      def: 5,
-      stam: 342687328,
+      stam: 5,
   };
 
   let b = Cryp {
       name: "lemongrass tea".to_string(),
-      dmg: 213213213,
+      dmg: 8,
-      def: 129435899,
+      def: 8,
-      stam: 342687328,
+      stam: 10,
   };
 
-
+  battle(a, b);
-  return battle(a, b);
+  return;
 }
 
 #[cfg(test)]