levelling up

src/cryp.rs

@@ -21,32 +21,56 @@ fn check_lvl(lvl: u8) -> u8 {
 }
 
 impl Cryp {
-  pub fn new(name: String, lvl: u8) -> Cryp {
+  pub fn new() -> Cryp {
-    let mut rng = thread_rng();
-    let checked_lvl = check_lvl(lvl);
-
-    let max = match checked_lvl == 64 {
-        true => u64::max_value(),
-        false => 2_u64.pow(checked_lvl.into()),
-    };
-
-    let dmg: u64 = rng.gen_range(1, max);
-    let def: u64 = rng.gen_range(1, max);
-    let stam: u64 = rng.gen_range(1, max);
     let id = Uuid::new_v4();
     return Cryp {
       id,
-      dmg,
+      dmg: 0,
-      def,
+      def: 0,
-      stam,
+      stam: 0,
-      lvl: checked_lvl,
+      lvl: 0,
       xp: 0,
-      name: name.clone()
+      name: String::new()
     };
   }
 
-  pub fn lvl(self) -> Cryp {
+  pub fn named(mut self, name: String) -> Cryp {
-    Cryp::new(self.name, self.lvl + 1)
+    self.name = name.clone();
+    self
+  }
+
+  pub fn level(mut self, lvl: u8) -> Cryp {
+    self.lvl = check_lvl(lvl);
+    self
+  }
+
+  pub fn add_xp(mut self) -> Cryp {
+    self.xp = self.xp.saturating_add(1);
+    if self.xp.is_power_of_two() {
+      return self.level_up();
+    }
+    self
+  }
+
+  pub fn level_up(mut self) -> Cryp {
+    self.lvl = self.lvl.saturating_add(1);
+    self.finish()
+  }
+
+  pub fn finish(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 {
+        true => u64::max_value(),
+        false => lvl_as_two_pwr,
+    };
+
+    self.xp = lvl_as_two_pwr;
+
+    self.dmg = rng.gen_range(1, max);
+    self.def = rng.gen_range(1, max);
+    self.stam = rng.gen_range(1, max);
+    self
   }
 }
 

src/lib.rs

@@ -36,7 +36,6 @@ struct Roll {
 struct Encounter {
   mob: Cryp,
   success: bool,
-  xp_gain: u64,
 }
 
 
@@ -56,23 +55,19 @@ fn print_roll(r: &Roll) {
 }
 
 fn cryp_turn(c: &Cryp) -> Turn {
-  println!("{:?}'s turn:", c.name);
+  // 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(&dmg);
-  print_roll(&def);
+  // print_roll(&def);
 
   return Turn { dmg, def }
 }
 
 fn assign_dmg(plr: &Cryp, opp: &Cryp, plr_t: &Turn, opp_t: &Turn) -> Cryp {
-  let final_dmg = match opp_t.dmg.result.checked_sub(plr_t.def.result) {
+  let final_dmg = opp_t.dmg.result.saturating_sub(plr_t.def.result);
-    Some(v) => v,
+  let blocked = opp_t.dmg.result.saturating_sub(final_dmg);
-    None => 0,
-  };
-
-  let blocked = opp_t.dmg.result.checked_sub(final_dmg).expect("damage weird");
 
   println!("{:?} deals {:?} dmg to {:?} ({:?} blocked)"
     ,opp.name
@@ -83,10 +78,7 @@ fn assign_dmg(plr: &Cryp, opp: &Cryp, plr_t: &Turn, opp_t: &Turn) -> Cryp {
   return Cryp {
     dmg: plr.dmg,
     def: plr.def,
-    stam: match plr.stam.checked_sub(final_dmg) {
+    stam: plr.stam.saturating_sub(final_dmg),
-      Some(v) => v,
-      None => 0,
-    },
     xp: plr.xp,
     lvl: plr.lvl,
     id: plr.id,
@@ -109,12 +101,12 @@ fn battle(a: &Cryp, b: &Cryp) -> Vec<Cryp> {
     b.clone()
   ];
 
-  println!("battle:",);
+  // println!("battle:",);
-  println!("{:?}", cryps[0]);
+  // println!("{:?}", cryps[0]);
-  println!("{:?}", cryps[1]);
+  // println!("{:?}", cryps[1]);
   loop {
     let combat = combat_phase(&cryps[0], &cryps[1]);
-    println!("{:?}", combat);
+    // println!("{:?}", combat);
     if combat.iter().any(|c| c.stam == 0) {
       return combat;
     }
@@ -126,50 +118,57 @@ fn pve(plr: &Cryp) -> Encounter {
   let mut rng = thread_rng();
   let mob_lvl: u8 = rng.gen_range(1, plr.lvl);
 
-  let mob = Cryp::new("bamboo basher".to_string(), mob_lvl);
+  let mob = Cryp::new()
-  let battle = battle(plr, &mob);
+    .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: mob,
       success: true,
-      xp_gain: 2,
     };
   }
 
   return Encounter {
-    mob,
+    mob: mob,
     success: false,
-    xp_gain: 0,
   };
 }
 
-fn levelling(c: Cryp) -> Cryp {
+fn levelling(mut c: Cryp) -> Cryp {
-  let mut plr = c;
   loop {
-    let enc = pve(&plr);
+    let enc = pve(&c);
-    if plr.lvl == 64 {
-      println!("{:?} has reached max level", plr.name);
-      break plr;
-    }
 
     if !enc.success {
-      println!("{:?} has been KO'd", plr.name);
+      println!("{:?} has been KO'd", c.name);
-      break plr;
+      continue;
     }
 
-    println!("{:?} is now level {:?}", plr.name, plr.lvl);
+    c = c.add_xp();
-    plr = plr.lvl();
+    println!("{:?} now has {:?} xp and is lvl {:?}", c.name, c.xp, c.lvl);
-    continue;
 
+    if c.lvl == 12 {
+      break c;
+    }
+
+    continue;
   }
 }
 
 pub fn main() {
-  let a = Cryp::new("pronounced \"creeep\"".to_string(), 8);
+  let a = Cryp::new()
-  let b = Cryp::new("lemongrass tea".to_string(), 8);
+    .named("pronounced \"creeep\"".to_string())
+    .level(8)
+    .finish();
+
+  let b = Cryp::new()
+    .named("lemongrass tea".to_string())
+    .level(8)
+    .finish();
 
   let battle = battle(&a, &b);
 
@@ -200,7 +199,10 @@ mod tests {
   }
   #[test]
   fn create_cryp_test() {
-    let lvl_eight = Cryp::new("hatchling".to_string(), 2);
+    let lvl_eight = Cryp::new()
+      .named("hatchling".to_string())
+      .level(2)
+      .finish();
     assert!(lvl_eight.dmg <= 2_u64.pow(2));
     assert!(lvl_eight.def <= 2_u64.pow(2));
     assert!(lvl_eight.stam < 2_u64.pow(2));
@@ -210,7 +212,11 @@ mod tests {
 
   #[test]
   fn pve_test() {
-    let player = Cryp::new("ca phe sua da".to_string(), 2);
+    let player = Cryp::new()
+      .named("ca phe sua da".to_string())
+      .level(2)
+      .finish();
+
     levelling(player);
     return;
   }