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

dmg returns vec of events now to clean up log

Browse Source
This commit is contained in:
ntr 2019-03-26 14:21:06 +11:00
parent 9cee9f4bfb
commit 55d5ea09ac
3 changed files with 135 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

110
server/src/cryp.rs
View File

@ -456,12 +456,14 @@ impl Cryp {
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) {
return Event::Immunity {
events.push(Event::Immunity {
immunity,
skill,
};
});
return events;
}
let healing_mods = self.effects.iter()
@ -471,46 +473,52 @@ impl Cryp {
// 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) {
false => {
let current_hp = self.hp();
self.hp.increase(modified_healing);
self.hp.increase(modified_green_damage);
let new_hp = self.hp.value;
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,
overhealing,
};
});
},
true => {
events.push(Event::Inversion { skill });
// there is no green shield (yet)
let current_hp = self.hp();
self.reduce_hp(modified_healing);
self.reduce_hp(modified_green_damage);
let delta = current_hp - self.hp();
return Event::Inversion {
events.push(Event::Damage {
skill,
damage: delta,
healing: 0,
recharge: 0,
amount: delta,
mitigation: 0,
category: Category::GreenDamage,
};
});
}
}
return events;
}
pub fn deal_red_damage(&mut self, skill: Skill, amount: u64) -> Event {
pub fn deal_red_damage(&mut self, skill: Skill, amount: u64) -> Vec<Event> {
let mut events = vec![];
if let Some(immunity) = self.immune(skill) {
return Event::Immunity {
events.push(Event::Immunity {
skill,
immunity,
};
});
return events;
}
let red_damage_mods = self.effects.iter()
@ -539,14 +547,16 @@ impl Cryp {
self.reduce_hp(remainder);
let delta = current_hp - self.hp();
return Event::Damage {
events.push(Event::Damage {
skill,
amount: delta,
mitigation,
category: Category::RedDamage,
};
});
},
true => {
events.push(Event::Inversion { skill });
let current_hp = self.hp();
self.hp.increase(modified_damage);
let new_hp = self.hp.value;
@ -557,23 +567,32 @@ impl Cryp {
self.red_shield.increase(overhealing);
let recharge = self.red_shield.value - current_shield;
return Event::Inversion {
damage: 0,
healing,
recharge,
skill,
category: Category::RedDamage,
};
if healing > 0 {
events.push(Event::Healing {
skill,
amount: healing,
overhealing: overhealing - recharge,
});
}
if recharge > 0 {
events.push(Event::Recharge { red: recharge, blue: 0, skill });
}
}
}
};
return events;
}
pub fn deal_blue_damage(&mut self, skill: Skill, amount: u64) -> Event {
pub fn deal_blue_damage(&mut self, skill: Skill, amount: u64) -> Vec<Event> {
let mut events = vec![];
if let Some(immunity) = self.immune(skill) {
return Event::Immunity {
events.push(Event::Immunity {
skill,
immunity,
};
});
return events;
}
let blue_damage_mods = self.effects.iter()
@ -582,6 +601,7 @@ impl Cryp {
.collect::<Vec<Effect>>();
// println!("{:?}", blue_damage_mods);
let modified_damage = blue_damage_mods.iter().fold(amount, |acc, m| m.apply(acc));
match self.affected(Effect::Invert) {
@ -589,20 +609,24 @@ impl Cryp {
let remainder = modified_damage.saturating_sub(self.blue_shield.value);
let mitigation = modified_damage.saturating_sub(remainder);
// reduce blue_shield by mitigation amount
self.blue_shield.reduce(mitigation);
// deal remainder to hp
let current_hp = self.hp();
self.reduce_hp(remainder);
let delta = current_hp - self.hp();
return Event::Damage {
events.push(Event::Damage {
skill,
amount: delta,
mitigation,
category: Category::BlueDamage,
};
});
},
true => {
events.push(Event::Inversion { skill });
let current_hp = self.hp();
self.hp.increase(modified_damage);
let new_hp = self.hp.value;
@ -613,15 +637,21 @@ impl Cryp {
self.blue_shield.increase(overhealing);
let recharge = self.blue_shield.value - current_shield;
return Event::Inversion {
skill,
damage: 0,
healing,
recharge,
category: Category::BlueDamage,
};
if healing > 0 {
events.push(Event::Healing {
skill,
amount: healing,
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 {

11
server/src/game.rs
View File

@ -516,14 +516,9 @@ impl Game {
self.log.push(format!("[{:}] {:} {:?} {:} {:} ({:}OH)",
speed, source.name, skill, target.name, amount, overhealing)),
Event::Inversion { skill, healing, damage, recharge, category: _ } => {
match *healing > 0 {
true => self.log.push(format!("[{:}] {:} {:?} {:} INVERTED {:} ({:} recharge)",
speed, source.name, skill, target.name, healing, recharge)),
false => self.log.push(format!("[{:}] {:} {:?} {:} INVERTED {:}",
speed, source.name, skill, target.name, damage)),
}
},
Event::Inversion { skill } =>
self.log.push(format!("[{:}] {:} {:?} {:} INVERTED",
speed, source.name, skill, target.name)),
Event::Effect { skill, effect, duration } =>
self.log.push(format!("[{:}] {:} {:?} {:} {:?} {:}T",

88
server/src/skill.rs
View File

@ -77,7 +77,7 @@ pub enum Event {
Damage { skill: Skill, amount: u64, mitigation: u64, category: Category },
Healing { skill: Skill, amount: u64, overhealing: u64 },
Recharge { skill: Skill, red: u64, blue: u64 },
Inversion { skill: Skill, healing: u64, damage: u64, recharge: u64, category: Category },
Inversion { skill: Skill },
Effect { skill: Skill, effect: Effect, duration: u8 },
Removal { effect: Effect },
Evasion { skill: Skill, evasion_rating: u64 },
@ -746,16 +746,32 @@ impl Skill {
}
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;
}
fn attack(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, amount)));
target.deal_red_damage(Skill::Attack, amount)
.into_iter()
.for_each(|e| results.push(Resolution::new(source, target).event(e)));
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 {
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)));
@ -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 {
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
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 {
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;
}
@ -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 {
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;
}
fn blast(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Resolutions {
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;
}
@ -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 {
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;
}
@ -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 {
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;
}
@ -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 {
let amount = source.blue_damage();
let siphon_damage = target.deal_blue_damage(Skill::SiphonTick, amount);
results.push(Resolution::new(source, target).event(siphon_damage.clone()));
let siphon_events = target.deal_blue_damage(Skill::SiphonTick, amount);
match siphon_damage {
Event::Damage { amount, mitigation: _, category: _, skill: _ } => {
results.push(Resolution::new(source, source).event(source.deal_green_damage(Skill::Heal, amount)));
},
_ => panic!("siphon tick damage not dealt {:?}", siphon_damage),
for e in siphon_events {
match e {
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));
};
},
_ => (),
}
results.push(Resolution::new(source, target).event(e));
}
return results;
@ -1025,13 +1059,6 @@ fn banish(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Res
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)]
mod tests {
use skill::*;
@ -1139,11 +1166,20 @@ mod tests {
let mut results = attack(&mut x, &mut y, vec![]);
assert!(y.hp() == 1024);
let Resolution { source: _, target: _, event } = results.remove(0);
match event {
Event::Inversion { damage: _, healing: _, recharge, category: _, skill: _ } => assert_eq!(recharge, 64),
match results.remove(0).event {
Event::Inversion { skill } => assert_eq!(skill, Skill::Attack),
_ => 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]