160 lines
3.0 KiB
Rust
160 lines
3.0 KiB
Rust
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;
|
|
}
|
|
}
|
|
|