fixed description, remove first().unwrap()

server/src/construct.rs

@@ -72,7 +72,7 @@ pub enum EffectMeta {
     Multiplier(u64),
 }
 
-#[derive(Debug,Clone,PartialEq,Serialize,Deserialize)]
+#[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
 pub struct ConstructEffect {
     pub effect: Effect,
     pub duration: u8,
@@ -104,6 +104,13 @@ impl ConstructEffect {
             Some(EffectMeta::Multiplier(s)) => s,
             _ => 0
         }
+    }
+
+    pub fn get_skill(&self) -> Option<Skill> {
+        match self.meta {
+            Some(EffectMeta::Skill(s)) => Some(s),
+            _ => None,
+        }
 
     }
 }

server/src/item.rs

@@ -408,15 +408,15 @@ impl Item {
             Item::Attack => format!("Deal RedDamage based on {:?}% RedPower",
                 self.into_skill().unwrap().multiplier()),
             Item::Block => format!("Reduce incoming RedDamage by {:?}%",
-                100 - self.into_skill().unwrap().effect().first().unwrap().get_multiplier()),
+                100 - self.into_skill().unwrap().effect()[0].get_multiplier()),
 
 
             Item::Stun => format!("Stun target construct for {:?}T",
-                self.into_skill().unwrap().effect().first().unwrap().get_duration()),
+                self.into_skill().unwrap().effect()[0].get_duration()),
             Item::Buff => format!("Increase target construct RedPower and speed by {:?}%",
-                self.into_skill().unwrap().effect().first().unwrap().get_multiplier() - 100),
+                self.into_skill().unwrap().effect()[0].get_multiplier() - 100),
             Item::Debuff => format!("Slow target construct speed by {:?}%",
-                100 - self.into_skill().unwrap().effect().first().unwrap().get_multiplier()),
+                100 - self.into_skill().unwrap().effect()[0].get_multiplier()),
             // specs
             // Base
             Item::Power => format!("Base ITEM for increased Power. Power determines the damage caused by your SKILLS."),
@@ -456,14 +456,14 @@ impl Item {
             Item::AmplifyI |
             Item::AmplifyII |
             Item::AmplifyIII => format!("Increase red and blue power by {:?}%. Lasts {:?}T",
-                self.into_skill().unwrap().effect().first().unwrap().get_multiplier() - 100,
+                self.into_skill().unwrap().effect()[0].get_multiplier() - 100,
-                self.into_skill().unwrap().effect().first().unwrap().get_duration()),
+                self.into_skill().unwrap().effect()[0].get_duration()),
 
             Item::BanishI |
             Item::BanishII |
             Item::BanishIII => format!("Banish target for {:?}T.
                 Banished constructs are immune to all skills and effects.",
-                self.into_skill().unwrap().effect().first().unwrap().get_duration()),
+                self.into_skill().unwrap().effect()[0].get_duration()),
 
             Item::BlastI |
             Item::BlastII |
