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

Merge branch 'master' of ssh://cryps.gg:40022/~/cryps

Browse Source
This commit is contained in:
Mashy 2019-03-26 13:24:40 +10:00
commit dda728bfb8
4 changed files with 177 additions and 101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
server/WORKLOG.md
View File

@ -22,6 +22,8 @@ ensure all skills impl
Skill::Slay -> red attack with bonus somethingorother for blue / maim no healing Skill::Slay -> red attack with bonus somethingorother for blue / maim no healing
Hatred -> damage received converted into bonus dmg Hatred -> damage received converted into bonus dmg
change inversion to several events
make parry semi-aggressive make parry semi-aggressive
constants constants
change to ownership pattern change to ownership pattern

129
server/src/cryp.rs
View File

@ -439,8 +439,10 @@ impl Cryp {
} }
pub fn recharge(&mut self) -> Event { pub fn recharge(&mut self) -> Event {
if let Some(immunity) = self.immune(Skill::Recharge) { let skill = Skill::Recharge;
if let Some(immunity) = self.immune(skill) {
return Event::Immunity { return Event::Immunity {
skill,
immunity, immunity,
}; };
} }
@ -451,14 +453,17 @@ impl Cryp {
let blue = self.blue_shield.max.saturating_sub(self.blue_shield.value); let blue = self.blue_shield.max.saturating_sub(self.blue_shield.value);
self.blue_shield.value = self.blue_shield.max; self.blue_shield.value = self.blue_shield.max;
Event::Recharge { red, blue } Event::Recharge { red, blue, skill }
} }
pub fn deal_green_damage(&mut self, skill: Skill, amount: u64) -> Event { pub fn deal_green_damage(&mut self, skill: Skill, amount: u64) -> Vec<Event> {
let mut events = vec![];
if let Some(immunity) = self.immune(skill) { if let Some(immunity) = self.immune(skill) {
return Event::Immunity { events.push(Event::Immunity {
immunity, immunity,
}; skill,
});
return events;
} }
let healing_mods = self.effects.iter() let healing_mods = self.effects.iter()
@ -468,43 +473,52 @@ impl Cryp {
// println!("{:?}", healing_mods); // println!("{:?}", healing_mods);
let modified_healing = healing_mods.iter().fold(amount, |acc, m| m.apply(acc)); let modified_green_damage = healing_mods.iter().fold(amount, |acc, m| m.apply(acc));
match self.affected(Effect::Invert) { match self.affected(Effect::Invert) {
false => { false => {
let current_hp = self.hp(); let current_hp = self.hp();
self.hp.increase(modified_healing); self.hp.increase(modified_green_damage);
let new_hp = self.hp.value; let new_hp = self.hp.value;
let healing = new_hp - current_hp; let healing = new_hp - current_hp;
let overhealing = modified_healing - healing; let overhealing = modified_green_damage - healing;
return Event::Healing { events.push(Event::Healing {
skill,
amount: healing, amount: healing,
overhealing, overhealing,
}; });
}, },
true => { true => {
events.push(Event::Inversion { skill });
// there is no green shield (yet) // there is no green shield (yet)
let current_hp = self.hp(); let current_hp = self.hp();
self.reduce_hp(modified_healing); self.reduce_hp(modified_green_damage);
let delta = current_hp - self.hp(); let delta = current_hp - self.hp();
return Event::Inversion { events.push(Event::Damage {
damage: delta, skill,
healing: 0, amount: delta,
recharge: 0, mitigation: 0,
category: Category::GreenDamage, category: Category::GreenDamage,
}; });
}
} }
} }
pub fn deal_red_damage(&mut self, skill: Skill, amount: u64) -> Event { return events;
}
pub fn deal_red_damage(&mut self, skill: Skill, amount: u64) -> Vec<Event> {
let mut events = vec![];
if let Some(immunity) = self.immune(skill) { if let Some(immunity) = self.immune(skill) {
return Event::Immunity { events.push(Event::Immunity {
skill,
immunity, immunity,
}; });
return events;
} }
let red_damage_mods = self.effects.iter() let red_damage_mods = self.effects.iter()
@ -533,13 +547,16 @@ impl Cryp {
self.reduce_hp(remainder); self.reduce_hp(remainder);
let delta = current_hp - self.hp(); let delta = current_hp - self.hp();
return Event::Damage { events.push(Event::Damage {
skill,
amount: delta, amount: delta,
mitigation, mitigation,
category: Category::RedDamage, category: Category::RedDamage,
}; });
}, },
true => { true => {
events.push(Event::Inversion { skill });
let current_hp = self.hp(); let current_hp = self.hp();
self.hp.increase(modified_damage); self.hp.increase(modified_damage);
let new_hp = self.hp.value; let new_hp = self.hp.value;
@ -550,21 +567,32 @@ impl Cryp {
self.red_shield.increase(overhealing); self.red_shield.increase(overhealing);
let recharge = self.red_shield.value - current_shield; let recharge = self.red_shield.value - current_shield;
return Event::Inversion { if healing > 0 {
damage: 0, events.push(Event::Healing {
healing, skill,
recharge, amount: healing,
category: Category::RedDamage, overhealing: overhealing - recharge,
}; });
}
}
} }
pub fn deal_blue_damage(&mut self, skill: Skill, amount: u64) -> Event { if recharge > 0 {
if let Some(immunity) = self.immune(skill) { events.push(Event::Recharge { red: recharge, blue: 0, skill });
return Event::Immunity { }
immunity, }
}; };
return events;
}
pub fn deal_blue_damage(&mut self, skill: Skill, amount: u64) -> Vec<Event> {
let mut events = vec![];
if let Some(immunity) = self.immune(skill) {
events.push(Event::Immunity {
skill,
immunity,
});
return events;
} }
let blue_damage_mods = self.effects.iter() let blue_damage_mods = self.effects.iter()
@ -573,6 +601,7 @@ impl Cryp {
.collect::<Vec<Effect>>(); .collect::<Vec<Effect>>();
// println!("{:?}", blue_damage_mods); // println!("{:?}", blue_damage_mods);
let modified_damage = blue_damage_mods.iter().fold(amount, |acc, m| m.apply(acc)); let modified_damage = blue_damage_mods.iter().fold(amount, |acc, m| m.apply(acc));
match self.affected(Effect::Invert) { match self.affected(Effect::Invert) {
@ -580,19 +609,24 @@ impl Cryp {
let remainder = modified_damage.saturating_sub(self.blue_shield.value); let remainder = modified_damage.saturating_sub(self.blue_shield.value);
let mitigation = modified_damage.saturating_sub(remainder); let mitigation = modified_damage.saturating_sub(remainder);
// reduce blue_shield by mitigation amount
self.blue_shield.reduce(mitigation); self.blue_shield.reduce(mitigation);
// deal remainder to hp
let current_hp = self.hp(); let current_hp = self.hp();
self.reduce_hp(remainder); self.reduce_hp(remainder);
let delta = current_hp - self.hp(); let delta = current_hp - self.hp();
return Event::Damage { events.push(Event::Damage {
skill,
amount: delta, amount: delta,
mitigation, mitigation,
category: Category::BlueDamage, category: Category::BlueDamage,
}; });
}, },
true => { true => {
events.push(Event::Inversion { skill });
let current_hp = self.hp(); let current_hp = self.hp();
self.hp.increase(modified_damage); self.hp.increase(modified_damage);
let new_hp = self.hp.value; let new_hp = self.hp.value;
@ -603,19 +637,27 @@ impl Cryp {
self.blue_shield.increase(overhealing); self.blue_shield.increase(overhealing);
let recharge = self.blue_shield.value - current_shield; let recharge = self.blue_shield.value - current_shield;
return Event::Inversion { if healing > 0 {
damage: 0, events.push(Event::Healing {
healing, skill,
recharge, amount: healing,
category: Category::BlueDamage, overhealing,
});
}
if recharge > 0 {
events.push(Event::Recharge { red: 0, blue: recharge, skill });
}
}
}; };
}
} return events;
} }
pub fn add_effect(&mut self, skill: Skill, effect: CrypEffect) -> Event { pub fn add_effect(&mut self, skill: Skill, effect: CrypEffect) -> Event {
if let Some(immunity) = self.immune(skill) { if let Some(immunity) = self.immune(skill) {
return Event::Immunity { return Event::Immunity {
skill,
immunity, immunity,
}; };
} }
@ -624,6 +666,7 @@ impl Cryp {
let result = Event::Effect { let result = Event::Effect {
effect: effect.effect, effect: effect.effect,
duration: effect.effect.duration(), duration: effect.effect.duration(),
skill,
}; };
// println!("{:?} {:?} adding effect", self.name, effect.effect); // println!("{:?} {:?} adding effect", self.name, effect.effect);

33
server/src/game.rs
View File

@ -435,7 +435,7 @@ impl Game {
resolutions.reverse(); resolutions.reverse();
while let Some(resolution) = resolutions.pop() { while let Some(resolution) = resolutions.pop() {
// fixme for mash // fixme for mash
self.log_resolution(cast.speed, cast.skill, &resolution); self.log_resolution(cast.speed, &resolution);
// the results go into the resolutions // the results go into the resolutions
self.resolved.push(resolution); self.resolved.push(resolution);
} }
@ -490,42 +490,37 @@ impl Game {
self self
} }
fn log_resolution(&mut self, speed: u64, skill: Skill, resolution: &Resolution) -> &mut Game { fn log_resolution(&mut self, speed: u64, resolution: &Resolution) -> &mut Game {
let Resolution { source, target, event } = resolution; let Resolution { source, target, event } = resolution;
match event { match event {
Event::Ko => Event::Ko =>
self.log.push(format!("{:} KO!", target.name)), self.log.push(format!("{:} KO!", target.name)),
Event::Disable { disable } => Event::Disable { skill, disable } =>
self.log.push(format!("{:} {:?} {:} disabled {:?}", self.log.push(format!("{:} {:?} {:} disabled {:?}",
source.name, skill, target.name, disable)), source.name, skill, target.name, disable)),
Event::Immunity { immunity } => Event::Immunity { skill, immunity } =>
self.log.push(format!("[{:}] {:} {:?} {:} immune {:?}", self.log.push(format!("[{:}] {:} {:?} {:} immune {:?}",
speed, source.name, skill, target.name, immunity)), speed, source.name, skill, target.name, immunity)),
Event::TargetKo => Event::TargetKo { skill } =>
self.log.push(format!("[{:}] {:} {:?} {:} - target is KO", self.log.push(format!("[{:}] {:} {:?} {:} - target is KO",
speed, source.name, skill, target.name)), speed, source.name, skill, target.name)),
Event::Damage { amount, mitigation, category: _ } => Event::Damage { skill, amount, mitigation, category: _ } =>
self.log.push(format!("[{:}] {:} {:?} {:} {:} ({:} mitigated)", self.log.push(format!("[{:}] {:} {:?} {:} {:} ({:} mitigated)",
speed, source.name, skill, target.name, amount, mitigation)), speed, source.name, skill, target.name, amount, mitigation)),
Event::Healing { amount, overhealing } => Event::Healing { skill, amount, overhealing } =>
self.log.push(format!("[{:}] {:} {:?} {:} {:} ({:}OH)", self.log.push(format!("[{:}] {:} {:?} {:} {:} ({:}OH)",
speed, source.name, skill, target.name, amount, overhealing)), speed, source.name, skill, target.name, amount, overhealing)),
Event::Inversion { healing, damage, recharge, category: _ } => { Event::Inversion { skill } =>
match *healing > 0 { self.log.push(format!("[{:}] {:} {:?} {:} INVERTED",
true => self.log.push(format!("[{:}] {:} {:?} {:} INVERTED {:} ({:} recharge)", speed, source.name, skill, target.name)),
speed, source.name, skill, target.name, healing, recharge)),
false => self.log.push(format!("[{:}] {:} {:?} {:} INVERTED {:}",
speed, source.name, skill, target.name, damage)),
}
},
Event::Effect { effect, duration } => Event::Effect { skill, effect, duration } =>
self.log.push(format!("[{:}] {:} {:?} {:} {:?} {:}T", self.log.push(format!("[{:}] {:} {:?} {:} {:?} {:}T",
speed, source.name, skill, target.name, effect, duration)), speed, source.name, skill, target.name, effect, duration)),
@ -533,11 +528,11 @@ impl Game {
self.log.push(format!("[{:}] {:?} removed {:} {:?}", self.log.push(format!("[{:}] {:?} removed {:} {:?}",
speed, source.name, target.name, effect)), speed, source.name, target.name, effect)),
Event::Recharge { red, blue } => Event::Recharge { skill, red, blue } =>
self.log.push(format!("[{:}] {:} {:?} {:} {:}R {:}B", self.log.push(format!("[{:}] {:} {:?} {:} {:}R {:}B",
speed, source.name, skill, target.name, red, blue)), speed, source.name, skill, target.name, red, blue)),
Event::Evasion { skill: _, evasion_rating } => Event::Evasion { skill, evasion_rating } =>
self.log.push(format!("[{:}] {:} {:?} {:} evaded ({:}%)", self.log.push(format!("[{:}] {:} {:?} {:} evaded ({:}%)",
speed, source.name, skill, target.name, evasion_rating)), speed, source.name, skill, target.name, evasion_rating)),
@ -1150,7 +1145,7 @@ mod tests {
let Resolution { source, target: _, event } = r; let Resolution { source, target: _, event } = r;
match source.id == x_cryp.id { match source.id == x_cryp.id {
true => match event { true => match event {
Event::Effect { effect, duration } => { Event::Effect { effect, duration, skill: _ } => {
assert!(*effect == Effect::Ruin); assert!(*effect == Effect::Ruin);
assert!(*duration == 1); assert!(*duration == 1);
true true

114
server/src/skill.rs
View File

@ -72,16 +72,16 @@ impl Resolution {
#[derive(Debug,Clone,PartialEq,Serialize,Deserialize)] #[derive(Debug,Clone,PartialEq,Serialize,Deserialize)]
pub enum Event { pub enum Event {
TargetKo, Disable { skill: Skill, disable: Disable },
Disable { disable: Disable }, Immunity { skill: Skill, immunity: Immunity },
Immunity { immunity: Immunity }, Damage { skill: Skill, amount: u64, mitigation: u64, category: Category },
Damage { amount: u64, mitigation: u64, category: Category }, Healing { skill: Skill, amount: u64, overhealing: u64 },
Healing { amount: u64, overhealing: u64 }, Recharge { skill: Skill, red: u64, blue: u64 },
Recharge { red: u64, blue: u64 }, Inversion { skill: Skill },
Inversion { healing: u64, damage: u64, recharge: u64, category: Category }, Effect { skill: Skill, effect: Effect, duration: u8 },
Effect { effect: Effect, duration: u8 },
Removal { effect: Effect }, Removal { effect: Effect },
Evasion { skill: Skill, evasion_rating: u64 }, Evasion { skill: Skill, evasion_rating: u64 },
TargetKo { skill: Skill },
Ko, Ko,
Incomplete, Incomplete,
@ -616,12 +616,12 @@ impl Skill {
let mut results = vec![]; let mut results = vec![];
if let Some(disable) = source.disabled(*self) { if let Some(disable) = source.disabled(*self) {
results.push(Resolution::new(source, target).event(Event::Disable { disable })); results.push(Resolution::new(source, target).event(Event::Disable { disable, skill: *self }));
return results; return results;
} }
if target.is_ko() { if target.is_ko() {
results.push(Resolution::new(source, target).event(Event::TargetKo)); results.push(Resolution::new(source, target).event(Event::TargetKo { skill: *self }));
return results; return results;
} }
@ -700,7 +700,7 @@ impl Skill {
results = match target.affected(Effect::Corrupt) { results = match target.affected(Effect::Corrupt) {
true => match results.iter().any(|r| true => match results.iter().any(|r|
match r.event { match r.event {
Event::Damage { amount: _, mitigation: _, category: _ } => true, Event::Damage { amount: _, mitigation: _, category: _, skill: _ } => true,
_ => false, _ => false,
}) { }) {
true => corruption(target, source, results), true => corruption(target, source, results),
@ -746,16 +746,32 @@ impl Skill {
} }
fn touch(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Resolutions { fn touch(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Resolutions {
results.push(Resolution::new(source, target).event(target.deal_red_damage(Skill::TestTouch, 0))); target.deal_red_damage(Skill::TestTouch, 0)
.into_iter()
.for_each(|e| results.push(Resolution::new(source, target).event(e)));
return results; return results;
} }
fn attack(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Resolutions { fn attack(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Resolutions {
let amount = source.red_damage(); let amount = source.red_damage();
results.push(Resolution::new(source, target).event(target.deal_red_damage(Skill::Attack, amount))); target.deal_red_damage(Skill::Attack, amount)
.into_iter()
.for_each(|e| results.push(Resolution::new(source, target).event(e)));
return results; return results;
} }
fn strike(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Resolutions {
let amount = source.red_damage();
target.deal_red_damage(Skill::Strike, amount)
.into_iter()
.for_each(|e| results.push(Resolution::new(source, target).event(e)));
return results;
}
fn stun(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Resolutions { fn stun(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Resolutions {
let effect = CrypEffect { effect: Effect::Stun, duration: Effect::Stun.duration(), tick: None }; let effect = CrypEffect { effect: Effect::Stun, duration: Effect::Stun.duration(), tick: None };
results.push(Resolution::new(source, target).event(target.add_effect(Skill::Stun, effect))); results.push(Resolution::new(source, target).event(target.add_effect(Skill::Stun, effect)));
@ -799,7 +815,9 @@ fn strangle(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> R
fn strangle_tick(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Resolutions { fn strangle_tick(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Resolutions {
let amount = source.red_damage(); let amount = source.red_damage();
results.push(Resolution::new(source, target).event(target.deal_red_damage(Skill::StrangleTick, amount))); target.deal_red_damage(Skill::StrangleTick, amount)
.into_iter()
.for_each(|e| results.push(Resolution::new(source, target).event(e)));
// remove immunity if target ko // remove immunity if target ko
if target.is_ko() { if target.is_ko() {
@ -841,7 +859,9 @@ fn empower(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Re
fn heal(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Resolutions { fn heal(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Resolutions {
let amount = source.green_damage(); let amount = source.green_damage();
results.push(Resolution::new(source, target).event(target.deal_green_damage(Skill::Heal, amount))); target.deal_green_damage(Skill::Heal, amount)
.into_iter()
.for_each(|e| results.push(Resolution::new(source, target).event(e)));
return results; return results;
} }
@ -857,13 +877,17 @@ fn triage(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Res
fn triage_tick(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Resolutions { fn triage_tick(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Resolutions {
let amount = source.green_damage().wrapping_div(2); let amount = source.green_damage().wrapping_div(2);
results.push(Resolution::new(source, target).event(target.deal_green_damage(Skill::TriageTick, amount))); target.deal_green_damage(Skill::TriageTick, amount)
.into_iter()
.for_each(|e| results.push(Resolution::new(source, target).event(e)));
return results; return results;
} }
fn blast(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Resolutions { fn blast(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Resolutions {
let amount = source.blue_damage(); let amount = source.blue_damage();
results.push(Resolution::new(source, target).event(target.deal_blue_damage(Skill::Blast, amount))); target.deal_blue_damage(Skill::Blast, amount)
.into_iter()
.for_each(|e| results.push(Resolution::new(source, target).event(e)));
return results; return results;
} }
@ -897,7 +921,9 @@ fn decay(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Reso
fn decay_tick(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Resolutions { fn decay_tick(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Resolutions {
let amount = source.blue_damage(); let amount = source.blue_damage();
results.push(Resolution::new(source, target).event(target.deal_blue_damage(Skill::DecayTick, amount))); target.deal_blue_damage(Skill::DecayTick, amount)
.into_iter()
.for_each(|e| results.push(Resolution::new(source, target).event(e)));
return results; return results;
} }
@ -921,7 +947,9 @@ fn corruption(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) ->
fn corruption_tick(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Resolutions { fn corruption_tick(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Resolutions {
let amount = source.blue_damage() / 2; let amount = source.blue_damage() / 2;
results.push(Resolution::new(source, target).event(target.deal_blue_damage(Skill::CorruptionTick, amount))); target.deal_blue_damage(Skill::CorruptionTick, amount)
.into_iter()
.for_each(|e| results.push(Resolution::new(source, target).event(e)));
return results; return results;
} }
@ -972,14 +1000,20 @@ fn siphon(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Res
fn siphon_tick(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Resolutions { fn siphon_tick(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Resolutions {
let amount = source.blue_damage(); let amount = source.blue_damage();
let siphon_damage = target.deal_blue_damage(Skill::SiphonTick, amount); let siphon_events = target.deal_blue_damage(Skill::SiphonTick, amount);
results.push(Resolution::new(source, target).event(siphon_damage.clone()));
match siphon_damage { for e in siphon_events {
Event::Damage { amount, mitigation: _, category: _, } => { match e {
results.push(Resolution::new(source, source).event(source.deal_green_damage(Skill::Heal, amount))); Event::Damage { amount, mitigation: _, category: _, skill: _ } => {
let dmg = source.deal_green_damage(Skill::Siphon, amount);
for e in dmg {
results.push(Resolution::new(source, target).event(e));
};
}, },
_ => panic!("siphon tick damage not dealt {:?}", siphon_damage), _ => (),
}
results.push(Resolution::new(source, target).event(e));
} }
return results; return results;
@ -1025,13 +1059,6 @@ fn banish(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Res
return results; return results;
} }
fn strike(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Resolutions {
let _amount = source.red_damage();
results.push(Resolution::new(source, target).event(target.deal_red_damage(Skill::Attack, u64::max_value())));
return results;
}
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use skill::*; use skill::*;
@ -1087,7 +1114,7 @@ mod tests {
let Resolution { source: _, target: _, event } = results.remove(0); let Resolution { source: _, target: _, event } = results.remove(0);
match event { match event {
Event::Damage { amount, mitigation: _, category: _ } => assert_eq!(amount, 50), Event::Damage { amount, mitigation: _, category: _, skill: _ } => assert_eq!(amount, 50),
_ => panic!("not damage"), _ => panic!("not damage"),
}; };
} }
@ -1110,7 +1137,7 @@ mod tests {
let Resolution { source: _, target: _, event } = results.remove(0); let Resolution { source: _, target: _, event } = results.remove(0);
match event { match event {
Event::Damage { amount, mitigation: _, category: _ } => assert_eq!(amount, 1023), Event::Damage { amount, mitigation: _, category: _, skill: _ } => assert_eq!(amount, 1023),
_ => panic!("not damage"), _ => panic!("not damage"),
}; };
} }
@ -1139,11 +1166,20 @@ mod tests {
let mut results = attack(&mut x, &mut y, vec![]); let mut results = attack(&mut x, &mut y, vec![]);
assert!(y.hp() == 1024); assert!(y.hp() == 1024);
let Resolution { source: _, target: _, event } = results.remove(0); match results.remove(0).event {
match event { Event::Inversion { skill } => assert_eq!(skill, Skill::Attack),
Event::Inversion { damage: _, healing: _, recharge, category: _ } => assert_eq!(recharge, 64),
_ => panic!("not inversion"), _ => panic!("not inversion"),
}; };
match results.remove(0).event {
Event::Healing { skill: _, overhealing: _, amount } => assert_eq!(amount, 256),
_ => panic!("not healing from inversion"),
};
match results.remove(0).event {
Event::Recharge { skill: _, red, blue: _ } => assert_eq!(red, 64),
_ => panic!("not recharge from inversion"),
};
} }
#[test] #[test]
@ -1163,7 +1199,7 @@ mod tests {
let Resolution { source: _, target: _, event } = results.remove(0); let Resolution { source: _, target: _, event } = results.remove(0);
match event { match event {
Event::Damage { amount, mitigation: _, category: _ } => assert_eq!(amount, 256), Event::Damage { amount, mitigation: _, category: _, skill: _ } => assert_eq!(amount, 256),
_ => panic!("not damage"), _ => panic!("not damage"),
}; };
} }
@ -1226,7 +1262,7 @@ mod tests {
let Resolution { source: _, target: _, event } = results.remove(0); let Resolution { source: _, target: _, event } = results.remove(0);
match event { match event {
Event::Recharge { red, blue } => { Event::Recharge { red, blue, skill: _ } => {
assert!(red == 5); assert!(red == 5);
assert!(blue == 5); assert!(blue == 5);
} }