combat module:

src/combat.rs

@@ -0,0 +1,159 @@
+use rand::prelude::*;
+use cryp::Cryp;
+
+struct Turn {
+  dmg: Roll,
+  def: Roll,
+}
+
+#[derive(Debug)]
+enum Attribute {
+  Dmg,
+  Def,
+}
+
+// impl Attribute {
+//   pub fn as_str(&self) -> &'static str {
+//     match self {
+//         Dmg => "dmg",
+//         Def => "def",
+//     }
+//   }
+// }
+
+struct Roll {
+  value: u64,
+  roll: u64,
+  result: u64,
+  att: Attribute
+}
+
+struct Encounter {
+  mob: Cryp,
+  success: bool,
+}
+
+
+
+fn att_roll(value: u64, att: Attribute) -> Roll {
+  let mut rng = thread_rng();
+  let roll: u64 = rng.gen();
+  return Roll { att, value, roll, result: value & roll };
+}
+
+fn print_roll(r: &Roll) {
+  println!("{:?}", r.att);
+  println!("{:064b} &", r.roll);
+  println!("{:064b}", r.value);
+  println!("{:064b} - {:?}", r.result, r.result);
+  println!("");
+}
+
+fn cryp_turn(c: &Cryp) -> Turn {
+  // println!("{:?}'s turn:", c.name);
+  let dmg = att_roll(c.dmg, Attribute::Dmg);
+  let def = att_roll(c.def, Attribute::Def);
+
+  // print_roll(&dmg);
+  // print_roll(&def);
+
+  return Turn { dmg, def }
+}
+
+fn assign_dmg(plr: &Cryp, opp: &Cryp, plr_t: &Turn, opp_t: &Turn) -> Cryp {
+  let final_dmg = opp_t.dmg.result.saturating_sub(plr_t.def.result);
+  let blocked = opp_t.dmg.result.saturating_sub(final_dmg);
+  let new_stam = plr.stam.saturating_sub(final_dmg);
+
+  println!("{:?} deals {:?} dmg to {:?} ({:?} blocked / {:?} hp remaining)"
+    ,opp.name
+    ,final_dmg
+    ,plr.name
+    ,blocked
+    ,new_stam);
+
+  return Cryp {
+    dmg: plr.dmg,
+    def: plr.def,
+    stam: new_stam,
+    xp: plr.xp,
+    lvl: plr.lvl,
+    id: plr.id,
+    name: plr.name.clone()
+  };
+}
+
+fn combat_phase(a: &Cryp, b: &Cryp) -> Vec<Cryp> {
+  let a_turn = cryp_turn(&a);
+  let b_turn = cryp_turn(&b);
+  return vec![
+  assign_dmg(&a, &b, &a_turn, &b_turn),
+  assign_dmg(&b, &a, &b_turn, &a_turn),
+  ];
+}
+
+pub fn battle(a: &Cryp, b: &Cryp) -> Vec<Cryp> {
+  let mut cryps = vec![
+    a.clone(),
+    b.clone()
+  ];
+
+  // println!("battle:",);
+  // println!("{:?}", cryps[0]);
+  // println!("{:?}", cryps[1]);
+  loop {
+    let combat = combat_phase(&cryps[0], &cryps[1]);
+    // println!("{:?}", combat);
+    if combat.iter().any(|c| c.stam == 0) {
+      return combat;
+    }
+    cryps = combat;
+  }
+}
+
+fn pve(plr: &Cryp) -> Encounter {
+  let mut rng = thread_rng();
+  let mob_lvl: u8 = rng.gen_range(1, plr.lvl);
+
+  let mob = Cryp::new()
+    .named("bamboo basher".to_string())
+    .level(mob_lvl)
+    .create();
+
+  let battle = battle(plr, &mob);
+  let win = battle.iter().any(|c| c.id == plr.id && c.stam > 0);
+
+  if win {
+    return Encounter {
+      mob: mob,
+      success: true,
+    };
+  }
+
+  return Encounter {
+    mob: mob,
+    success: false,
+  };
+}
+
+pub fn levelling(mut c: Cryp) -> Cryp {
+  loop {
+    let enc = pve(&c);
+
+    if !enc.success {
+      println!("{:?} has been KO'd", c.name);
+      break c;
+    }
+
+    println!("{:?} rekt {:?}", c.name, enc.mob.name);
+    c = c.add_xp();
+    println!("{:?} now has {:?} xp and is lvl {:?}", c.name, c.xp, c.lvl);
+
+    if c.lvl == 12 {
+      break c;
+    }
+
+    continue;
+  }
+}
+

src/cryp.rs

