remove finalise

This commit is contained in:
ntr 2019-03-25 16:46:17 +11:00
parent ab2549219d
commit d35e1ede60
3 changed files with 127 additions and 140 deletions

View File

@ -22,9 +22,6 @@ ensure all skills impl
Skill::Slay -> red attack with bonus somethingorother for blue / maim no healing
Hatred -> damage received converted into bonus dmg
aoe
Skill::Ruin -> aoe stun
on attack
Skill::Taunt -> redirect incomnig attacks to self
Skill::Toxic -> apply debuff to attackers

View File

@ -168,17 +168,6 @@ impl Game {
}
}
pub fn cryp_name(&mut self, id: Uuid) -> String {
match self.teams.iter_mut().find(|t| t.cryps.iter().any(|c| c.id == id)) {
Some(team) => {
let cryp = team.cryps.iter_mut().find(|c| c.id == id).expect("cryp not in team");
return cryp.name.clone();
}
None => panic!("{:?} not in game", id),
}
}
fn all_cryps(&self) -> Vec<Cryp> {
self.teams.clone()
.into_iter()
@ -188,16 +177,6 @@ impl Game {
.collect::<Vec<Cryp>>()
}
pub fn cryp_aoe_targets(&self, cryp_id: Uuid) -> Vec<Uuid> {
self.teams.iter()
.find(|t| t.cryps.iter().any(|c| c.id == cryp_id))
.unwrap()
.cryps
.iter()
.map(|c| c.id)
.collect()
}
fn update_cryp(&mut self, cryp: &mut Cryp) -> &mut Game {
match self.teams.iter_mut().find(|t| t.cryps.iter().any(|c| c.id == cryp.id)) {
Some(team) => {
@ -372,79 +351,47 @@ impl Game {
self.resolve_skills()
}
// remove names from the cast
// put them in teh result
// just add the results to the resolved vec
// try remove casts altogether
fn log_resolution(&mut self, cast: &Cast) -> &mut Game {
for resolution in cast.resolutions.iter() {
let Resolution { source, target, event } = resolution;
match event {
Event::Disable { disable } =>
self.log.push(format!("{:} {:?} {:} disabled {:?}",
source.name, cast.skill, target.name, disable)),
Event::Immunity { immunity } =>
self.log.push(format!("[{:}] {:} {:?} {:} immune {:?}",
cast.speed, source.name, cast.skill, target.name, immunity)),
Event::TargetKo =>
self.log.push(format!("[{:}] {:} {:?} {:} - KO",
cast.speed, source.name, cast.skill, target.name)),
Event::Damage { amount, mitigation, category: _ } =>
self.log.push(format!("[{:}] {:} {:?} {:} {:} ({:} mitigated)",
cast.speed, source.name, cast.skill, target.name, amount, mitigation)),
Event::Healing { amount, overhealing } =>
self.log.push(format!("[{:}] {:} {:?} {:} {:} ({:}OH)",
cast.speed, source.name, cast.skill, target.name, amount, overhealing)),
Event::Inversion { healing, damage, recharge, category: _ } => {
match *healing > 0 {
true => self.log.push(format!("[{:}] {:} {:?} {:} INVERTED {:} ({:} recharge)",
cast.speed, source.name, cast.skill, target.name, healing, recharge)),
false => self.log.push(format!("[{:}] {:} {:?} {:} INVERTED {:}",
cast.speed, source.name, cast.skill, target.name, damage)),
}
},
Event::Effect { effect, duration } =>
self.log.push(format!("[{:}] {:} {:?} {:} {:?} {:}T",
cast.speed, source.name, cast.skill, target.name, effect, duration)),
Event::Removal { effect } =>
self.log.push(format!("[{:}] {:?} removed {:} {:?}",
cast.speed, source.name, target.name, effect)),
Event::Recharge { red, blue } =>
self.log.push(format!("[{:}] {:} {:?} {:} {:}R {:}B",
cast.speed, source.name, cast.skill, target.name, red, blue)),
Event::Evasion { skill: _, evasion_rating } =>
self.log.push(format!("[{:}] {:} {:?} {:} evaded ({:}%)",
cast.speed, source.name, cast.skill, target.name, evasion_rating)),
Event::Incomplete => panic!("incomplete resolution {:?}", resolution),
}
}
self
}
fn stack_sort_speed(&mut self) -> &mut Game {
let mut sorted = self.stack.clone();
sorted.sort_unstable_by_key(|s| -> u64 {
let caster = self.cryp_by_id(s.source_cryp_id).unwrap();
caster.skill_speed(s.skill)
});
sorted.iter_mut()
.for_each(|s| {
let caster = self.cryp_by_id(s.source_cryp_id).unwrap();
let speed = caster.skill_speed(s.skill);
s.speed = speed;
});
sorted.sort_unstable_by_key(|s| s.speed);
self.stack = sorted;
self
}
fn cryp_aoe_targets(&self, cryp_id: Uuid) -> Vec<Uuid> {
self.teams.iter()
.find(|t| t.cryps.iter().any(|c| c.id == cryp_id))
.unwrap()
.cryps
.iter()
.map(|c| c.id)
.collect()
}
fn get_targets(&self, skill: Skill, source: &Cryp, target_cryp_id: Uuid) -> Vec<Uuid> {
// match self.teams.iter_mut().find(|t| t.cryps.iter().any(|c| c.id == id)) {
// Some(team) => team.cryps.iter_mut().find(|c| c.id == id),
// None => None,
// }
// let target_team = self.teams.iter_mut().find(|t| t.cryps.iter().any(|c| c.id == id)).unwrap();
// let target = team.cryps.iter_mut().find(|c| c.id == id).unwrap();
match source.skill_is_aoe(skill) {
true => self.cryp_aoe_targets(target_cryp_id),
false => vec![target_cryp_id],
}
}
fn resolve_skills(mut self) -> Game {
if self.phase != Phase::Resolve {
panic!("game not in Resolve phase");
@ -469,35 +416,31 @@ impl Game {
// because need to check cooldown use before pushing them into the complete list
let mut resolving = vec![];
while let Some(mut cast) = self.stack.pop() {
while let Some(cast) = self.stack.pop() {
// println!("{:} resolving ", cast);
cast.finalise(&mut self);
let mut resolutions = vec![];
let mut source = self.cryp_by_id(cast.source_cryp_id).unwrap().clone();
self.log_resolution(&cast);
let targets = self.get_targets(cast.skill, &source, cast.target_cryp_id);
for target_id in targets {
// let mut source = game.cryp_by_id(self.source_cryp_id).unwrap();
let mut target = self.cryp_by_id(target_id).unwrap();
resolutions.append(&mut cast.skill.resolve(&mut source, target));
}
// the results go into the resolutions
self.resolved.append(&mut cast.resolutions);
while let Some(resolution) = resolutions.pop() {
// fixme for mash
self.log_resolution(cast.speed, cast.skill, &resolution);
// the results go into the resolutions
self.resolved.push(resolution);
}
// the cast itself goes into this temp vec
// to handle cooldowns
resolving.push(cast);
// if target.is_ko() && !target.ko_logged {
// self.log.push(format!("{:} KO", target.name));
// target.effects.clear();
// target.ko_logged = true;
// }
// if source.is_ko() && !source.ko_logged {
// self.log.push(format!("{:} KO", source.name));
// source.effects.clear();
// source.ko_logged = true;
// }
// self.update_cryp(&mut source);
// self.update_cryp(&mut target);
// sort the stack again in case speeds have changed
self.stack_sort_speed();
};
@ -543,6 +486,60 @@ impl Game {
self
}
fn log_resolution(&mut self, speed: u64, skill: Skill, resolution: &Resolution) -> &mut Game {
let Resolution { source, target, event } = resolution;
match event {
Event::Disable { disable } =>
self.log.push(format!("{:} {:?} {:} disabled {:?}",
source.name, skill, target.name, disable)),
Event::Immunity { immunity } =>
self.log.push(format!("[{:}] {:} {:?} {:} immune {:?}",
speed, source.name, skill, target.name, immunity)),
Event::TargetKo =>
self.log.push(format!("[{:}] {:} {:?} {:} - KO",
speed, source.name, skill, target.name)),
Event::Damage { amount, mitigation, category: _ } =>
self.log.push(format!("[{:}] {:} {:?} {:} {:} ({:} mitigated)",
speed, source.name, skill, target.name, amount, mitigation)),
Event::Healing { amount, overhealing } =>
self.log.push(format!("[{:}] {:} {:?} {:} {:} ({:}OH)",
speed, source.name, skill, target.name, amount, overhealing)),
Event::Inversion { 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::Effect { effect, duration } =>
self.log.push(format!("[{:}] {:} {:?} {:} {:?} {:}T",
speed, source.name, skill, target.name, effect, duration)),
Event::Removal { effect } =>
self.log.push(format!("[{:}] {:?} removed {:} {:?}",
speed, source.name, target.name, effect)),
Event::Recharge { red, blue } =>
self.log.push(format!("[{:}] {:} {:?} {:} {:}R {:}B",
speed, source.name, skill, target.name, red, blue)),
Event::Evasion { skill: _, evasion_rating } =>
self.log.push(format!("[{:}] {:} {:?} {:} evaded ({:}%)",
speed, source.name, skill, target.name, evasion_rating)),
Event::Incomplete => panic!("incomplete resolution {:?}", resolution),
}
self
}
pub fn finished(&self) -> bool {
self.teams.iter().any(|t| t.cryps.iter().all(|c| c.is_ko()))
}
@ -1141,7 +1138,7 @@ mod tests {
assert!(effect == Effect::Ruin);
assert!(duration == 1);
}
_ => panic!("result was not recharge"),
_ => panic!("ruin result not effect"),
}
}

View File

@ -33,26 +33,6 @@ impl Cast {
Cast::new(source.id, source.account, target.id, skill)
}
pub fn finalise(&mut self, game: &mut Game) -> &mut Cast {
let mut results = vec![];
let mut source = game.cryp_by_id(self.source_cryp_id).unwrap().clone();
self.speed = source.skill_speed(self.skill);
let targets = match source.skill_is_aoe(self.skill) {
true => game.cryp_aoe_targets(self.target_cryp_id),
false => vec![self.target_cryp_id],
};
for target_id in targets {
// let mut source = game.cryp_by_id(self.source_cryp_id).unwrap();
let mut target = game.cryp_by_id(target_id).unwrap();
results.append(&mut self.skill.resolve(&mut source, target));
}
self.resolutions = results;
self
}
pub fn used_cooldown(&self) -> bool {
return self.skill.base_cd().is_some();
}
@ -615,16 +595,6 @@ impl Skill {
return results;
}
// match self.category() == Category::Red {
// true => {
// if let Some(evasion) = target.evade(*self) {
// results.push(evasion);
// return Event;
// }
// },
// false => (),
// }
if target.is_ko() {
results.push(Resolution::new(source, target).event(Event::TargetKo));
return results;
@ -638,6 +608,29 @@ impl Skill {
return self.resolve(target, source);
}
// match self.category() == Category::Red {
// true => {
// if let Some(evasion) = target.evade(*self) {
// results.push(evasion);
// return Event;
// }
// },
// false => (),
// }
// if target.is_ko() && !target.ko_logged {
// self.log.push(format!("{:} KO", target.name));
// target.effects.clear();
// target.ko_logged = true;
// }
// if source.is_ko() && !source.ko_logged {
// self.log.push(format!("{:} KO", source.name));
// source.effects.clear();
// source.ko_logged = true;
// }
match self {
Skill::Amplify => amplify(source, target, results), // increase magic damage
Skill::Attack => attack(source, target, results),