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

add u8 to resolution struct for breaking up resolution parts

Browse Source
This commit is contained in:
Mashy 2019-05-31 16:20:33 +10:00
parent c7ee7361dd
commit b10c4f988c
4 changed files with 112 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
client/src/events.jsx
View File

@ -43,7 +43,7 @@ function registerEvents(store) {
return eachSeries(newRes, (r, cb) => {
if (['Disable', 'TargetKo'].includes(r.event[0])) return cb();
// Create sub events for combat animations
const sequence = getCombatSequence(r.event);
const sequence = getCombatSequence(r);
return eachSeries(sequence, (stage, sCb) => {
const { skip } = store.getState();
if (skip) return sCb();

46
client/src/utils.jsx
View File

@ -276,38 +276,22 @@ function eventClasses(resolution, construct) {
return '';
}
function getCombatSequence(event) {
if (!event) return false;
// Skip combat animations depending on event type, expandable in future
if (['Inversion'].includes(event[0])) return false;
if (['Skill', 'AoeSkill'].includes(event[0])) return ['START_SKILL', 'END_SKILL'];
if (['Immunity'].includes(event[0])) return ['START_SKILL', 'POST_SKILL'];
if (['Removal'].includes(event[0])) return ['POST_SKILL'];
function getCombatSequence(resolution) {
if (!resolution.event) return false;
if (resolution.event[0] === 'Inversion') return false;
if (resolution.event[0] === 'Skill') return ['START_SKILL', 'END_SKILL'];
if (resolution.event[0] === 'Ko') return ['POST_SKILL'];
if (['Healing'].includes(event[0])
&& (event[1].skill.includes('Slay')
|| event[1].skill.includes('SiphonTick')
|| event[1].skill.includes('Purify')
|| event[1].skill.includes('Sleep'))) return ['POST_SKILL'];
if (['Recharge'].includes(event[0])
&& (event[1].skill.includes('Reflect'))) return ['POST_SKILL'];
if (event[0] === 'Effect'
&& (['Ruin', 'Taunt', 'Strangling', 'Parry'].includes(event[1].skill)
|| (event[1].skill.includes('Decay') && event[1].effect === 'Wither'))) return ['POST_SKILL'];
if (['Power'].includes(event[0])
&& ((event[1].skill.includes('Chaos') && event[1].colour === 'Red')
|| event[1].skill.includes('Silence')
|| event[1].skill.includes('Snare'))) return ['POST_SKILL'];
if (['Ko'].includes(event[0])
|| (event[1].skill.includes('Throw') && event[1].effect === 'Vulnerable')) return ['POST_SKILL'];
if (['Tick'].includes(event[1].skill)) return ['END_SKILL', 'POST_SKILL'];
return ['START_SKILL', 'END_SKILL', 'POST_SKILL'];
switch (resolution.stages) {
case 1: return ['START_SKILL', 'END_SKILL'];
case 2: return ['START_SKILL', 'POST_SKILL'];
case 3: return ['START_SKILL'];
case 4: return ['END_SKILL', 'POST_SKILL'];
case 5: return ['END_SKILL'];
case 6: return ['POST_SKILL'];
case 7: return false;
default: return ['START_SKILL', 'END_SKILL', 'POST_SKILL'];
}
}
function getCombatText(construct, resolution) {

24
server/src/game.rs
View File

@ -495,7 +495,7 @@ impl Game {
}
fn log_resolution(&mut self, speed: u64, resolution: &Resolution) -> &mut Game {
let Resolution { source, target, event } = resolution;
let Resolution { source, target, event, stages } = resolution;
match event {
Event::Ko { skill: _ }=>
self.log.push(format!("{:} KO!", target.name)),
@ -532,10 +532,6 @@ impl Game {
self.log.push(format!("[{:}] {:} {:?} {:} {:?} {:}T",
speed, source.name, skill, target.name, effect, duration)),
Event::AoeSkill { skill } =>
self.log.push(format!("[{:}] {:} {:?} {:}",
speed, source.name, skill, target.name)),
Event::Skill { skill } =>
self.log.push(format!("[{:}] {:} {:?} {:}",
speed, source.name, skill, target.name)),
@ -1263,13 +1259,13 @@ mod tests {
game = game.resolve_phase_start();
assert!(game.construct_by_id(x_construct.id).unwrap().affected(Effect::Scatter));
let Resolution { source: _, target: _, event } = game.resolved.pop().unwrap();
let Resolution { source: _, target: _, event, stages: _ } = game.resolved.pop().unwrap();
match event {
Event::Effect { effect, skill: _, duration: _, construct_effects: _ } => assert_eq!(effect, Effect::Scatter),
_ => panic!("not siphon"),
};
let Resolution { source: _, target: _, event } = game.resolved.pop().unwrap();
let Resolution { source: _, target: _, event, stages: _ } = game.resolved.pop().unwrap();
match event {
Event::Recharge { red: _, blue: _, skill: _ } => (),
_ => panic!("scatter result was not recharge"),
@ -1281,7 +1277,7 @@ mod tests {
game.player_ready(y_player.id).unwrap();
game = game.resolve_phase_start();
let Resolution { source: _, target, event } = game.resolved.pop().unwrap();
let Resolution { source: _, target, event, stages: _ } = game.resolved.pop().unwrap();
assert_eq!(target.id, y_construct.id);
match event {
Event::Damage { amount, skill: _, mitigation: _, colour: _} =>
@ -1354,7 +1350,7 @@ mod tests {
let ruins = game.resolved
.into_iter()
.filter(|r| {
let Resolution { source, target: _, event } = r;
let Resolution { source, target: _, event, stages: _ } = r;
match source.id == x_construct.id {
true => match event {
Event::Effect { effect, duration, skill: _, construct_effects: _ } => {
@ -1362,7 +1358,7 @@ mod tests {
assert!(*duration == 1);
true
},
Event::AoeSkill { skill: _ } => false,
Event::Skill { skill: _ } => false,
_ => panic!("ruin result not effect {:?}", event),
}
false => false,
@ -1403,7 +1399,7 @@ mod tests {
assert!(game.resolved.len() == 5);
while let Some(r) = game.resolved.pop() {
let Resolution { source , target, event: _ } = r;
let Resolution { source , target, event: _, stages: _ } = r;
if [i_construct.id, j_construct.id].contains(&source.id) {
assert!(target.id == x_construct.id);
}
@ -1493,7 +1489,7 @@ mod tests {
game = game.resolve_phase_start();
assert!(game.construct_by_id(y_construct.id).unwrap().affected(Effect::Decay));
let Resolution { source: _, target: _, event } = game.resolved.pop().unwrap();
let Resolution { source: _, target: _, event, stages: _ } = game.resolved.pop().unwrap();
match event {
Event::Damage { amount: _, skill, mitigation: _, colour: _ } => assert_eq!(skill, Skill::DecayTickI),
_ => panic!("not decay"),
@ -1507,7 +1503,7 @@ mod tests {
game.player_ready(y_player.id).unwrap();
game = game.resolve_phase_start();
while let Some(Resolution { source: _, target: _, event }) = game.resolved.pop() {
while let Some(Resolution { source: _, target: _, event, stages: _ }) = game.resolved.pop() {
match event {
Event::Damage { amount: _, skill: _, mitigation: _, colour: _ } =>
panic!("{:?} damage event", event),
@ -1527,7 +1523,7 @@ mod tests {
game.player_ready(y_player.id).unwrap();
game = game.resolve_phase_start();
while let Some(Resolution { source: _, target: _, event }) = game.resolved.pop() {
while let Some(Resolution { source: _, target: _, event, stages: _ }) = game.resolved.pop() {
match event {
Event::Damage { amount: _, skill: _, mitigation: _, colour: _ } =>
panic!("{:#?} {:#?} damage event", game.resolved, event),

133
server/src/skill.rs
View File

@ -22,7 +22,7 @@ pub fn pre_resolve(cast: &Cast, game: &mut Game, mut resolutions: Resolutions) -
if skill.aoe() { // Send an aoe skill event for anims
resolutions.push(Resolution::new(&source,
&game.construct_by_id(cast.target_construct_id).unwrap().clone()).event(Event::AoeSkill { skill }));
&game.construct_by_id(cast.target_construct_id).unwrap().clone()).event(Event::Skill { skill }));
}
for target_id in targets {
@ -282,7 +282,7 @@ pub fn resolve(skill: Skill, source: &mut Construct, target: &mut Construct, mut
}
fn post_resolve(_skill: Skill, game: &mut Game, mut resolutions: Resolutions) -> Resolutions {
for Resolution { source, target, event } in resolutions.clone() {
for Resolution { source, target, event, stages: _ } in resolutions.clone() {
let mut source = game.construct_by_id(source.id).unwrap().clone();
let mut target = game.construct_by_id(target.id).unwrap().clone();
@ -393,11 +393,24 @@ pub struct LogConstruct {
pub blue: u64,
}
#[derive(Debug,Clone,PartialEq,Serialize,Deserialize)]
pub enum LogStages {
AllStages, // 0 Anim Anim Anim
StartEnd, // 1 Anim Anim Skip
StartPost, // 2 Anim Skip Anim
StartOnly, // 3 Anim Skip Skip
EndPost, // 4 Skip Anim Anim
EndOnly, // 5 Skip Anim Skip
PostOnly, // 6 Skip Skip Anim
None, // 7 Skip Skip Skip
}
#[derive(Debug,Clone,PartialEq,Serialize,Deserialize)]
pub struct Resolution {
pub source: LogConstruct,
pub target: LogConstruct,
pub event: Event,
pub stages: u8,
}
impl Resolution {
@ -418,6 +431,7 @@ impl Resolution {
blue: target.blue_life(),
},
event: Event::Incomplete,
stages: LogStages::AllStages as u8,
}
}
@ -425,6 +439,11 @@ impl Resolution {
self.event = e;
self
}
fn stages(mut self, s: LogStages) -> Resolution {
self.stages = s as u8;
self
}
}
@ -437,7 +456,6 @@ pub enum Event {
Recharge { skill: Skill, red: u64, blue: u64 },
Inversion { skill: Skill },
Reflection { skill: Skill },
AoeSkill { skill: Skill },
Skill { skill: Skill },
Effect { skill: Skill, effect: Effect, duration: u8, construct_effects: Vec<ConstructEffect> },
Removal { effect: Effect, construct_effects: Vec<ConstructEffect> },
@ -1486,7 +1504,7 @@ fn sleep(source: &mut Construct, target: &mut Construct, mut results: Resolution
let amount = source.green_power().pct(skill.multiplier());
target.deal_green_damage(skill, amount)
.into_iter()
.for_each(|e| results.push(Resolution::new(source, target).event(e)));
.for_each(|e| results.push(Resolution::new(source, target).event(e).stages(LogStages::PostOnly)));
return results;
}
@ -1501,14 +1519,17 @@ fn taunt(source: &mut Construct, target: &mut Construct, mut results: Resolution
let red_amount = source.red_power().pct(skill.multiplier());
results.push(Resolution::new(source, target).event(target.recharge(skill, red_amount, 0)));
skill.effect().into_iter()
.for_each(|e| (results.push(Resolution::new(source, target).event(target.add_effect(skill, e)))));
let taunt = skill.effect()[0];
results.push(Resolution::new(source, target).event(target.add_effect(skill, taunt)).stages(LogStages::PostOnly));
return results;
}
fn throw(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions {
skill.effect().into_iter()
.for_each(|e| (results.push(Resolution::new(source, target).event(target.add_effect(skill, e)))));
let stun = skill.effect()[0];
results.push(Resolution::new(source, target).event(target.add_effect(skill, stun)));
let vuln = skill.effect()[1];
results.push(Resolution::new(source, target).event(target.add_effect(skill, vuln)).stages(LogStages::PostOnly));
return results;
}
@ -1522,7 +1543,7 @@ fn strangle(source: &mut Construct, target: &mut Construct, mut results: Resolut
results.push(Resolution::new(source, target).event(target.add_effect(skill, strangle)));
let attacker_strangle = ConstructEffect::new(Effect::Strangling, duration);
results.push(Resolution::new(source, source).event(source.add_effect(skill, attacker_strangle)));
results.push(Resolution::new(source, source).event(source.add_effect(skill, attacker_strangle)).stages(LogStages::PostOnly));
return strangle_tick(source, target, results, tick_skill);
}
@ -1530,7 +1551,7 @@ fn strangle_tick(source: &mut Construct, target: &mut Construct, mut results: Re
let amount = source.red_power().pct(skill.multiplier());
target.deal_red_damage(skill, amount)
.into_iter()
.for_each(|e| results.push(Resolution::new(source, target).event(e)));
.for_each(|e| results.push(Resolution::new(source, target).event(e).stages(LogStages::EndPost)));
// remove immunity if target ko
if target.is_ko() {
@ -1540,30 +1561,36 @@ fn strangle_tick(source: &mut Construct, target: &mut Construct, mut results: Re
.expect("no strangling on construct");
source.effects.remove(i);
results.push(Resolution::new(source, source)
.event(Event::Removal { effect: Effect::Strangling, construct_effects: target.effects.clone() }));
.event(Event::Removal { effect: Effect::Strangling, construct_effects: target.effects.clone() })
.stages(LogStages::PostOnly));
}
return results;
}
fn block(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions {
skill.effect().into_iter()
.for_each(|e| (results.push(Resolution::new(source, target).event(target.add_effect(skill, e)))));
results.push(Resolution::new(source, target)
.event(target.add_effect(skill, skill.effect()[0]))
.stages(LogStages::StartEnd));
return results;
}
fn buff(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions {
skill.effect().into_iter()
.for_each(|e| (results.push(Resolution::new(source, target).event(target.add_effect(skill, e)))));
results.push(Resolution::new(source, target)
.event(target.add_effect(skill, skill.effect()[0])));
return results;
}
fn parry(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions {
let red_amount = source.red_power().pct(skill.multiplier());
results.push(Resolution::new(source, target).event(target.recharge(skill, red_amount, 0)));
results.push(Resolution::new(source, target)
.event(target.recharge(skill, red_amount, 0))
.stages(LogStages::StartEnd));
results.push(Resolution::new(source, target)
.event(target.add_effect(skill, skill.effect()[0]))
.stages(LogStages::PostOnly));
skill.effect().into_iter()
.for_each(|e| (results.push(Resolution::new(source, target).event(target.add_effect(skill, e)))));
return results;
}
@ -1571,7 +1598,7 @@ fn riposte(source: &mut Construct, target: &mut Construct, mut results: Resoluti
let amount = source.red_power().pct(skill.multiplier());
target.deal_red_damage(skill, amount)
.into_iter()
.for_each(|e| results.push(Resolution::new(source, target).event(e)));
.for_each(|e| results.push(Resolution::new(source, target).event(e).stages(LogStages::StartPost)));
return results;
}
@ -1590,7 +1617,7 @@ fn snare(source: &mut Construct, target: &mut Construct, mut results: Resolution
let amount = source.red_power().pct(skill.multiplier()).pct(s_multi);
target.deal_red_damage(skill, amount)
.into_iter()
.for_each(|e| results.push(Resolution::new(source, target).event(e)));
.for_each(|e| results.push(Resolution::new(source, target).event(e).stages(LogStages::PostOnly)));
return results;
@ -1606,7 +1633,7 @@ fn slay(source: &mut Construct, target: &mut Construct, mut results: Resolutions
results.push(Resolution::new(source, target).event(e));
let heal = source.deal_green_damage(skill, amount);
for h in heal {
results.push(Resolution::new(source, source).event(h));
results.push(Resolution::new(source, source).event(h).stages(LogStages::PostOnly));
};
},
_ => results.push(Resolution::new(source, target).event(e)),
@ -1639,7 +1666,7 @@ fn triage_tick(source: &mut Construct, target: &mut Construct, mut results: Reso
let amount = source.green_power().pct(skill.multiplier());
target.deal_green_damage(skill, amount)
.into_iter()
.for_each(|e| results.push(Resolution::new(source, target).event(e)));
.for_each(|e| results.push(Resolution::new(source, target).event(e).stages(LogStages::EndPost)));
return results;
}
@ -1654,7 +1681,7 @@ fn chaos(source: &mut Construct, target: &mut Construct, mut results: Resolution
let amount = source.red_power().pct(skill.multiplier()).pct(r_rng);
target.deal_red_damage(skill, amount)
.into_iter()
.for_each(|e| results.push(Resolution::new(source, target).event(e)));
.for_each(|e| results.push(Resolution::new(source, target).event(e).stages(LogStages::PostOnly)));
return results;
}
@ -1692,7 +1719,9 @@ fn decay(source: &mut Construct, target: &mut Construct, mut results: Resolution
_ => panic!("no decay tick skill"),
};
let decay = ConstructEffect::new(effect, duration).set_tick(Cast::new_tick(source, target, tick_skill));
results.push(Resolution::new(source, target).event(target.add_effect(skill, decay)));
results.push(Resolution::new(source, target)
.event(target.add_effect(skill, decay))
.stages(LogStages::PostOnly));
return decay_tick(source, target, results, tick_skill);
}
@ -1701,7 +1730,7 @@ fn decay_tick(source: &mut Construct, target: &mut Construct, mut results: Resol
let amount = source.blue_power().pct(skill.multiplier());
target.deal_blue_damage(skill, amount)
.into_iter()
.for_each(|e| results.push(Resolution::new(source, target).event(e)));
.for_each(|e| results.push(Resolution::new(source, target).event(e).stages(LogStages::EndPost)));
return results;
}
@ -1721,7 +1750,9 @@ fn corruption(source: &mut Construct, target: &mut Construct, mut results: Resol
_ => panic!("no corruption tick skill"),
};
let corruption = ConstructEffect::new(effect, duration).set_tick(Cast::new_tick(source, target, tick_skill));
results.push(Resolution::new(source, target).event(target.add_effect(skill, corruption)));
results.push(Resolution::new(source, target)
.event(target.add_effect(skill, corruption))
.stages(LogStages::StartPost));
return corruption_tick(source, target, results, tick_skill);
}
@ -1729,12 +1760,14 @@ fn corruption_tick(source: &mut Construct, target: &mut Construct, mut results:
let amount = source.blue_power().pct(skill.multiplier());
target.deal_blue_damage(skill, amount)
.into_iter()
.for_each(|e| results.push(Resolution::new(source, target).event(e)));
.for_each(|e| results.push(Resolution::new(source, target).event(e).stages(LogStages::EndPost)));
return results;
}
fn ruin(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions {
results.push(Resolution::new(source, target).event(target.add_effect(skill, skill.effect()[0])));
results.push(Resolution::new(source, target)
.event(target.add_effect(skill, skill.effect()[0]))
.stages(LogStages::PostOnly));
return results;;
}
@ -1751,7 +1784,9 @@ fn hostility(source: &mut Construct, target: &mut Construct, mut results: Resolu
fn hatred(source: &mut Construct, target: &mut Construct, mut results: Resolutions, reflect_skill: Skill, amount: u64, skill: Skill) -> Resolutions {
let hatred = skill.effect()[0].set_meta(EffectMeta::AddedDamage(amount));
results.push(Resolution::new(source, target).event(target.add_effect(reflect_skill, hatred)));
results.push(Resolution::new(source, target)
.event(target.add_effect(reflect_skill, hatred))
.stages(LogStages::PostOnly));
return results;;
}
@ -1774,7 +1809,9 @@ fn reflect(source: &mut Construct, target: &mut Construct, mut results: Resoluti
results.push(Resolution::new(source, target).event(target.add_effect(skill, skill.effect()[0])));
let blue_amount = source.blue_power().pct(skill.multiplier());
results.push(Resolution::new(source, target).event(target.recharge(skill, 0, blue_amount)));
results.push(Resolution::new(source, target)
.event(target.recharge(skill, 0, blue_amount))
.stages(LogStages::PostOnly));
return results;;
}
@ -1806,13 +1843,13 @@ fn siphon_tick(source: &mut Construct, target: &mut Construct, mut results: Reso
for e in siphon_events {
match e {
Event::Damage { amount, mitigation: _, colour: _, skill: _ } => {
results.push(Resolution::new(source, target).event(e));
results.push(Resolution::new(source, target).event(e).stages(LogStages::EndPost));
let heal = source.deal_green_damage(skill, amount);
for h in heal {
results.push(Resolution::new(source, source).event(h));
results.push(Resolution::new(source, source).event(h).stages(LogStages::PostOnly));
};
},
_ => results.push(Resolution::new(source, target).event(e)),
_ => results.push(Resolution::new(source, target).event(e).stages(LogStages::EndPost)),
}
}
@ -1824,7 +1861,7 @@ fn scatter(source: &mut Construct, target: &mut Construct, mut results: Resoluti
results.push(Resolution::new(source, target).event(target.recharge(skill, 0, blue_amount)));
let scatter = skill.effect()[0].set_meta(EffectMeta::ScatterTarget(target.id));
results.push(Resolution::new(source, target).event(source.add_effect(skill, scatter)));
results.push(Resolution::new(source, target).event(source.add_effect(skill, scatter)).stages(LogStages::PostOnly));
return results;
}
@ -1844,7 +1881,8 @@ fn scatter_hit(source: &Construct, target: &Construct, mut results: Resolutions,
};
results.push(Resolution::new(target, scatter_target).event(Event::Skill { skill: Skill::ScatterI }));
res.into_iter().for_each(|e| results.push(Resolution::new(&source, &scatter_target).event(e)));
res.into_iter().for_each(|e| results.push(Resolution::new(&source, &scatter_target)
.event(e).stages(LogStages::EndPost)));
} else {
panic!("not a scatter target {:?}", scatter);
}
@ -1868,7 +1906,7 @@ fn silence(source: &mut Construct, target: &mut Construct, mut results: Resoluti
let amount = source.blue_power().pct(skill.multiplier()).pct(s_multi);
target.deal_blue_damage(skill, amount)
.into_iter()
.for_each(|e| results.push(Resolution::new(source, target).event(e)));
.for_each(|e| results.push(Resolution::new(source, target).event(e).stages(LogStages::PostOnly)));
return results;
}
@ -1893,10 +1931,11 @@ fn purify(source: &mut Construct, target: &mut Construct, mut results: Resolutio
.position(|ce| ce.effect.category() == EffectCategory::Debuff) {
let ce = target.effects.remove(i);
results.push(Resolution::new(source, target)
.event(Event::Removal { effect: ce.effect, construct_effects: target.effects.clone() }));
.event(Event::Removal { effect: ce.effect, construct_effects: target.effects.clone() })
.stages(LogStages::PostOnly));
target.deal_green_damage(skill, amount)
.into_iter()
.for_each(|e| results.push(Resolution::new(source, target).event(e)));
.for_each(|e| results.push(Resolution::new(source, target).event(e).stages(LogStages::PostOnly)));
}
return results;
@ -1960,7 +1999,7 @@ mod tests {
let mut results = attack(&mut x, &mut y, vec![], Skill::Attack);
let Resolution { source: _, target: _, event } = results.remove(0);
let Resolution { source: _, target: _, event, stages: _ } = results.remove(0);
match event {
Event::Damage { amount, mitigation: _, colour: _, skill: _ } =>
assert!(amount < x.red_power().pct(Skill::Attack.multiplier())),
@ -1982,7 +2021,7 @@ mod tests {
assert!(y.affected(Effect::Clutch));
let mut results = hex(&mut x, &mut y, vec![], Skill::HexI);
let Resolution { source: _, target: _, event } = results.remove(0);
let Resolution { source: _, target: _, event, stages: _ } = results.remove(0);
match event {
Event::Immunity { skill: _, immunity } => assert!(immunity.contains(&Effect::Clutch)),
_ => panic!("not immune cluthc"),
@ -1991,7 +2030,7 @@ mod tests {
let mut results = attack(&mut x, &mut y, vec![], Skill::Attack);
assert!(y.green_life() == 1);
let Resolution { source: _, target: _, event } = results.remove(0);
let Resolution { source: _, target: _, event, stages: _ } = results.remove(0);
match event {
Event::Damage { amount, mitigation: _, colour: _, skill: _ } => assert_eq!(amount, 1023),
_ => panic!("not damage"),
@ -2065,13 +2104,13 @@ mod tests {
assert!(x.green_life() < 1024);
let Resolution { source: _, target: _, event } = results.remove(0);
let Resolution { source: _, target: _, event, stages: _ } = results.remove(0);
match event {
Event::Reflection { skill } => assert_eq!(skill, Skill::Attack),
_ => panic!("not reflection"),
};
let Resolution { source: _, target: _, event } = results.remove(0);
let Resolution { source: _, target: _, event, stages: _ } = results.remove(0);
match event {
Event::Damage { amount, mitigation: _, colour: _, skill: _ } => assert!(amount > 0),
_ => panic!("not damage"),
@ -2093,19 +2132,19 @@ mod tests {
assert!(y.affected(Effect::Siphon));
assert!(x.green_life() == (512 + 256.pct(Skill::SiphonTickI.multiplier())));
let Resolution { source: _, target: _, event } = results.remove(0);
let Resolution { source: _, target: _, event, stages: _ } = results.remove(0);
match event {
Event::Effect { effect, skill: _, duration: _, construct_effects: _ } => assert_eq!(effect, Effect::Siphon),
_ => panic!("not siphon"),
};
let Resolution { source: _, target: _, event } = results.remove(0);
let Resolution { source: _, target: _, event, stages: _ } = results.remove(0);
match event {
Event::Damage { amount, skill: _, mitigation: _, colour: _} => assert_eq!(amount, 256.pct(Skill::SiphonTickI.multiplier())),
_ => panic!("not damage siphon"),
};
let Resolution { source: _, target, event } = results.remove(0);
let Resolution { source: _, target, event, stages: _ } = results.remove(0);
match event {
Event::Healing { amount, skill: _, overhealing: _ } => {
assert_eq!(amount, 256.pct(Skill::SiphonTickI.multiplier()));
@ -2155,7 +2194,7 @@ mod tests {
let mut results = recharge(&mut x, &mut y, vec![], Skill::RechargeI);
let Resolution { source: _, target: _, event } = results.remove(0);
let Resolution { source: _, target: _, event, stages: _ } = results.remove(0);
match event {
Event::Recharge { red, blue, skill: _ } => {
assert!(red == 5);