@@ -477,48 +477,51 @@ impl Item {
 
             Item::ClutchI |
             Item::ClutchII |
-            Item::ClutchIII => format!("Construct cannot be KO'd while active. Additionally provides immunity to disables."),
+            Item::ClutchIII => format!("Construct cannot be KO'd while active. Additionally provides immunity to disables. \
+                Lasts {:?}T",
+                self.into_skill().unwrap().effect()[0].get_duration()),
 
             Item::CorruptI |
             Item::CorruptII |
             Item::CorruptIII => format!(
-                "Self targetting defensive for {:?}T. Applies corrupt to attackers dealing BlueDamage {:?}% \
+                "Self targetting defensive for {:?}T. Applies Corruption to attackers dealing BlueDamage {:?}% \
                 BluePower per turn for {:?}T.",
-                self.into_skill().unwrap().effect().first().unwrap().get_duration(),
+                self.into_skill().unwrap().effect()[0].get_duration(),
-                Skill::CorruptI.multiplier(), // TO BE FIXT
+                self.into_skill().unwrap().effect()[0].get_skill().unwrap().effect()[0].get_skill().unwrap().multiplier(),
-                self.into_skill().unwrap().effect().last().unwrap().get_duration()),
+                self.into_skill().unwrap().effect()[0].get_skill().unwrap().effect()[0].get_duration()),
 
             Item::CurseI |
             Item::CurseII |
             Item::CurseIII => format!(
                 "Increases red and blue damage taken by {:?}%. Lasts {:?}T",
-                self.into_skill().unwrap().effect().first().unwrap().get_multiplier() - 100,
+                self.into_skill().unwrap().effect()[0].get_multiplier() - 100,
-                self.into_skill().unwrap().effect().first().unwrap().get_duration()),
+                self.into_skill().unwrap().effect()[0].get_duration()),
 
             Item::DecayI |
             Item::DecayII |
             Item::DecayIII => format!(
-                "Reduces healing taken by {:?}% and deals blue damage {:?}% blue power each turn. Lasts {:?}T",
+                "Reduces healing taken by {:?}% for {:?}T. Deals blue damage {:?}% blue power each turn for {:?}T",
-                100 - self.into_skill().unwrap().effect().first().unwrap().get_multiplier(),
+                100 - self.into_skill().unwrap().effect()[0].get_multiplier(),
-                self.into_skill().unwrap().multiplier(),
+                self.into_skill().unwrap().effect()[0].get_duration(),
-                self.into_skill().unwrap().effect().first().unwrap().get_duration()),
+                self.into_skill().unwrap().effect()[1].get_skill().unwrap().multiplier(),
+                self.into_skill().unwrap().effect()[1].get_duration()),
 
             Item::HostilityI |
             Item::HostilityII |
             Item::HostilityIII => format!(
                 "Gain Hostility for {:?}T. {} Hatred lasts {:?}T",
-                self.into_skill().unwrap().effect().first().unwrap().get_duration(),
+                self.into_skill().unwrap().effect()[0].get_duration(),
                 "When attacked by Hostility you gain Hatred which increased red and blue power based on Damage taken.",
-                self.into_skill().unwrap().effect().last().unwrap().get_duration()),
+                self.into_skill().unwrap().effect()[0].get_skill().unwrap().effect()[0].get_duration()),
 
             Item::HasteI |
             Item::HasteII |
             Item::HasteIII => format!(
                 "Haste increases Speed by {:?}%, Red based Attack skills will strike again dealing {:?}{}. Lasts {:?}T",
-                self.into_skill().unwrap().effect().first().unwrap().get_multiplier() - 100,
+                self.into_skill().unwrap().effect()[0].get_multiplier() - 100,
                  Skill::HasteStrike.multiplier(),
                 "% Speed as RedDamage",
-                self.into_skill().unwrap().effect().first().unwrap().get_duration()),
+                self.into_skill().unwrap().effect()[0].get_duration()),
 
             Item::HealI |
             Item::HealII |
@@ -528,16 +531,16 @@ impl Item {
             Item::HexII |
             Item::HexIII => format!("Blue based skill that applies Hex for {:?}T. \
                 Hexed targets cannot cast any skills.",
-                self.into_skill().unwrap().effect().first().unwrap().get_duration()),
+                self.into_skill().unwrap().effect()[0].get_duration()),
 
             Item::ImpurityI |
             Item::ImpurityII |
             Item::ImpurityIII => format!(
                 "Impurity increases Green Power by {:?}%, Blue based Attack skills will blast again dealing {:?}{}. Lasts {:?}T",
-                self.into_skill().unwrap().effect().first().unwrap().get_multiplier() - 100,
+                self.into_skill().unwrap().effect()[0].get_multiplier() - 100,
                  Skill::ImpureBlast.multiplier(),
                 "% GreenPower as BluePower",
-                self.into_skill().unwrap().effect().first().unwrap().get_duration()),
+                self.into_skill().unwrap().effect()[0].get_duration()),
 
             Item::InvertI |
             Item::InvertII |
@@ -550,9 +553,9 @@ impl Item {
             Item::ParryIII => format!("{} {:?}% red power and blocks red skills for {:?}T. {} {:?}% red power.",
                 "Self targetting skill. Recharges RedLife for",
                 self.into_skill().unwrap().multiplier(),
-                self.into_skill().unwrap().effect().first().unwrap().get_duration(),
+                self.into_skill().unwrap().effect()[0].get_duration(),
                 "If a red skill is parried the construct will riposte the source dealing red damage",
-                Skill::RiposteI.multiplier()),
+                self.into_skill().unwrap().effect()[0].get_skill().unwrap().multiplier()),
 
             Item::PurgeI |
             Item::PurgeII |
