levelling

src/cryp.rs

@@ -0,0 +1,53 @@
+use uuid::Uuid;
+use rand::prelude::*;
+
+#[derive(Debug,Clone)]
+pub struct Cryp {
+  pub id: Uuid,
+  // todo
+  // make attributes hold this value
+  pub dmg: u64,
+  pub def: u64,
+  pub stam: u64,
+  pub xp: u64,
+  pub lvl: u8,
+  pub name: String,
+}
+
+fn check_lvl(lvl: u8) -> u8 {
+  if lvl > 64 { return 64; }
+  if lvl == 0 { return 0; }
+  return lvl;
+}
+
+impl Cryp {
+  pub fn new(name: String, lvl: u8) -> 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,
+      def,
+      stam,
+      lvl: checked_lvl,
+      xp: 0,
+      name: name.clone()
+    };
+  }
+
+  pub fn lvl(self) -> Cryp {
+    Cryp::new(self.name, self.lvl + 1)
+  }
+}
+
+

src/lib.rs

@@ -1,21 +1,11 @@
 extern crate rand;
 extern crate uuid;
-// extern crate serde_json;
 
-use uuid::Uuid;
+mod cryp;
+
+use cryp::Cryp;
 use rand::prelude::*;
 
-#[derive(Debug,Clone)]
-struct Cryp {
-  id: Uuid,
-  dmg: u64,
-  def: u64,
-  stam: u64,
-  xp: u64,
-  lvl: u8,
-  name: String,
-}
-
 struct Turn {
   dmg: Roll,
   def: Roll,
@@ -27,14 +17,14 @@ enum Attribute {
   Def,
 }
 
-impl Attribute {
+// impl Attribute {
-  pub fn as_str(&self) -> &'static str {
+//   pub fn as_str(&self) -> &'static str {
-    match self {
+//     match self {
-        Dmg => "dmg",
+//         Dmg => "dmg",
-        Def => "def",
+//         Def => "def",
-    }
+//     }
-  }
+//   }
-}
+// }
 
 struct Roll {
   value: u64,
@@ -43,29 +33,13 @@ struct Roll {
   att: Attribute
 }
 
-fn check_lvl(lvl: u8) -> u8 {
+struct Encounter {
-  if lvl > 64 { return 64; }
+  mob: Cryp,
-  if lvl == 0 { return 0; }
+  success: bool,
-  return lvl;
+  xp_gain: u64,
 }
 
-fn create_cryp(name: String, lvl: u8) -> Cryp {
+
-  let mut rng = thread_rng();
-  let max = 2_u64.pow(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,
-    def,
-    stam,
-    lvl,
-    xp: 0,
-    name: name.clone()
-  };
-}
 
 fn att_roll(value: u64, att: Attribute) -> Roll {
   let mut rng = thread_rng();
@@ -84,7 +58,7 @@ fn print_roll(r: &Roll) {
 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::Dmg);
+  let def = att_roll(c.def, Attribute::Def);
 
   print_roll(&dmg);
   print_roll(&def);
@@ -98,11 +72,13 @@ fn assign_dmg(plr: &Cryp, opp: &Cryp, plr_t: &Turn, opp_t: &Turn) -> Cryp {
     None => 0,
   };
 
+  let blocked = opp_t.dmg.result.checked_sub(final_dmg).expect("damage weird");
+
   println!("{:?} deals {:?} dmg to {:?} ({:?} blocked)"
     ,opp.name
     ,final_dmg
     ,plr.name
-    ,opp_t.def.result);
+    ,blocked);
 
   return Cryp {
     dmg: plr.dmg,
@@ -146,27 +122,54 @@ fn battle(a: &Cryp, b: &Cryp) -> Vec<Cryp> {
   }
 }
 
-fn pve(plr: &Cryp) {
+fn pve(plr: &Cryp) -> Encounter {
   let mut rng = thread_rng();
-  let mob_lvl: u8 = rng.gen_range(1, check_lvl(plr.lvl + 1));
+  let mob_lvl: u8 = rng.gen_range(1, plr.lvl);
-  let mob = create_cryp("bamboo basher".to_string(), mob_lvl);
 
+  let mob = Cryp::new("bamboo basher".to_string(), mob_lvl);
   let battle = battle(plr, &mob);
 
-  let winner = match battle.iter().find(|c| c.stam > 0) {
+  let win = battle.iter().any(|c| c.id == plr.id && c.stam > 0);
-    Some(w) => w,
-    None => panic!("no winner found {:?}", battle),
-  };
 
-  if winner.id == plr.id {
+  if win {
-    println!("level up");
+    return Encounter {
+      mob,
+      success: true,
+      xp_gain: 2,
+    };
   }
 
+  return Encounter {
+    mob,
+    success: false,
+    xp_gain: 0,
+  };
+}
+
+fn levelling(c: Cryp) -> Cryp {
+  let mut plr = c;
+  loop {
+    let enc = pve(&plr);
+    if plr.lvl == 64 {
+      println!("{:?} has reached max level", plr.name);
+      break plr;
+    }
+
+    if !enc.success {
+      println!("{:?} has been KO'd", plr.name);
+      break plr;
+    }
+
+    println!("{:?} is now level {:?}", plr.name, plr.lvl);
+    plr = plr.lvl();
+    continue;
+
+  }
 }
 
 pub fn main() {
-  let a = create_cryp("pronounced \"creeep\"".to_string(), 8);
+  let a = Cryp::new("pronounced \"creeep\"".to_string(), 8);
-  let b = create_cryp("lemongrass tea".to_string(), 8);
+  let b = Cryp::new("lemongrass tea".to_string(), 8);
 
   let battle = battle(&a, &b);
 
@@ -197,7 +200,7 @@ mod tests {
   }
   #[test]
   fn create_cryp_test() {
-    let lvl_eight = create_cryp("hatchling".to_string(), 2);
+    let lvl_eight = Cryp::new("hatchling".to_string(), 2);
     assert!(lvl_eight.dmg <= 2_u64.pow(2));
     assert!(lvl_eight.def <= 2_u64.pow(2));
     assert!(lvl_eight.stam < 2_u64.pow(2));
@@ -207,8 +210,8 @@ mod tests {
 
   #[test]
   fn pve_test() {
-    let player = create_cryp("ca phe sua da".to_string(), 2);
+    let player = Cryp::new("ca phe sua da".to_string(), 2);
-    pve(&player);
+    levelling(player);
     return;
   }