@@ -16,7 +16,6 @@ pub struct Cryp {
 
 fn check_lvl(lvl: u8) -> u8 {
   if lvl > 64 { return 64; }
-  if lvl == 0 { return 0; }
   return lvl;
 }
 
@@ -54,10 +53,10 @@ impl Cryp {
 
   pub fn level_up(mut self) -> Cryp {
     self.lvl = self.lvl.saturating_add(1);
-    self.finish()
+    self.create()
   }
 
-  pub fn finish(mut self) -> Cryp {
+  pub fn create(mut self) -> Cryp {
     let mut rng = thread_rng();
     let lvl_as_two_pwr = 2_u64.pow(self.lvl.into());
     let max = match self.lvl == 64 {

src/lib.rs

@@ -2,173 +2,21 @@ extern crate rand;
 extern crate uuid;
 
 mod cryp;
+mod combat;
 
+use combat::{battle, levelling};
 use cryp::Cryp;
-use rand::prelude::*;
-
-struct Turn {
-  dmg: Roll,
-  def: Roll,
-}
-
-#[derive(Debug)]
-enum Attribute {
-  Dmg,
-  Def,
-}
-
-// impl Attribute {
-//   pub fn as_str(&self) -> &'static str {
-//     match self {
-//         Dmg => "dmg",
-//         Def => "def",
-//     }
-//   }
-// }
-
-struct Roll {
-  value: u64,
-  roll: u64,
-  result: u64,
-  att: Attribute
-}
-
-struct Encounter {
-  mob: Cryp,
-  success: bool,
-}
-
-
-
-fn att_roll(value: u64, att: Attribute) -> Roll {
-  let mut rng = thread_rng();
-  let roll: u64 = rng.gen();
-  return Roll { att, value, roll, result: value & roll };
-}
-
-fn print_roll(r: &Roll) {
-  println!("{:?}", r.att);
-  println!("{:064b} &", r.roll);
-  println!("{:064b}", r.value);
-  println!("{:064b} - {:?}", r.result, r.result);
-  println!("");
-}
-
-fn cryp_turn(c: &Cryp) -> Turn {
-  // println!("{:?}'s turn:", c.name);
-  let dmg = att_roll(c.dmg, Attribute::Dmg);
-  let def = att_roll(c.def, Attribute::Def);
-
-  // print_roll(&dmg);
-  // print_roll(&def);
-
-  return Turn { dmg, def }
-}
-
-fn assign_dmg(plr: &Cryp, opp: &Cryp, plr_t: &Turn, opp_t: &Turn) -> Cryp {
-  let final_dmg = opp_t.dmg.result.saturating_sub(plr_t.def.result);
-  let blocked = opp_t.dmg.result.saturating_sub(final_dmg);
-
-  println!("{:?} deals {:?} dmg to {:?} ({:?} blocked)"
-    ,opp.name
-    ,final_dmg
-    ,plr.name
-    ,blocked);
-
-  return Cryp {
-    dmg: plr.dmg,
-    def: plr.def,
-    stam: plr.stam.saturating_sub(final_dmg),
-    xp: plr.xp,
-    lvl: plr.lvl,
-    id: plr.id,
-    name: plr.name.clone()
-  };
-}
-
-fn combat_phase(a: &Cryp, b: &Cryp) -> Vec<Cryp> {
-  let a_turn = cryp_turn(&a);
-  let b_turn = cryp_turn(&b);
-  return vec![
-  assign_dmg(&a, &b, &a_turn, &b_turn),
-  assign_dmg(&b, &a, &b_turn, &a_turn),
-  ];
-}
-
-fn battle(a: &Cryp, b: &Cryp) -> Vec<Cryp> {
-  let mut cryps = vec![
-    a.clone(),
-    b.clone()
-  ];
-
-  // println!("battle:",);
-  // println!("{:?}", cryps[0]);
-  // println!("{:?}", cryps[1]);
-  loop {
-    let combat = combat_phase(&cryps[0], &cryps[1]);
-    // println!("{:?}", combat);
-    if combat.iter().any(|c| c.stam == 0) {
-      return combat;
-    }
-    cryps = combat;
-  }
-}
-
-fn pve(plr: &Cryp) -> Encounter {
-  let mut rng = thread_rng();
-  let mob_lvl: u8 = rng.gen_range(1, plr.lvl);
-
-  let mob = Cryp::new()
-    .named("bamboo basher".to_string())
-    .level(mob_lvl)
-    .finish();
-
-  let battle = battle(plr, &mob);
-  let win = battle.iter().any(|c| c.id == plr.id && c.stam > 0);
-
-  if win {
-    return Encounter {
-      mob: mob,
-      success: true,
-    };
-  }
-
-  return Encounter {
-    mob: mob,
-    success: false,
-  };
-}
-
-fn levelling(mut c: Cryp) -> Cryp {
-  loop {
-    let enc = pve(&c);
-
-    if !enc.success {
-      println!("{:?} has been KO'd", c.name);
-      continue;
-    }
-
-    c = c.add_xp();
-    println!("{:?} now has {:?} xp and is lvl {:?}", c.name, c.xp, c.lvl);
-
-    if c.lvl == 12 {
-      break c;
-    }
-
-    continue;
-  }
-}
 
 pub fn main() {
   let a = Cryp::new()
     .named("pronounced \"creeep\"".to_string())
     .level(8)
-    .finish();
+    .create();
 
   let b = Cryp::new()
     .named("lemongrass tea".to_string())
     .level(8)
-    .finish();
+    .create();
 
   let battle = battle(&a, &b);
 
@@ -202,7 +50,7 @@ mod tests {
     let lvl_eight = Cryp::new()
       .named("hatchling".to_string())
       .level(2)
-      .finish();
+      .create();
     assert!(lvl_eight.dmg <= 2_u64.pow(2));
     assert!(lvl_eight.def <= 2_u64.pow(2));
     assert!(lvl_eight.stam < 2_u64.pow(2));
@@ -215,7 +63,7 @@ mod tests {
     let player = Cryp::new()
       .named("ca phe sua da".to_string())
       .level(2)
-      .finish();
+      .create();
 
     levelling(player);
     return;