@@ -568,7 +571,7 @@ impl Item {
             Item::ReflectII |
             Item::ReflectIII => format!(
                 "Reflect incoming skills to source. Lasts {:?}T",
-                self.into_skill().unwrap().effect().first().unwrap().get_duration()),
+                self.into_skill().unwrap().effect()[0].get_duration()),
 
             Item::RechargeI |
             Item::RechargeII |
@@ -580,7 +583,7 @@ impl Item {
             Item::RuinII |
             Item::RuinIII => format!(
                 "Team wide Stun for {:?}T. Stunned constructs are unable to cast skills.",
-                self.into_skill().unwrap().effect().first().unwrap().get_duration()),
+                self.into_skill().unwrap().effect()[0].get_duration()),
 
             Item::ScatterI |
             Item::ScatterII |
@@ -592,7 +595,7 @@ impl Item {
             Item::SilenceII |
             Item::SilenceIII => format!(
                 "Block the target from using blue skills for {:?}T and deals blue damage {:?}% blue power. {}",
-                self.into_skill().unwrap().effect().first().unwrap().get_duration(),
+                self.into_skill().unwrap().effect()[0].get_duration(),
                 self.into_skill().unwrap().multiplier(),
                 "Deals 45% more Damage per blue skill on target"),
 
@@ -606,14 +609,14 @@ impl Item {
             Item::SleepII |
             Item::SleepIII => format!(
                 "Stun for {:?}T and heal for {:?}% GreenPower.",
-                self.into_skill().unwrap().effect().first().unwrap().get_duration(),
+                self.into_skill().unwrap().effect()[0].get_duration(),
                 self.into_skill().unwrap().multiplier()),
 
             Item::SnareI |
             Item::SnareII |
             Item::SnareIII => format!(
                 "Block the target from using red skills for {:?}T and deals RedDamage {:?}% RedPower. {}",
-                self.into_skill().unwrap().effect().first().unwrap().get_duration(),
+                self.into_skill().unwrap().effect()[0].get_duration(),
                 self.into_skill().unwrap().multiplier(),
                 "Deals 35% more Damage per red skill on target"),
 
@@ -622,8 +625,8 @@ impl Item {
             Item::StrangleIII => format!(
                 "Strangle the target disabling skills from both the caster and the target.
                 While strangling deal RedDamage each turn {:?}% RedPower. Lasts {:?}T.",
-                self.into_skill().unwrap().multiplier(),
+                self.into_skill().unwrap().effect()[0].get_skill().unwrap().multiplier(),
-                self.into_skill().unwrap().effect().first().unwrap().get_duration()),
+                self.into_skill().unwrap().effect()[0].get_duration()),
 
             Item::StrikeI |
             Item::StrikeII |
@@ -635,33 +638,30 @@ impl Item {
             Item::SiphonII |
             Item::SiphonIII => format!(
                 "Deals BlueDamage {:?}% BluePower each turn and heals caster based on Damage dealt. Lasts {:?}T",
-                self.into_skill().unwrap().multiplier(),
+                self.into_skill().unwrap().effect()[0].get_skill().unwrap().multiplier(),
-                self.into_skill().unwrap().effect().first().unwrap().get_duration()),
+                self.into_skill().unwrap().effect()[0].get_duration()),
 
             Item::TauntI |
             Item::TauntII |
             Item::TauntIII => format!("Taunt redirects skills against the team to target, lasts {:?}T.\
                 Recharges RedLife for {:?} RedPower.",
-                self.into_skill().unwrap().effect().first().unwrap().get_duration(),
+                self.into_skill().unwrap().effect()[0].get_duration(),
                 self.into_skill().unwrap().multiplier()),
 
             Item::ThrowI |
             Item::ThrowII |
             Item::ThrowIII => format!(
                 "Stun the target for {:?}T and applies Vulnerable increasing RedDamage taken by {:?}% for {:?}T",
-
+                self.into_skill().unwrap().effect()[0].get_duration(),
-                self.into_skill().unwrap().effect().first().unwrap().get_duration(),
+                self.into_skill().unwrap().effect()[1].get_multiplier() - 100,
-                self.into_skill().unwrap().effect().last().unwrap().get_multiplier() - 100,
+                self.into_skill().unwrap().effect()[1].get_duration()),
-                self.into_skill().unwrap().effect().last().unwrap().get_duration()),
 
             Item::TriageI |
             Item::TriageII |
             Item::TriageIII => format!(
                 "Heals target for {:?}% GreenPower each turn. Lasts {:?}T",
-                self.into_skill().unwrap().multiplier(),
+                self.into_skill().unwrap().effect()[0].get_skill().unwrap().multiplier(),
-                self.into_skill().unwrap().effect().first().unwrap().get_duration()),
+                self.into_skill().unwrap().effect()[0].get_duration()),
-
-            _ => format!("..."),
         }
     }
 

server/src/skill.rs

@@ -1506,7 +1506,7 @@ fn throw(source: &mut Construct, target: &mut Construct, mut results: Resolution
 }
 
 fn strangle(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions {
-    let ConstructEffect { effect, duration, meta, tick: _ } = skill.effect().first().unwrap().clone();
+    let ConstructEffect { effect, duration, meta, tick: _ } = skill.effect()[0];
     let tick_skill = match meta {
         Some(EffectMeta::Skill(s)) => s,
         _ => panic!("no strangle tick skill"),
@@ -1659,29 +1659,26 @@ fn blast(source: &mut Construct, target: &mut Construct, mut results: Resolution
 }
 
 fn amplify(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions {
-    skill.effect().into_iter()
+    results.push(Resolution::new(source, target).event(target.add_effect(skill, skill.effect()[0])));
-        .for_each(|e| (results.push(Resolution::new(source, target).event(target.add_effect(skill, e)))));
     return results;;
 }
 
 fn haste(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions {
-    skill.effect().into_iter()
+    results.push(Resolution::new(source, target).event(target.add_effect(skill, skill.effect()[0])));
-        .for_each(|e| (results.push(Resolution::new(source, target).event(target.add_effect(skill, e)))));
     return results;;
 }
 
 fn debuff(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions {
-    skill.effect().into_iter()
+    results.push(Resolution::new(source, target).event(target.add_effect(skill, skill.effect()[0])));
-        .for_each(|e| (results.push(Resolution::new(source, target).event(target.add_effect(skill, e)))));
     return results;;
 }
 
 fn decay(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions {
 
-    let wither = skill.effect().first().unwrap().clone();
+    let wither = skill.effect()[0];
     results.push(Resolution::new(source, target).event(target.add_effect(skill, wither)));
 
-    let ConstructEffect { effect, duration, meta, tick: _ } = skill.effect().last().unwrap().clone();
+    let ConstructEffect { effect, duration, meta, tick: _ } = skill.effect()[1];
     let tick_skill = match meta {
         Some(EffectMeta::Skill(s)) => s,
         _ => panic!("no decay tick skill"),
@@ -1703,14 +1700,14 @@ fn decay_tick(source: &mut Construct, target: &mut Construct, mut results: Resol
 // corrupt is the buff effect
 // when attacked it runs corruption and applies a debuff
 fn corrupt(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions {
-    let corrupt = skill.effect().first().unwrap().clone();
+    let corrupt = skill.effect()[0];
     results.push(Resolution::new(source, target).event(target.add_effect(skill, corrupt)));
     return results;;
 }
 
 fn corruption(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions {
 
-    let ConstructEffect { effect, duration, meta, tick: _ } = skill.effect().first().unwrap().clone();
+    let ConstructEffect { effect, duration, meta, tick: _ } = skill.effect()[0];
     let tick_skill = match meta {
         Some(EffectMeta::Skill(s)) => s,
         _ => panic!("no corruption tick skill"),
@@ -1729,53 +1726,44 @@ fn corruption_tick(source: &mut Construct, target: &mut Construct, mut results:
 }
 
 fn ruin(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions {
-    skill.effect().into_iter()
+    results.push(Resolution::new(source, target).event(target.add_effect(skill, skill.effect()[0])));
-        .for_each(|e| (results.push(Resolution::new(source, target).event(target.add_effect(skill, e)))));
     return results;;
 }
 
 
 fn hex(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions {
-    skill.effect().into_iter()
+    results.push(Resolution::new(source, target).event(target.add_effect(skill, skill.effect()[0])));
-        .for_each(|e| (results.push(Resolution::new(source, target).event(target.add_effect(skill, e)))));
     return results;;
 }
 
 fn hostility(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions {
-    let hostility = skill.effect().first().unwrap().clone();
+    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, hostility)));
     return results;;
 }
 
 fn hatred(source: &mut Construct, target: &mut Construct, mut results: Resolutions, reflect_skill: Skill, amount: u64, skill: Skill) -> Resolutions {
-    let hatred = skill.effect().first().unwrap().clone()
+    let hatred = skill.effect()[0].set_meta(EffectMeta::AddedDamage(amount));
-        .set_meta(EffectMeta::AddedDamage(amount));
-
     results.push(Resolution::new(source, target).event(target.add_effect(reflect_skill, hatred)));
     return results;;
 }
 
 fn curse(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions {
-    skill.effect().into_iter()
+    results.push(Resolution::new(source, target).event(target.add_effect(skill, skill.effect()[0])));
-        .for_each(|e| (results.push(Resolution::new(source, target).event(target.add_effect(skill, e)))));
     return results;;
 }
 
 fn impurity(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions {
-    skill.effect().into_iter()
+    results.push(Resolution::new(source, target).event(target.add_effect(skill, skill.effect()[0])));
-        .for_each(|e| (results.push(Resolution::new(source, target).event(target.add_effect(skill, e)))));
     return results;;
 }
 
 fn invert(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions {
-    skill.effect().into_iter()
+    results.push(Resolution::new(source, target).event(target.add_effect(skill, skill.effect()[0])));
-        .for_each(|e| (results.push(Resolution::new(source, target).event(target.add_effect(skill, e)))));
     return results;;
 }
 
 fn reflect(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions {
-    skill.effect().into_iter()
+    results.push(Resolution::new(source, target).event(target.add_effect(skill, skill.effect()[0])));
-        .for_each(|e| (results.push(Resolution::new(source, target).event(target.add_effect(skill, e)))));
 
     let blue_amount = source.blue_power().pct(skill.multiplier());
     results.push(Resolution::new(source, target).event(target.recharge(skill, 0, blue_amount)));
@@ -1792,7 +1780,7 @@ fn recharge(source: &mut Construct, target: &mut Construct, mut results: Resolut
 }
 
 fn siphon(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions {
-    let ConstructEffect { effect, duration, meta, tick: _ } = skill.effect().first().unwrap().clone();
+    let ConstructEffect { effect, duration, meta, tick: _ } = skill.effect()[0];
     let tick_skill = match meta {
         Some(EffectMeta::Skill(s)) => s,
         _ => panic!("no siphon tick skill"),
@@ -1827,10 +1815,8 @@ fn scatter(source: &mut Construct, target: &mut Construct, mut results: Resoluti
     let blue_amount = source.blue_power().pct(skill.multiplier());
     results.push(Resolution::new(source, target).event(target.recharge(skill, 0, blue_amount)));
 
-    skill.effect().into_iter().for_each(|e| {
+    let scatter = skill.effect()[0].set_meta(EffectMeta::ScatterTarget(target.id));
-        let scatter = e.clone().set_meta(EffectMeta::ScatterTarget(target.id));
     results.push(Resolution::new(source, target).event(source.add_effect(skill, scatter)));
-    });
 
     return results;
 }
@@ -1862,8 +1848,7 @@ fn scatter_hit(source: &Construct, target: &Construct, mut results: Resolutions,
 }
 
 fn silence(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions {
-    skill.effect().into_iter()
+    results.push(Resolution::new(source, target).event(target.add_effect(skill, skill.effect()[0])));
-        .for_each(|e| (results.push(Resolution::new(source, target).event(target.add_effect(skill, e)))));
 
     let s_multi = target.skills
         .iter()
@@ -1908,8 +1893,7 @@ fn purify(source: &mut Construct, target: &mut Construct, mut results: Resolutio
 }
 
 fn banish(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions {
-    skill.effect().into_iter()
+    results.push(Resolution::new(source, target).event(target.add_effect(skill, skill.effect()[0])));
-        .for_each(|e| (results.push(Resolution::new(source, target).event(target.add_effect(skill, e)))));
     return results;
 }