From 7afb6e30bdda6f60e40ad8aebc19917377a6a168 Mon Sep 17 00:00:00 2001 From: Mashy Date: Fri, 6 Dec 2019 16:26:50 +1000 Subject: [PATCH] wip --- core/src/construct.rs | 83 +++++++++++++++++++------------------------ core/src/game.rs | 48 +++++++++++++------------ core/src/skill.rs | 69 +++++++++++++++++------------------ 3 files changed, 98 insertions(+), 102 deletions(-) diff --git a/core/src/construct.rs b/core/src/construct.rs index f8a3efbf..937a377f 100644 --- a/core/src/construct.rs +++ b/core/src/construct.rs @@ -4,7 +4,7 @@ use rand::prelude::*; use failure::Error; use failure::err_msg; -use skill::{Skill, Cast, Disable, Event, EventVariant, EventConstruct}; +use skill::{Skill, Cast, Disable, EventVariant, EventConstruct}; use game::{Colour}; use effect::{Cooldown, Effect}; use spec::{Spec}; @@ -415,7 +415,7 @@ impl Construct { self } - pub fn increase_cooldowns(&mut self, turns: usize) -> Vec { + pub fn increase_cooldowns(&mut self, turns: usize) -> Vec { let mut events = vec![]; for skill in self.skills.iter_mut() { @@ -423,11 +423,11 @@ impl Construct { match skill.cd { Some(cd) => { skill.cd = Some(cd.saturating_add(turns)); - events.push(Event::new(EventVariant::CooldownIncrease { turns, skill: skill.skill }, self.id)) + events.push(EventVariant::CooldownIncrease { turns, skill: skill.skill }) }, None => { skill.cd = Some(turns); - events.push(Event::new(EventVariant::CooldownIncrease { turns, skill: skill.skill }, self.id)) + events.push(EventVariant::CooldownIncrease { turns, skill: skill.skill }) }, } } @@ -546,7 +546,7 @@ impl Construct { } } - pub fn recharge(&mut self, red_amount: usize, blue_amount: usize) -> Vec { + pub fn recharge(&mut self, red_amount: usize, blue_amount: usize) -> Vec { let mut events = vec![]; if self.is_ko() { return events; } @@ -565,7 +565,7 @@ impl Construct { let blue = new_blue_life - current_blue_life; if red != 0 || blue != 0 { - events.push(Event::new(EventVariant::Recharge { red, blue }, self.id)); + events.push(EventVariant::Recharge { red, blue }); } }, true => { @@ -591,12 +591,12 @@ impl Construct { self.reduce_green_life(red_remainder); let red_damage_amount = red_current_green_life - self.green_life(); - events.push(Event::new(EventVariant::Damage { + events.push(EventVariant::Damage { amount: red_damage_amount, mitigation: red_mitigation, colour: Colour::Red, display: EventConstruct::new(self), - }, self.id)); + }); } if blue_amount != 0 { @@ -620,19 +620,19 @@ impl Construct { self.reduce_green_life(blue_remainder); let blue_damage_amount = blue_current_green_life - self.green_life(); - events.push(Event::new(EventVariant::Damage { + events.push(EventVariant::Damage { amount: blue_damage_amount, mitigation: blue_mitigation, colour: Colour::Blue, display: EventConstruct::new(self), - }, self.id)); + }); } } } return events; } - pub fn deal_green_damage(&mut self, amount: usize) -> Vec { + pub fn deal_green_damage(&mut self, amount: usize) -> Vec { let mut events = vec![]; if self.is_ko() { return events; } @@ -653,10 +653,10 @@ impl Construct { let healing = new_green_life - current_green_life; let overhealing = modified_power - healing; - events.push(Event::new(EventVariant::Healing { + events.push(EventVariant::Healing { amount: healing, overhealing, - }, self.id)); + }); }, true => { // events.push(Event::new(EventVariant::Inversion { skill })); @@ -666,19 +666,19 @@ impl Construct { self.reduce_green_life(modified_power); let delta = current_green_life - self.green_life(); - events.push(Event::new(EventVariant::Damage { + events.push(EventVariant::Damage { amount: delta, mitigation: 0, colour: Colour::Green, display: EventConstruct::new(self), - }, self.id)); + }); } } return events; } - pub fn deal_red_damage(&mut self, amount: usize) -> Vec { + pub fn deal_red_damage(&mut self, amount: usize) -> Vec { let mut events = vec![]; if self.is_ko() { return events; } @@ -708,17 +708,16 @@ impl Construct { self.reduce_green_life(remainder); let delta = current_green_life - self.green_life(); - events.push(Event::new( + events.push( EventVariant::Damage { amount: delta, mitigation, colour: Colour::Red, display: EventConstruct::new(self), - }, - self.id - )); + } + ); if self.is_ko() { - events.push(Event::new(EventVariant::Ko {}, self.id)); + events.push(EventVariant::Ko {}); } }, true => { @@ -735,16 +734,16 @@ impl Construct { let recharge = self.red_life.value - current_life; if healing > 0 { - events.push(Event::new( - EventVariant::Healing{ + events.push( + EventVariant::Healing { amount: healing, overhealing: overhealing - recharge, - }, self.id - )); + } + ); } if recharge > 0 { - events.push(Event::new(EventVariant::Recharge { red: recharge, blue: 0 }, self.id)); + events.push(EventVariant::Recharge { red: recharge, blue: 0 }); } } }; @@ -752,7 +751,7 @@ impl Construct { return events; } - pub fn deal_blue_damage(&mut self, amount: usize) -> Vec { + pub fn deal_blue_damage(&mut self, amount: usize) -> Vec { let mut events = vec![]; if self.is_ko() { return events; } @@ -778,12 +777,12 @@ impl Construct { self.reduce_green_life(remainder); let delta = current_green_life - self.green_life(); - events.push(Event::new(EventVariant::Damage { + events.push(EventVariant::Damage { amount: delta, mitigation, colour: Colour::Blue, - display: EventConstruct::new(self), - }, self.id)); + display: EventConstruct::new(self), + }); }, true => { // events.push(Event::new(EventVariant::Inversion { skill })); @@ -799,17 +798,11 @@ impl Construct { let recharge = self.blue_life.value - current_life; if healing > 0 { - events.push( - Event::new(EventVariant::Healing { - amount: healing, - overhealing, - }, - self.id - )); + events.push(EventVariant::Healing { amount: healing, overhealing }); } if recharge > 0 { - events.push(Event::new(EventVariant::Recharge { red: 0, blue: recharge }, self.id)); + events.push(EventVariant::Recharge { red: 0, blue: recharge }); } } }; @@ -817,7 +810,7 @@ impl Construct { return events; } - pub fn add_effect(&mut self, effect: ConstructEffect) -> Vec { + pub fn add_effect(&mut self, effect: ConstructEffect) -> Vec { if self.is_ko() { return vec![] } if self.affected(Effect::Banish) { panic!("banish immunity not fixt yet") } @@ -834,13 +827,11 @@ impl Construct { } // todo modified durations cause of buffs - let result = Event::new( - EventVariant::Effect { - effect: effect.effect, - duration: effect.duration, - display: EventConstruct::new(self), - }, self.id - ); + let result = EventVariant::Effect { + effect: effect.effect, + duration: effect.duration, + display: EventConstruct::new(self) + }; return vec![result]; } diff --git a/core/src/game.rs b/core/src/game.rs index 9258c2e0..effe4285 100644 --- a/core/src/game.rs +++ b/core/src/game.rs @@ -40,11 +40,11 @@ pub enum Colour { #[derive(Debug,Clone,PartialEq,Serialize,Deserialize)] pub enum Action { - Hit { construct: Uuid, skill: Skill }, - HitCast { construct: Uuid, skill: Skill, source: Uuid }, - Damage { construct: Uuid, values: Vec, colour: Colour }, - Effect { construct: Uuid, effect: ConstructEffect }, - IncreaseCooldowns { construct: Uuid, turns: usize }, + Hit { cast: Cast }, + HitCast { cast: Cast }, + Damage { cast: Cast, construct: Uuid, values: Vec, colour: Colour }, + Effect { cast: Cast, construct: Uuid, effect: ConstructEffect }, + IncreaseCooldowns { cast: Cast, construct: Uuid, turns: usize }, // Recharge { skill: Skill, red: usize, blue: usize }, } @@ -493,7 +493,12 @@ impl Game { self.skill_phase_start(r_animation_ms) } - fn event_add(&mut self, mut events: Vec) -> &mut Game { + fn event_add(&mut self, event_variants: Vec, cast: Cast) -> &mut Game { + let mut events = event_variants + .iter() + .map(|e| e.to_event(cast)) + .collect(); + self.events.last_mut().unwrap().append(&mut events); self } @@ -501,45 +506,44 @@ impl Game { pub fn actions(&mut self, actions: Vec) -> &mut Game { for action in actions { match action { - Action::Hit { construct, skill } => self.hit(construct, skill), - Action::HitCast { construct, skill, source } => self.hit_cast(construct, skill, source), - Action::Damage { construct, values, colour } => self.damage(construct, values, colour), - Action::Effect { construct, effect } => self.effect(construct, effect), - Action::IncreaseCooldowns { construct, turns } => self.increase_cooldowns(construct, turns), + Action::Hit { cast } => self.hit(cast), + Action::HitCast { cast } => self.hit_cast(cast), + Action::Damage { cast, construct, values, colour } => self.damage(cast, construct, values, colour), + Action::Effect { cast, construct, effect } => self.effect(cast, construct, effect), + Action::IncreaseCooldowns { cast, construct, turns } => self.increase_cooldowns(cast, construct, turns), }; } self } - fn hit_cast(&mut self, construct: Uuid, skill: Skill, source: Uuid) -> &mut Game { - self.event_add(vec![Event::new(EventVariant::HitCast { skill: skill, source: source }, construct)]); + fn hit_cast(&mut self, cast: Cast) -> &mut Game { + self.event_add(vec![EventVariant::HitCast()], cast); self } - fn hit(&mut self, construct: Uuid, skill: Skill) -> &mut Game { - self.event_add(vec![Event::new(EventVariant::Hit { skill: skill }, construct)]); + fn hit(&mut self, cast: Cast) -> &mut Game { + self.event_add(vec![EventVariant::Hit()], cast); self } - fn damage(&mut self, construct: Uuid, values: Vec, colour: Colour) -> &mut Game { + fn damage(&mut self, cast: Cast, construct: Uuid, values: Vec, colour: Colour) -> &mut Game { let events = match colour { _ => self.construct_by_id(construct).unwrap().deal_red_damage(128) // fixme unwrap }; - - self.event_add(events); + self.event_add(events, cast); self } - fn effect(&mut self, construct: Uuid, effect: ConstructEffect) -> &mut Game { + fn effect(&mut self, cast: Cast, construct: Uuid, effect: ConstructEffect) -> &mut Game { let events = self.construct_by_id(construct).unwrap().add_effect(effect); - self.event_add(events); + self.event_add(events, cast); self } - fn increase_cooldowns(&mut self, construct: Uuid, turns: usize) -> &mut Game { + fn increase_cooldowns(&mut self, cast: Cast, construct: Uuid, turns: usize) -> &mut Game { let events = self.construct_by_id(construct).unwrap().increase_cooldowns(turns); - self.event_add(events); + self.event_add(events, cast); self } diff --git a/core/src/skill.rs b/core/src/skill.rs index a0282286..298c762f 100644 --- a/core/src/skill.rs +++ b/core/src/skill.rs @@ -89,6 +89,10 @@ impl Cast { }; } + pub fn target(self) -> Uuid { + self.target + } + pub fn new_tick(source: &mut Construct, target: &mut Construct, skill: Skill) -> Cast { Cast { id: Uuid::new_v4(), @@ -106,25 +110,28 @@ impl Cast { pub fn actions(&self) -> Vec { let mut actions = match self.skill.is_tick() { - false => vec![Action::HitCast { construct: self.target, skill: self.skill, source: self.source }], - true => vec![Action::Hit { construct: self.target, skill: self.skill }] + false => vec![Action::HitCast { cast: *self } ], + true => vec![Action::Hit { cast: *self } ] }; let mut rest = match self.skill { Skill::Amplify => vec![ Action::Effect { + cast: *self, construct: self.target, effect: ConstructEffect { effect: Effect::Amplify, duration: 2, meta: Some(EffectMeta::Multiplier(150)), tick: None }, }, ], Skill::AmplifyPlus => vec![ Action::Effect { + cast: *self, construct: self.target, effect: ConstructEffect { effect: Effect::Amplify, duration: 3, meta: Some(EffectMeta::Multiplier(175)), tick: None }, }, ], Skill::AmplifyPlusPlus => vec![ Action::Effect { + cast: *self, construct: self.target, effect: ConstructEffect { effect: Effect::Amplify, duration: 4, meta: Some(EffectMeta::Multiplier(200)), tick: None }, }, @@ -132,6 +139,7 @@ impl Cast { Skill::Attack => vec![ Action::Damage { + cast: *self, construct: self.target, colour: Colour::Red, values: vec![Value::Stat { construct: self.source, stat: Stat::RedPower, mult: self.skill.multiplier() }], @@ -141,18 +149,21 @@ impl Cast { Skill::Banish => vec![ Action::Effect { + cast: *self, construct: self.target, effect: ConstructEffect { effect: Effect::Banish, duration: 2, meta: None, tick: None } } ], Skill::BanishPlus => vec![ Action::Effect { + cast: *self, construct: self.target, effect: ConstructEffect { effect: Effect::Banish, duration: 2, meta: None, tick: None } } ], Skill::BanishPlusPlus => vec![ Action::Effect { + cast: *self, construct: self.target, effect: ConstructEffect { effect: Effect::Banish, duration: 2, meta: None, tick: None } } @@ -162,6 +173,7 @@ impl Cast { Skill::BashPlus | Skill::BashPlusPlus => vec![ Action::Damage { + cast: *self, construct: self.target, colour: Colour::Red, values: vec![ @@ -170,10 +182,12 @@ impl Cast { ], }, Action::Effect { + cast: *self, construct: self.target, effect: ConstructEffect {effect: Effect::Stun, duration: 2, meta: None, tick: None } }, Action::IncreaseCooldowns { + cast: *self, construct: self.target, turns: 1, }, @@ -183,6 +197,7 @@ impl Cast { Skill::BlastPlus | Skill::BlastPlusPlus => vec![ Action::Damage { + cast: *self, construct: self.target, colour: Colour::Blue, values: vec![Value::Stat { construct: self.source, stat: Stat::BluePower, mult: self.skill.multiplier() }], @@ -193,6 +208,7 @@ impl Cast { Skill::StrikePlus | Skill::StrikePlusPlus => vec![ Action::Damage { + cast: *self, construct: self.target, colour: Colour::Red, values: vec![Value::Stat { construct: self.source, stat: Stat::RedPower, mult: self.skill.multiplier() }], @@ -211,32 +227,20 @@ pub type Disable = Vec; #[derive(Debug,Clone,PartialEq,Serialize,Deserialize)] pub struct Event { - pub target: Uuid, + pub cast: Cast, pub variant: EventVariant, pub delay: i64, } -impl Event { - pub fn new(variant: EventVariant, target: Uuid) -> Event { - let delay = variant.delay(); - Event { - target, - variant, - delay, - } - } -} - -#[derive(Debug,Clone,PartialEq,Serialize,Deserialize)] +#[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)] pub enum EventVariant { - Hit { skill: Skill }, - HitCast { skill: Skill, source: Uuid }, + Hit (), + HitCast (), Damage { amount: usize, mitigation: usize, colour: Colour, display: EventConstruct }, Effect { effect: Effect, duration: u8, display: EventConstruct }, Removal { effect: Option, display: EventConstruct }, - Disable { disable: Disable }, Healing { amount: usize, overhealing: usize }, Recharge { red: usize, blue: usize }, Inversion { skill: Skill }, @@ -264,16 +268,25 @@ impl EventVariant { let combat_text_overlap = 600; // overlap between animation and combat text match self { - EventVariant::Hit { skill: _ } => target_duration - combat_text_overlap, - EventVariant::HitCast { skill: _, source: _ } => target_delay + target_duration - combat_text_overlap, + EventVariant::Hit() => target_duration - combat_text_overlap, + EventVariant::HitCast() => target_delay + target_duration - combat_text_overlap, _ => combat_text_delay, } } + + pub fn to_event(&self, cast: Cast) -> Event { + let delay = self.delay(); + Event { + cast, + variant: *self, + delay, + } + } } // used to show the progress of a construct // while the resolutions are animating -#[derive(Debug,Clone,PartialEq,Serialize,Deserialize)] +#[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)] pub struct EventConstruct { pub id: Uuid, pub red: usize, @@ -1555,19 +1568,7 @@ mod tests { let cast = Cast::new(Uuid::new_v4(), Uuid::new_v4(), Uuid::new_v4(), Skill::Attack); let actions = cast.actions(); - match actions[0] { - Action::Hit { construct: _, skill } => { - assert_eq!(skill, Skill::Attack); - }, - _ => panic!("{:?}", actions), - }; - - match actions[1] { - Action::Damage { construct: _, values: _, colour } => { - assert_eq!(colour, Colour::Red); - }, - _ => panic!("{:?}", actions), - }; + } // #[test]