dont pass species but rather dex around
Bel LaPointe
parent
50841b807a
commit
6007c2f2ed
|
|
@ -1,301 +1,337 @@
|
|||
pub mod mon {
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub struct Species {
|
||||
pub name: String,
|
||||
pub hp: i32,
|
||||
pub atk: i32,
|
||||
pub def: i32,
|
||||
pub spd: i32,
|
||||
}
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub struct Species {
|
||||
pub name: String,
|
||||
pub hp: i32,
|
||||
pub atk: i32,
|
||||
pub def: i32,
|
||||
pub spd: i32,
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod species_tests {
|
||||
use super::*;
|
||||
#[cfg(test)]
|
||||
mod species_tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn test_literal() {
|
||||
let _: Species = Species{
|
||||
name: "".to_string(),
|
||||
hp: 1,
|
||||
atk: 2,
|
||||
def: 3,
|
||||
spd: 4,
|
||||
};
|
||||
}
|
||||
}
|
||||
#[test]
|
||||
fn test_literal() {
|
||||
let _: Species = Species {
|
||||
name: "".to_string(),
|
||||
hp: 1,
|
||||
atk: 2,
|
||||
def: 3,
|
||||
spd: 4,
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub enum Dex {
|
||||
Pika,
|
||||
Mari,
|
||||
}
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub enum Dex {
|
||||
Pika,
|
||||
Mari,
|
||||
}
|
||||
|
||||
impl Dex {
|
||||
pub fn new(&self) -> Species {
|
||||
self.clone().into()
|
||||
}
|
||||
}
|
||||
impl Dex {
|
||||
pub fn new(&self) -> Species {
|
||||
self.clone().into()
|
||||
}
|
||||
|
||||
impl Into<Species> for Dex {
|
||||
fn into(self) -> Species {
|
||||
match self {
|
||||
Dex::Pika => Species{
|
||||
name: "Pika".to_string(),
|
||||
hp: 10,
|
||||
atk: 11,
|
||||
def: 9,
|
||||
spd: 11,
|
||||
},
|
||||
Dex::Mari => Species{
|
||||
name: "Mari".to_string(),
|
||||
hp: 10,
|
||||
atk: 8,
|
||||
def: 12,
|
||||
spd: 9,
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
pub fn name(&self) -> String {
|
||||
self.new().name
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod dex_tests {
|
||||
use super::*;
|
||||
pub fn hp(&self) -> i32 {
|
||||
self.new().hp
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_dex_to_species() {
|
||||
let dex = Dex::Pika;
|
||||
let _: Species = dex.new();
|
||||
let _: Species = dex.into();
|
||||
let _: Species = Dex::Pika.new();
|
||||
let _: Species = Dex::Pika.into();
|
||||
}
|
||||
}
|
||||
pub fn atk(&self) -> i32 {
|
||||
self.new().atk
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct Instance {
|
||||
pub species: Species,
|
||||
pub damage: i32,
|
||||
}
|
||||
pub fn def(&self) -> i32 {
|
||||
self.new().def
|
||||
}
|
||||
|
||||
impl Instance {
|
||||
pub fn roll(dex: Dex) -> Instance {
|
||||
Instance{
|
||||
species: dex.into(),
|
||||
damage: 0,
|
||||
}
|
||||
}
|
||||
}
|
||||
pub fn spd(&self) -> i32 {
|
||||
self.new().spd
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod instance_tests {
|
||||
use super::*;
|
||||
impl Into<Species> for Dex {
|
||||
fn into(self) -> Species {
|
||||
match self {
|
||||
Dex::Pika => Species {
|
||||
name: "Pika".to_string(),
|
||||
hp: 10,
|
||||
atk: 11,
|
||||
def: 9,
|
||||
spd: 11,
|
||||
},
|
||||
Dex::Mari => Species {
|
||||
name: "Mari".to_string(),
|
||||
hp: 10,
|
||||
atk: 8,
|
||||
def: 12,
|
||||
spd: 9,
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_instance_roll() {
|
||||
let i: Instance = Instance::roll(Dex::Pika);
|
||||
assert_eq!(0, i.damage);
|
||||
assert_eq!(Dex::Pika.new(), i.species);
|
||||
}
|
||||
}
|
||||
#[cfg(test)]
|
||||
mod dex_tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn test_dex_to_species() {
|
||||
let dex = Dex::Pika;
|
||||
let _: Species = dex.new();
|
||||
let _: Species = dex.into();
|
||||
let _: Species = Dex::Pika.new();
|
||||
let _: Species = Dex::Pika.into();
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct Instance {
|
||||
pub dex: Dex,
|
||||
pub damage: i32,
|
||||
}
|
||||
|
||||
impl Instance {
|
||||
pub fn roll(dex: Dex) -> Instance {
|
||||
Instance {
|
||||
dex: dex,
|
||||
damage: 0,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod instance_tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn test_instance_roll() {
|
||||
let i: Instance = Instance::roll(Dex::Pika);
|
||||
assert_eq!(0, i.damage);
|
||||
assert_eq!(Dex::Pika, i.dex);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub mod battle {
|
||||
use super::*;
|
||||
use super::*;
|
||||
|
||||
pub struct Engine {
|
||||
teams: Vec<Team>,
|
||||
q: Vec<Move>,
|
||||
}
|
||||
pub struct Engine {
|
||||
teams: Vec<Team>,
|
||||
q: Vec<Move>,
|
||||
}
|
||||
|
||||
impl Engine {
|
||||
pub fn new(first: Vec<mon::Instance>, second: Vec<mon::Instance>) -> Engine {
|
||||
let mut result = Self{
|
||||
teams: vec![],
|
||||
q: vec![],
|
||||
};
|
||||
result.join(first);
|
||||
result.join(second);
|
||||
result
|
||||
}
|
||||
|
||||
pub fn join(&mut self, third: Vec<mon::Instance>) {
|
||||
self.teams.push(Team::new(third));
|
||||
}
|
||||
|
||||
pub fn enqueue(&mut self, m: Move) {
|
||||
self.q.push(m);
|
||||
}
|
||||
|
||||
pub fn exec(&mut self) {
|
||||
self.turn_order().iter().for_each(|idx| {
|
||||
match self.q[*idx].clone() {
|
||||
Move::Pass(_) => {},
|
||||
Move::Attack(rIdx, wIdx) => {
|
||||
let r = self.teams[rIdx.team].mons[rIdx.mon].clone();
|
||||
if r.can_attack() {
|
||||
let w = self.teams[wIdx.team].mons[wIdx.mon].clone();
|
||||
if w.can_be_attacked() {
|
||||
self.teams[wIdx.team].mons[wIdx.mon].mon = Engine::attack(&w.mon, &r.mon);
|
||||
}
|
||||
}
|
||||
},
|
||||
impl Engine {
|
||||
pub fn new(first: Vec<mon::Instance>, second: Vec<mon::Instance>) -> Engine {
|
||||
let mut result = Self {
|
||||
teams: vec![],
|
||||
q: vec![],
|
||||
};
|
||||
});
|
||||
self.new_turn();
|
||||
}
|
||||
result.join(first);
|
||||
result.join(second);
|
||||
result
|
||||
}
|
||||
|
||||
fn new_turn(&mut self) {
|
||||
self.q = vec![];
|
||||
}
|
||||
pub fn join(&mut self, third: Vec<mon::Instance>) {
|
||||
self.teams.push(Team::new(third));
|
||||
}
|
||||
|
||||
fn turn_order(&self) -> Vec<usize> {
|
||||
let mut order = vec![];
|
||||
for i in 0..self.q.len() {
|
||||
order.push((i, match &self.q[i] {
|
||||
Move::Pass(_) => 0,
|
||||
Move::Attack(w, _) => self.teams[w.team].mons[w.mon].mon.species.spd,
|
||||
}));
|
||||
}
|
||||
order.sort_unstable_by(|a, b| a.1.cmp(&b.1));
|
||||
order.iter().map(|x| x.0).collect()
|
||||
}
|
||||
pub fn enqueue(&mut self, m: Move) {
|
||||
self.q.push(m);
|
||||
}
|
||||
|
||||
fn attack(w: &mon::Instance, r: &mon::Instance) -> mon::Instance {
|
||||
let mut w = w.clone();
|
||||
let atk_delta = r.species.atk - 10;
|
||||
let def_delta = w.species.def - 10;
|
||||
pub fn exec(&mut self) {
|
||||
self.turn_order().iter().for_each(|idx| {
|
||||
match self.q[*idx].clone() {
|
||||
Move::Pass(_) => {}
|
||||
Move::Attack(r_idx, w_idx) => {
|
||||
let r = self.teams[r_idx.team].mons[r_idx.mon].clone();
|
||||
if r.can_attack() {
|
||||
let w = self.teams[w_idx.team].mons[w_idx.mon].clone();
|
||||
if w.can_be_attacked() {
|
||||
self.teams[w_idx.team].mons[w_idx.mon].mon =
|
||||
Engine::attack(&w.mon, &r.mon);
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
});
|
||||
self.new_turn();
|
||||
}
|
||||
|
||||
let power = match atk_delta - def_delta {
|
||||
v if v < 1 => 1,
|
||||
v => v,
|
||||
};
|
||||
fn new_turn(&mut self) {
|
||||
self.q = vec![];
|
||||
}
|
||||
|
||||
w.damage = match w.damage + power {
|
||||
v if v < w.species.hp => v,
|
||||
_ => w.species.hp,
|
||||
};
|
||||
fn turn_order(&self) -> Vec<usize> {
|
||||
let mut order = vec![];
|
||||
for i in 0..self.q.len() {
|
||||
order.push((
|
||||
i,
|
||||
match &self.q[i] {
|
||||
Move::Pass(_) => 0,
|
||||
Move::Attack(w, _) => self.teams[w.team].mons[w.mon].mon.dex.new().spd,
|
||||
},
|
||||
));
|
||||
}
|
||||
order.sort_unstable_by(|a, b| a.1.cmp(&b.1));
|
||||
order.iter().map(|x| x.0).collect()
|
||||
}
|
||||
|
||||
w
|
||||
}
|
||||
}
|
||||
fn attack(w: &mon::Instance, r: &mon::Instance) -> mon::Instance {
|
||||
let mut w = w.clone();
|
||||
let atk_delta = r.dex.new().atk - 10;
|
||||
let def_delta = w.dex.new().def - 10;
|
||||
|
||||
#[cfg(test)]
|
||||
mod engine_tests {
|
||||
use super::*;
|
||||
let power = match atk_delta - def_delta {
|
||||
v if v < 1 => 1,
|
||||
v => v,
|
||||
};
|
||||
|
||||
#[test]
|
||||
fn test_new() {
|
||||
let mut engine = Engine::new(team_a(), team_b());
|
||||
engine.join(team_b());
|
||||
}
|
||||
w.damage = match w.damage + power {
|
||||
v if v < w.dex.new().hp => v,
|
||||
_ => w.dex.new().hp,
|
||||
};
|
||||
|
||||
#[test]
|
||||
fn test_attack() {
|
||||
let mut pika = mon::Instance::roll(mon::Dex::Pika);
|
||||
let mut mari = mon::Instance::roll(mon::Dex::Mari);
|
||||
w
|
||||
}
|
||||
}
|
||||
|
||||
pika = Engine::attack(&mut pika, &mut mari);
|
||||
assert_eq!(1, pika.damage);
|
||||
#[cfg(test)]
|
||||
mod engine_tests {
|
||||
use super::*;
|
||||
|
||||
mari = Engine::attack(&mut mari, &mut pika);
|
||||
assert_eq!(1, mari.damage);
|
||||
#[test]
|
||||
fn test_new() {
|
||||
let mut engine = Engine::new(team_a(), team_b());
|
||||
engine.join(team_b());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_attack() {
|
||||
let mut pika = mon::Instance::roll(mon::Dex::Pika);
|
||||
let mut mari = mon::Instance::roll(mon::Dex::Mari);
|
||||
|
||||
for _ in 0..pika.species.hp+5 {
|
||||
pika = Engine::attack(&mut pika, &mut mari);
|
||||
}
|
||||
assert_eq!(pika.species.hp, pika.damage);
|
||||
assert_eq!(1, mari.damage);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_turn() {
|
||||
let mut engine = Engine::new(team_a(), team_b());
|
||||
engine.join(team_b());
|
||||
assert_eq!(1, pika.damage);
|
||||
|
||||
// player 0 mon 0 attacks team 1 mon 0
|
||||
engine.enqueue(Move::Attack(Idx{team: 0, mon: 0}, Idx{team: 1, mon: 0}));
|
||||
// player 1 mon 0 passes
|
||||
engine.enqueue(Move::Pass(Idx{team: 1, mon: 0}));
|
||||
// player 1 mon 1 not out
|
||||
engine.exec();
|
||||
mari = Engine::attack(&mut mari, &mut pika);
|
||||
assert_eq!(1, mari.damage);
|
||||
|
||||
assert_eq!(0, engine.teams[0].mons[0].mon.damage);
|
||||
assert_eq!(1, engine.teams[1].mons[0].mon.damage);
|
||||
assert_eq!(0, engine.teams[1].mons[1].mon.damage);
|
||||
}
|
||||
for _ in 0..pika.dex.new().hp + 5 {
|
||||
pika = Engine::attack(&mut pika, &mut mari);
|
||||
}
|
||||
assert_eq!(pika.dex.new().hp, pika.damage);
|
||||
assert_eq!(1, mari.damage);
|
||||
}
|
||||
|
||||
fn team_a() -> Vec<mon::Instance> {
|
||||
vec![mon::Instance::roll(mon::Dex::Pika)]
|
||||
}
|
||||
#[test]
|
||||
fn test_turn() {
|
||||
let mut engine = Engine::new(team_a(), team_b());
|
||||
engine.join(team_b());
|
||||
|
||||
fn team_b() -> Vec<mon::Instance> {
|
||||
vec![mon::Instance::roll(mon::Dex::Mari), mon::Instance::roll(mon::Dex::Pika)]
|
||||
}
|
||||
}
|
||||
// player 0 mon 0 attacks team 1 mon 0
|
||||
engine.enqueue(Move::Attack(
|
||||
Idx { team: 0, mon: 0 },
|
||||
Idx { team: 1, mon: 0 },
|
||||
));
|
||||
// player 1 mon 0 passes
|
||||
engine.enqueue(Move::Pass(Idx { team: 1, mon: 0 }));
|
||||
// player 1 mon 1 not out
|
||||
engine.exec();
|
||||
|
||||
#[derive(Debug)]
|
||||
struct Team {
|
||||
mons: Vec<Instance>,
|
||||
}
|
||||
assert_eq!(0, engine.teams[0].mons[0].mon.damage);
|
||||
assert_eq!(1, engine.teams[1].mons[0].mon.damage);
|
||||
assert_eq!(0, engine.teams[1].mons[1].mon.damage);
|
||||
}
|
||||
|
||||
impl Team {
|
||||
fn new(mons: Vec<mon::Instance>) -> Self {
|
||||
assert!(mons.len() > 0);
|
||||
let mut mons: Vec<_> = mons.iter().map(|m| Instance{mon: m.clone(), out: false}).collect();
|
||||
mons[0].out = true;
|
||||
Self{mons: mons}
|
||||
}
|
||||
}
|
||||
fn team_a() -> Vec<mon::Instance> {
|
||||
vec![mon::Instance::roll(mon::Dex::Pika)]
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
struct Instance {
|
||||
mon: mon::Instance,
|
||||
out: bool,
|
||||
}
|
||||
fn team_b() -> Vec<mon::Instance> {
|
||||
vec![
|
||||
mon::Instance::roll(mon::Dex::Mari),
|
||||
mon::Instance::roll(mon::Dex::Pika),
|
||||
]
|
||||
}
|
||||
}
|
||||
|
||||
impl Instance {
|
||||
fn alive(&self) -> bool {
|
||||
self.mon.damage < self.mon.species.hp
|
||||
}
|
||||
#[derive(Debug)]
|
||||
struct Team {
|
||||
mons: Vec<Instance>,
|
||||
}
|
||||
|
||||
fn can_attack(&self) -> bool {
|
||||
self.out && self.alive()
|
||||
}
|
||||
impl Team {
|
||||
fn new(mons: Vec<mon::Instance>) -> Self {
|
||||
assert!(mons.len() > 0);
|
||||
let mut mons: Vec<_> = mons
|
||||
.iter()
|
||||
.map(|m| Instance {
|
||||
mon: m.clone(),
|
||||
out: false,
|
||||
})
|
||||
.collect();
|
||||
mons[0].out = true;
|
||||
Self { mons: mons }
|
||||
}
|
||||
}
|
||||
|
||||
fn can_be_attacked(&self) -> bool {
|
||||
self.out && self.alive()
|
||||
}
|
||||
}
|
||||
#[derive(Clone, Debug)]
|
||||
struct Instance {
|
||||
mon: mon::Instance,
|
||||
out: bool,
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod instance_tests {
|
||||
use super::*;
|
||||
impl Instance {
|
||||
fn alive(&self) -> bool {
|
||||
self.mon.damage < self.mon.dex.new().hp
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_checks() {
|
||||
let mut i = Instance{
|
||||
mon: mon::Instance::roll(mon::Dex::Pika),
|
||||
out: true,
|
||||
};
|
||||
assert_eq!(true, i.alive());
|
||||
assert_eq!(true, i.can_attack());
|
||||
assert_eq!(true, i.can_be_attacked());
|
||||
i.mon.damage = i.mon.species.hp;
|
||||
assert_eq!(false, i.alive());
|
||||
assert_eq!(false, i.can_attack());
|
||||
assert_eq!(false, i.can_be_attacked());
|
||||
}
|
||||
}
|
||||
fn can_attack(&self) -> bool {
|
||||
self.out && self.alive()
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
struct Idx {
|
||||
pub team: usize,
|
||||
pub mon: usize,
|
||||
}
|
||||
fn can_be_attacked(&self) -> bool {
|
||||
self.out && self.alive()
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
enum Move {
|
||||
Pass(Idx),
|
||||
Attack(Idx, Idx),
|
||||
}
|
||||
#[cfg(test)]
|
||||
mod instance_tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn test_checks() {
|
||||
let mut i = Instance {
|
||||
mon: mon::Instance::roll(mon::Dex::Pika),
|
||||
out: true,
|
||||
};
|
||||
assert_eq!(true, i.alive());
|
||||
assert_eq!(true, i.can_attack());
|
||||
assert_eq!(true, i.can_be_attacked());
|
||||
i.mon.damage = i.mon.dex.new().hp;
|
||||
assert_eq!(false, i.alive());
|
||||
assert_eq!(false, i.can_attack());
|
||||
assert_eq!(false, i.can_be_attacked());
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct Idx {
|
||||
pub team: usize,
|
||||
pub mon: usize,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub enum Move {
|
||||
Pass(Idx),
|
||||
Attack(Idx, Idx),
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue