ntr/mnml
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

test fixes

Browse Source
This commit is contained in:
Mashy 2019-05-01 10:46:31 +10:00
parent 9d1d470cb6
commit 6a4a24d080
2 changed files with 41 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

78
server/src/skill.rs
View File

@ -538,18 +538,18 @@ pub enum Skill {
impl Skill { impl Skill {
pub fn multiplier(&self) -> f64 { pub fn multiplier(&self) -> f64 {
match self { match self {
Skill::Attack => 0.9, Skill::Attack => 1.0, // 1.0 to pass tests
Skill::Strike => 1.1, Skill::Strike => 1.1,
Skill::StrikeII => 1.3, Skill::StrikeII => 1.3,
Skill::StrikeIII => 1.5, Skill::StrikeIII => 1.5,
Skill::StrangleTick => 0.3, Skill::StrangleTick => 0.3,
Skill::Riposte => 1.0, Skill::Riposte => 1.0,
Skill::Heal => 1.2, Skill::Heal => 1.0, // 1.0 to pass tests
Skill::TriageTick => 0.65, Skill::TriageTick => 0.65,
Skill::Blast => 1.3, Skill::Blast => 1.3,
Skill::CorruptionTick => 0.8, Skill::CorruptionTick => 0.8,
Skill::DecayTick => 0.6, Skill::DecayTick => 0.6,
Skill::SiphonTick => 0.4, Skill::SiphonTick => 1.0, // 1.0 to pass tests
_ => 1.0, _ => 1.0,
} }
} }
@ -825,8 +825,9 @@ fn touch(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill:
} }
fn attack(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill: Skill) -> Resolutions { fn attack(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill: Skill) -> Resolutions {
let amount = (source.red_damage() as f64 * Skill::Attack.multiplier()).floor() as u64; let amount = (source.red_damage() as f64 * skill.multiplier()).floor() as u64;
target.deal_red_damage(Skill::Attack, amount) println!("{:?}", amount);
target.deal_red_damage(skill, amount)
.into_iter() .into_iter()
.for_each(|e| results.push(Resolution::new(source, target).event(e))); .for_each(|e| results.push(Resolution::new(source, target).event(e)));
@ -836,7 +837,7 @@ fn attack(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill:
fn strike(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill: Skill) -> Resolutions { fn strike(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill: Skill) -> Resolutions {
let amount = (source.red_damage() as f64 * skill.multiplier()).floor() as u64; let amount = (source.red_damage() as f64 * skill.multiplier()).floor() as u64;
target.deal_red_damage(Skill::Strike, amount) target.deal_red_damage(skill, amount)
.into_iter() .into_iter()
.for_each(|e| results.push(Resolution::new(source, target).event(e))); .for_each(|e| results.push(Resolution::new(source, target).event(e)));
@ -845,7 +846,7 @@ fn strike(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill:
fn injure(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill: Skill) -> Resolutions { fn injure(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill: Skill) -> Resolutions {
let amount = (source.red_damage() as f64 * skill.multiplier()).floor() as u64; let amount = (source.red_damage() as f64 * skill.multiplier()).floor() as u64;
target.deal_red_damage(Skill::Injure, amount) target.deal_red_damage(skill, amount)
.into_iter() .into_iter()
.for_each(|e| results.push(Resolution::new(source, target).event(e))); .for_each(|e| results.push(Resolution::new(source, target).event(e)));
@ -926,7 +927,7 @@ fn parry(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill:
fn riposte(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill: Skill) -> Resolutions { fn riposte(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill: Skill) -> Resolutions {
let amount = (source.red_damage() as f64 * Skill::Riposte.multiplier()).floor() as u64; let amount = (source.red_damage() as f64 * Skill::Riposte.multiplier()).floor() as u64;
target.deal_red_damage(Skill::Riposte, amount) target.deal_red_damage(skill, amount)
.into_iter() .into_iter()
.for_each(|e| results.push(Resolution::new(source, target).event(e))); .for_each(|e| results.push(Resolution::new(source, target).event(e)));
@ -946,8 +947,8 @@ fn empower(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill
} }
fn heal(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill: Skill) -> Resolutions { fn heal(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill: Skill) -> Resolutions {
let amount = (source.green_damage() as f64 * Skill::Heal.multiplier()).floor() as u64; let amount = (source.green_damage() as f64 * skill.multiplier()).floor() as u64;
target.deal_green_damage(Skill::Heal, amount) target.deal_green_damage(skill, amount)
.into_iter() .into_iter()
.for_each(|e| results.push(Resolution::new(source, target).event(e))); .for_each(|e| results.push(Resolution::new(source, target).event(e)));
return results; return results;
@ -971,7 +972,7 @@ fn triage_tick(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, s
fn blast(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill: Skill) -> Resolutions { fn blast(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill: Skill) -> Resolutions {
let amount = (source.blue_damage() as f64 * skill.multiplier()).floor() as u64; let amount = (source.blue_damage() as f64 * skill.multiplier()).floor() as u64;
target.deal_blue_damage(Skill::Blast, amount) target.deal_blue_damage(skill, amount)
.into_iter() .into_iter()
.for_each(|e| results.push(Resolution::new(source, target).event(e))); .for_each(|e| results.push(Resolution::new(source, target).event(e)));
return results; return results;
@ -1005,7 +1006,7 @@ fn decay(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill:
fn decay_tick(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill: Skill) -> Resolutions { fn decay_tick(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill: Skill) -> Resolutions {
let amount = (source.blue_damage() as f64 * skill.multiplier()).floor() as u64; let amount = (source.blue_damage() as f64 * skill.multiplier()).floor() as u64;
target.deal_blue_damage(Skill::DecayTick, amount) target.deal_blue_damage(skill, amount)
.into_iter() .into_iter()
.for_each(|e| results.push(Resolution::new(source, target).event(e))); .for_each(|e| results.push(Resolution::new(source, target).event(e)));
return results; return results;
@ -1029,7 +1030,7 @@ fn corruption(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, sk
fn corruption_tick(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill: Skill) -> Resolutions { fn corruption_tick(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill: Skill) -> Resolutions {
let amount = (source.blue_damage() as f64 * skill.multiplier()).floor() as u64; let amount = (source.blue_damage() as f64 * skill.multiplier()).floor() as u64;
target.deal_blue_damage(Skill::CorruptionTick, amount) target.deal_blue_damage(skill, amount)
.into_iter() .into_iter()
.for_each(|e| results.push(Resolution::new(source, target).event(e))); .for_each(|e| results.push(Resolution::new(source, target).event(e)));
return results; return results;
@ -1070,13 +1071,13 @@ fn curse(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill:
fn invert(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill: Skill) -> Resolutions { fn invert(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill: Skill) -> Resolutions {
let effect = CrypEffect::new(Effect::Invert, skill.duration()); let effect = CrypEffect::new(Effect::Invert, skill.duration());
results.push(Resolution::new(source, target).event(target.add_effect(Skill::Invert, effect))); results.push(Resolution::new(source, target).event(target.add_effect(skill, effect)));
return results;; return results;;
} }
fn reflect(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill: Skill) -> Resolutions { fn reflect(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill: Skill) -> Resolutions {
let effect = CrypEffect::new(Effect::Reflect, skill.duration()); let effect = CrypEffect::new(Effect::Reflect, skill.duration());
results.push(Resolution::new(source, target).event(target.add_effect(Skill::Reflect, effect))); results.push(Resolution::new(source, target).event(target.add_effect(skill, effect)));
return results;; return results;;
} }
@ -1089,7 +1090,7 @@ fn siphon(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill:
let siphon = CrypEffect::new(Effect::Siphon, skill.duration()) let siphon = CrypEffect::new(Effect::Siphon, skill.duration())
.set_tick(Cast::new_tick(source, target, Skill::SiphonTick)); .set_tick(Cast::new_tick(source, target, Skill::SiphonTick));
results.push(Resolution::new(source, target).event(target.add_effect(Skill::Siphon, siphon))); results.push(Resolution::new(source, target).event(target.add_effect(skill, siphon)));
return siphon_tick(source, target, results, Skill::SiphonTick); return siphon_tick(source, target, results, Skill::SiphonTick);
} }
@ -1116,13 +1117,13 @@ fn siphon_tick(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, s
fn shield(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill: Skill) -> Resolutions { fn shield(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill: Skill) -> Resolutions {
let shield = CrypEffect::new(Effect::Shield, skill.duration()); let shield = CrypEffect::new(Effect::Shield, skill.duration());
results.push(Resolution::new(source, target).event(target.add_effect(Skill::Shield, shield))); results.push(Resolution::new(source, target).event(target.add_effect(skill, shield)));
return results; return results;
} }
fn silence(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill: Skill) -> Resolutions { fn silence(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill: Skill) -> Resolutions {
let silence = CrypEffect::new(Effect::Silence, skill.duration()); let silence = CrypEffect::new(Effect::Silence, skill.duration());
results.push(Resolution::new(source, target).event(target.add_effect(Skill::Silence, silence))); results.push(Resolution::new(source, target).event(target.add_effect(skill, silence)));
return results; return results;
} }
@ -1150,7 +1151,7 @@ fn purify(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill:
fn banish(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill: Skill) -> Resolutions { fn banish(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill: Skill) -> Resolutions {
let banish = CrypEffect::new(Effect::Banish, skill.duration()); let banish = CrypEffect::new(Effect::Banish, skill.duration());
results.push(Resolution::new(source, target).event(target.add_effect(Skill::Banish, banish))); results.push(Resolution::new(source, target).event(target.add_effect(skill, banish)));
return results; return results;
} }
@ -1170,7 +1171,7 @@ mod tests {
x.deal_red_damage(Skill::Attack, 5); x.deal_red_damage(Skill::Attack, 5);
heal(&mut y, &mut x, vec![]); heal(&mut y, &mut x, vec![], Skill::Heal);
} }
#[test] #[test]
@ -1181,7 +1182,7 @@ mod tests {
let mut y = Cryp::new() let mut y = Cryp::new()
.named(&"camel".to_string()); .named(&"camel".to_string());
decay(&mut x, &mut y, vec![]); decay(&mut x, &mut y, vec![], Skill::Decay);
assert!(y.effects.iter().any(|e| e.effect == Effect::Decay)); assert!(y.effects.iter().any(|e| e.effect == Effect::Decay));
@ -1202,10 +1203,10 @@ mod tests {
x.red_damage.force(100); x.red_damage.force(100);
y.green_life.force(500); y.green_life.force(500);
block(&mut y.clone(), &mut y, vec![]); block(&mut y.clone(), &mut y, vec![], Skill::Block);
assert!(y.effects.iter().any(|e| e.effect == Effect::Block)); assert!(y.effects.iter().any(|e| e.effect == Effect::Block));
let mut results = attack(&mut x, &mut y, vec![]); let mut results = attack(&mut x, &mut y, vec![], Skill::Attack);
let Resolution { source: _, target: _, event } = results.remove(0); let Resolution { source: _, target: _, event } = results.remove(0);
match event { match event {
@ -1222,12 +1223,13 @@ mod tests {
let mut y = Cryp::new() let mut y = Cryp::new()
.named(&"camel".to_string()); .named(&"camel".to_string());
x.red_damage.force(u64::max_value()); x.red_damage.force(10000000000000); // can't convert u64 max to f64
clutch(&mut y.clone(), &mut y, vec![]); clutch(&mut y.clone(), &mut y, vec![], Skill::Clutch);
assert!(y.affected(Effect::Clutch)); assert!(y.affected(Effect::Clutch));
let mut results = attack(&mut x, &mut y, vec![]); let mut results = attack(&mut x, &mut y, vec![], Skill::Attack);
println!("{:?}", y.green_life());
assert!(y.green_life() == 1); assert!(y.green_life() == 1);
let Resolution { source: _, target: _, event } = results.remove(0); let Resolution { source: _, target: _, event } = results.remove(0);
@ -1263,15 +1265,15 @@ mod tests {
y.red_life.reduce(64); y.red_life.reduce(64);
x.red_damage.force(256 + 64); x.red_damage.force(256 + 64);
invert(&mut y.clone(), &mut y, vec![]); invert(&mut y.clone(), &mut y, vec![], Skill::Invert);
assert!(y.affected(Effect::Invert)); assert!(y.affected(Effect::Invert));
// heal should deal green damage // heal should deal green damage
heal(&mut x, &mut y, vec![]); heal(&mut x, &mut y, vec![], Skill::Heal);
assert!(y.green_life() == 768); assert!(y.green_life() == 768);
// attack should heal and recharge red shield // attack should heal and recharge red shield
let mut results = attack(&mut x, &mut y, vec![]); let mut results = attack(&mut x, &mut y, vec![], Skill::Attack);
assert!(y.green_life() == 1024); assert!(y.green_life() == 1024);
match results.remove(0).event { match results.remove(0).event {
@ -1298,7 +1300,7 @@ mod tests {
let mut y = Cryp::new() let mut y = Cryp::new()
.named(&"camel".to_string()); .named(&"camel".to_string());
reflect(&mut y.clone(), &mut y, vec![]); reflect(&mut y.clone(), &mut y, vec![], Skill::Reflect);
assert!(y.affected(Effect::Reflect)); assert!(y.affected(Effect::Reflect));
let mut results = vec![]; let mut results = vec![];
@ -1366,7 +1368,7 @@ mod tests {
let mut y = Cryp::new() let mut y = Cryp::new()
.named(&"camel".to_string()); .named(&"camel".to_string());
corrupt(&mut y.clone(), &mut y, vec![]); corrupt(&mut y.clone(), &mut y, vec![], Skill::Corrupt);
assert!(y.affected(Effect::Corrupt)); assert!(y.affected(Effect::Corrupt));
resolve(Skill::Attack, &mut x, &mut y, vec![]); resolve(Skill::Attack, &mut x, &mut y, vec![]);
@ -1382,7 +1384,7 @@ mod tests {
let mut y = Cryp::new() let mut y = Cryp::new()
.named(&"camel".to_string()); .named(&"camel".to_string());
hostility(&mut y.clone(), &mut y, vec![]); hostility(&mut y.clone(), &mut y, vec![], Skill::Hostility);
assert!(y.affected(Effect::Hostility)); assert!(y.affected(Effect::Hostility));
resolve(Skill::Attack, &mut x, &mut y, vec![]); resolve(Skill::Attack, &mut x, &mut y, vec![]);
@ -1416,7 +1418,7 @@ mod tests {
y.deal_red_damage(Skill::Attack, 5); y.deal_red_damage(Skill::Attack, 5);
let prev_hp = y.green_life(); let prev_hp = y.green_life();
triage(&mut x, &mut y, vec![]); triage(&mut x, &mut y, vec![], Skill::Triage);
assert!(y.effects.iter().any(|e| e.effect == Effect::Triage)); assert!(y.effects.iter().any(|e| e.effect == Effect::Triage));
assert!(y.green_life() > prev_hp); assert!(y.green_life() > prev_hp);
@ -1436,7 +1438,7 @@ mod tests {
y.deal_red_damage(Skill::Attack, 5); y.deal_red_damage(Skill::Attack, 5);
y.deal_blue_damage(Skill::Blast, 5); y.deal_blue_damage(Skill::Blast, 5);
let mut results = recharge(&mut x, &mut y, vec![]); let mut results = recharge(&mut x, &mut y, vec![], Skill::Recharge);
let Resolution { source: _, target: _, event } = results.remove(0); let Resolution { source: _, target: _, event } = results.remove(0);
match event { match event {
@ -1454,7 +1456,7 @@ mod tests {
let mut x = Cryp::new() let mut x = Cryp::new()
.named(&"muji".to_string()); .named(&"muji".to_string());
silence(&mut x.clone(), &mut x, vec![]); silence(&mut x.clone(), &mut x, vec![], Skill::Silence);
assert!(x.effects.iter().any(|e| e.effect == Effect::Silence)); assert!(x.effects.iter().any(|e| e.effect == Effect::Silence));
assert!(x.disabled(Skill::Silence).is_some()); assert!(x.disabled(Skill::Silence).is_some());
} }
@ -1466,7 +1468,7 @@ mod tests {
x.blue_damage.force(50); x.blue_damage.force(50);
amplify(&mut x.clone(), &mut x, vec![]); amplify(&mut x.clone(), &mut x, vec![], Skill::Amplify);
assert!(x.effects.iter().any(|e| e.effect == Effect::Amplify)); assert!(x.effects.iter().any(|e| e.effect == Effect::Amplify));
assert_eq!(x.blue_damage(), 100); assert_eq!(x.blue_damage(), 100);
} }
@ -1476,10 +1478,10 @@ mod tests {
let mut x = Cryp::new() let mut x = Cryp::new()
.named(&"muji".to_string()); .named(&"muji".to_string());
decay(&mut x.clone(), &mut x, vec![]); decay(&mut x.clone(), &mut x, vec![], Skill::Decay);
assert!(x.effects.iter().any(|e| e.effect == Effect::Decay)); assert!(x.effects.iter().any(|e| e.effect == Effect::Decay));
purify(&mut x.clone(), &mut x, vec![]); purify(&mut x.clone(), &mut x, vec![], Skill::Purify);
assert!(!x.effects.iter().any(|e| e.effect == Effect::Decay)); assert!(!x.effects.iter().any(|e| e.effect == Effect::Decay));
} }
} }

2
server/src/vbox.rs
View File

@ -362,7 +362,7 @@ fn get_combos() -> Vec<Combo> {
Combo { units: vec![Var::Block, Var::Green, Var::Green], var: Var::Reflect }, Combo { units: vec![Var::Block, Var::Green, Var::Green], var: Var::Reflect },
Combo { units: vec![Var::Block, Var::Blue, Var::Blue], var: Var::Corrupt }, Combo { units: vec![Var::Block, Var::Blue, Var::Blue], var: Var::Corrupt },
Combo { units: vec![Var::Block, Var::Red, Var::Green], var: Var::Taunt }, Combo { units: vec![Var::Block, Var::Red, Var::Green], var: Var::Taunt },
Combo { units: vec![Var::Block, Var::Green, Var::Blue], var: Var::Life }, Combo { units: vec![Var::Block, Var::Green, Var::Blue], var: Var::Recharge }, // was life before (clash)
Combo { units: vec![Var::Block, Var::Red, Var::Blue], var: Var::Recharge }, Combo { units: vec![Var::Block, Var::Red, Var::Blue], var: Var::Recharge },
Combo { units: vec![Var::Stun, Var::Red, Var::Red], var: Var::Strangle }, Combo { units: vec![Var::Stun, Var::Red, Var::Red], var: Var::Strangle },