enum magic

src/lib.rs

@@ -1,123 +1,216 @@
 extern crate rand;
+extern crate uuid;
 // extern crate serde_json;
 
+use uuid::Uuid;
 use rand::prelude::*;
 
 #[derive(Debug,Clone)]
 struct Cryp {
-    dmg: u64,
-    def: u64,
-    stam: u64,
-    name: String,
+  id: Uuid,
+  dmg: u64,
+  def: u64,
+  stam: u64,
+  xp: u64,
+  lvl: u8,
+  name: String,
 }
 
 struct Turn {
-    dmg: u64,
-    def: u64,
+  dmg: Roll,
+  def: Roll,
 }
 
-fn att_roll(att: u64) -> u64 {
-    let mut rng = thread_rng();
-    let roll: u64 = rng.gen();
-    println!("{:b} & {:b}", att, roll);
-    return att & roll;
+#[derive(Debug)]
+enum Attribute {
+  Dmg,
+  Def,
 }
 
-fn cryp_turn(c: &Cryp) -> Turn {
-    let dmg = att_roll(c.dmg);
-    let def = att_roll(c.def);
-
-    println!("{:?}", c.name);
-    println!("dmg: {:b}", dmg);
-    println!("def: {:b}", def);
-
-    return Turn { dmg, def }
-}
-
-fn assign_dmg(a: &Cryp, t: &Turn) -> Cryp {
-  Cryp {
-    dmg: a.dmg,
-    def: a.def,
-    stam: match a.stam.checked_sub(t.dmg) {
-      Some(v) => v,
-      None => 0,
-    },
-    name: a.name.clone()
+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
+}
+
+fn check_lvl(lvl: u8) -> u8 {
+  if lvl > 64 { return 64; }
+  if lvl == 0 { return 0; }
+  return lvl;
+}
+
+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();
+  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::Dmg);
+
+  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 = match opp_t.dmg.result.checked_sub(plr_t.def.result) {
+    Some(v) => v,
+    None => 0,
+  };
+
+  println!("{:?} deals {:?} dmg to {:?} ({:?} blocked)"
+    ,opp.name
+    ,final_dmg
+    ,plr.name
+    ,opp_t.def.result);
+
+  return Cryp {
+    dmg: plr.dmg,
+    def: plr.def,
+    stam: match plr.stam.checked_sub(final_dmg) {
+      Some(v) => v,
+      None => 0,
+    },
+    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_turn),
-      assign_dmg(&b, &a_turn),
-    ];
+  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()
-    ];
-    loop {
-        let combat = combat_phase(&cryps[0], &cryps[1]);
-        println!("{:?}", combat);
-        if combat.iter().any(|c| c.stam == 0) {
-          return combat;
-        }
-        cryps = combat;
+  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 main() {
-//     let mut bodies = vec![
-//         Body { x: 10, y: 10, v: 0 },
-//         Body { x: 20, y: 30, v: 0 },
-//     ];
+fn pve(plr: &Cryp) {
+  let mut rng = thread_rng();
+  let mob_lvl: u8 = rng.gen_range(1, check_lvl(plr.lvl + 1));
+  let mob = create_cryp("bamboo basher".to_string(), mob_lvl);
 
-//     for _ in 0..2 {
-//         let next_bodies = bodies
-//             .iter()
-//             .map(|b| {
-//                 let next_v = bodies
-//                     .iter()
-//                     .fold(b.v, { |a, b_inner| a + b.x * b_inner.x });
-//                 Body { v: next_v, ..*b }
-//             })
-//             .collect();
-//         bodies = next_bodies;
-//     }
+  let battle = battle(plr, &mob);
 
-//     println!("{:?}", bodies);
-// }
+  let winner = match battle.iter().find(|c| c.stam > 0) {
+    Some(w) => w,
+    None => panic!("no winner found {:?}", battle),
+  };
+
+  if winner.id == plr.id {
+    println!("level up");
+  }
+
+}
 
 pub fn main() {
-  let a = Cryp {
-      name: "pronounced \"creeep\"".to_string(),
-      dmg: 10,
-      def: 5,
-      stam: 25,
+  let a = create_cryp("pronounced \"creeep\"".to_string(), 8);
+  let b = create_cryp("lemongrass tea".to_string(), 8);
+
+  let battle = battle(&a, &b);
+
+  let draw = battle.iter().all(|c| c.stam == 0);
+  if draw {
+    println!("{:?} was a draw", battle);
+    return;
+  }
+
+  let winner = match battle.iter().find(|c| c.stam > 0) {
+    Some(w) => w,
+    None => panic!("no winner found {:?}", battle),
   };
 
-  let b = Cryp {
-      name: "lemongrass tea".to_string(),
-      dmg: 8,
-      def: 8,
-      stam: 25,
-  };
+  println!("{:?} is the winner with {:?} hp remaining", winner.name, winner.stam);
 
-  battle(&a, &b);
   return;
 }
 
 #[cfg(test)]
 mod tests {
-  use main;
+  use *;
+
   #[test]
-  fn it_works() {
-     main();
-     return;
- }
+  fn battle_test() {
+    main();
+    return;
+  }
+  #[test]
+  fn create_cryp_test() {
+    let lvl_eight = create_cryp("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));
+    println!("{:?}", lvl_eight);
+    return;
+  }
+
+  #[test]
+  fn pve_test() {
+    let player = create_cryp("ca phe sua da".to_string(), 2);
+    pve(&player);
+    return;
+  }
+
 }