group attack skills

core/src/skill.rs

@@ -218,14 +218,9 @@ pub enum Skill {
     Attack,
     Debuff,
     Buff,
-    Block, // reduce damage
+    Block,
     Stun,
 
-    // Boost -- sounds nice
-    // Evade, // actively evade
-    // Nightmare,
-    // Sleep,
-
     Amplify,
     #[serde(rename = "Amplify+")]
     AmplifyPlus,
@@ -771,6 +766,214 @@ fn attack(cast: Cast, game: &mut Game, values: Attack) {
     );
 }
 
+#[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
+enum Blast { Base, Plus, PlusPlus, Hybrid }
+impl Blast {
+    fn dmg_multi(self) -> usize {
+        match self { 
+            Blast::Base => 105,
+            Blast::Plus => 125,
+            Blast::PlusPlus => 145,
+            Blast::Hybrid => 50,
+        }
+    }
+}
+
+fn blast(cast: Cast, game: &mut Game, values: Blast) {
+    let amount = match values {
+        Blast::Hybrid => game.value(Value::Stat { construct: cast.source, stat: Stat::GreenPower }).pct(values.dmg_multi()),
+        _ => game.value(Value::Stat { construct: cast.source, stat: Stat::BluePower }).pct(values.dmg_multi())
+    };
+
+    game.action(cast,
+        Action::Damage {
+            construct: cast.target,
+            colour: Colour::Blue,
+            amount,
+        },
+    );
+}
+
+#[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
+enum Chaos { Base, Plus, PlusPlus }
+impl Chaos {
+    fn dmg_multi(self) -> usize {
+        match self { Chaos::Base => 40, Chaos::Plus => 50, Chaos::PlusPlus => 65 }
+    }
+}
+
+fn chaos(cast: Cast, game: &mut Game, values: Chaos) {
+    let mut rng = thread_rng();
+    game.action(cast,
+        Action::Damage {
+            construct: cast.target,
+            colour: Colour::Red,
+            amount:
+                game.value(Value::Stat { construct: cast.source, stat: Stat::RedPower }).pct(values.dmg_multi().pct(rng.gen_range(100, 130)))
+        }
+    );
+    game.action(cast,
+        Action::Damage {
+            construct: cast.target,
+            colour: Colour::Blue,
+            amount:
+                game.value(Value::Stat { construct: cast.source, stat: Stat::BluePower }).pct(values.dmg_multi().pct(rng.gen_range(100, 130)))
+        },
+    );
+}
+
+enum Heal { Base, Plus, PlusPlus }
+impl Heal {
+    pub fn heal_multiplier(self) -> usize {
+        match self { Heal::Base => 115, Heal::Plus => 135, Heal::PlusPlus => 160 }
+    }
+}
+
+fn heal(cast: Cast, game: &mut Game, values: Heal) {
+    game.action(cast,
+        Action::Heal {
+            construct: cast.target,
+            colour: Colour::Green,
+            amount: game.value(Value::Stat { construct: cast.source, stat: Stat::GreenPower }).pct(values.heal_multiplier()),
+        },
+    );
+}
+
+#[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
+enum Siphon { Base, Plus, PlusPlus }
+impl Siphon {
+    pub fn blue_dmg_multi(self) -> usize {
+        match self { Siphon::Base => 25, Siphon::Plus => 27, Siphon::PlusPlus => 30 }
+    }
+
+    pub fn green_dmg_multi(self) -> usize {
+        match self { Siphon::Base => 25, Siphon::Plus => 27, Siphon::PlusPlus => 30 }
+    }
+
+    pub fn duration(self) -> u8 {
+        match self { Siphon::Base => 2, Siphon::Plus => 3, Siphon::PlusPlus => 4 }
+    }
+}
+
+fn siphon(cast: Cast, game: &mut Game, values: Siphon) {
+    let amount =
+        game.value(Value::Stat { construct: cast.source, stat: Stat::BluePower }).pct(values.blue_dmg_multi())
+        + game.value(Value::Stat { construct: cast.source, stat: Stat::GreenPower }).pct(values.green_dmg_multi());
+
+    game.action(cast,
+        Action::Effect {
+            construct: cast.target,
+            effect: ConstructEffect { effect: Effect::Siphon, duration: values.duration(), meta:
+                Some(EffectMeta::CastTick { source: cast.source, target: cast.target, skill: Skill::SiphonTick, speed: cast.speed, amount }) },
+        }
+    );
+    game.action(cast,
+        Action::Damage {
+            construct: cast.target,
+            colour: Colour::Blue,
+            amount,
+        }
+    );
+    game.action(cast,
+        Action::Effect {
+            construct: cast.target,
+            effect: ConstructEffect { effect: Effect::Siphoned, duration: 1, meta: None }, // immunity to additional ticks
+        }
+    );
+    game.action(cast,
+        Action::Heal {
+            construct: cast.source,
+            colour: Colour::Green,
+            amount: game.value(Value::DamageReceived { construct: cast.target, colour: Colour::Blue }).pct(100),
+        },
+    );
+}
+
+fn siphon_tick(cast: Cast, game: &mut Game) {
+    game.action(cast,
+        Action::Damage {
+            construct: cast.target,
+            colour: Colour::Blue,
+            amount: game.value(Value::TickDamage { construct: cast.target, effect: Effect::Siphon }),
+        }
+    );
+    game.action(cast,
+        Action::Effect {
+            construct: cast.target,
+            effect: ConstructEffect { effect: Effect::Siphoned, duration: 1, meta: None }, // immunity to additional ticks
+        }
+    );
+    game.action(cast,
+        Action::Heal {
+            construct: cast.source,
+            colour: Colour::Green,
+            amount: game.value(Value::DamageReceived { construct: cast.target, colour: Colour::Blue }).pct(100),
+        },
+    );
+}
+
+#[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
+enum Slay { Base, Plus, PlusPlus }
+impl Slay {
+    pub fn blue_dmg_multi(self) -> usize {
+        match self { Slay::Base => 40, Slay::Plus => 50, Slay::PlusPlus => 65 }
+    }
+
+    pub fn green_dmg_multi(self) -> usize {
+        match self { Slay::Base => 40, Slay::Plus => 50, Slay::PlusPlus => 65 }
+    }
+}
+
+fn slay(cast: Cast, game: &mut Game, values: Slay) {
+    let amount =
+        game.value(Value::Stat { construct: cast.source, stat: Stat::BluePower }).pct(values.blue_dmg_multi())
+        + game.value(Value::Stat { construct: cast.source, stat: Stat::GreenPower }).pct(values.green_dmg_multi());
+
+    game.action(cast,
+        Action::Damage {
+            construct: cast.target,
+            colour: Colour::Red,
+            amount,
+        }
+    );
+    game.action(cast,
+        Action::Heal {
+            construct: cast.source,
+            colour: Colour::Green,
+            amount: game.value(Value::DamageReceived { construct: cast.target, colour: Colour::Red }),
+        },
+    );
+}
+
+#[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
+enum Strike { Base, Plus, PlusPlus, Haste }
+impl Strike {
+    pub fn dmg_multi(self) -> usize {
+        match self {
+            Strike::Base => 90,
+            Strike::Plus => 110,
+            Strike::PlusPlus => 140,
+            Strike::Haste => 60,
+        }
+    }
+}
+
+fn strike(cast: Cast, game: &mut Game, values: Strike) {
+    let amount = match values {
+        Strike::Haste => game.value(Value::Stat { construct: cast.source, stat: Stat::Speed }).pct(values.dmg_multi()),
+        _ => game.value(Value::Stat { construct: cast.source, stat: Stat::RedPower }).pct(values.dmg_multi())
+    };
+
+    game.action(cast,
+        Action::Damage {
+            construct: cast.target,
+            colour: Colour::Red,
+            amount,
+        },
+    );
+}
+
+
 #[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
 enum Block { Base }
 impl Block {
@@ -1023,34 +1226,6 @@ fn bash(cast: Cast, game: &mut Game, values: Bash) {
     );
 }
 
-#[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
-enum Blast { Base, Plus, PlusPlus, Hybrid }
-impl Blast {
-    fn dmg_multi(self) -> usize {
-        match self { 
-            Blast::Base => 105,
-            Blast::Plus => 125,
-            Blast::PlusPlus => 145,
-            Blast::Hybrid => 50,
-        }
-    }
-}
-
-fn blast(cast: Cast, game: &mut Game, values: Blast) {
-    let amount = match values {
-        Blast::Hybrid => game.value(Value::Stat { construct: cast.source, stat: Stat::GreenPower }).pct(values.dmg_multi()),
-        _ => game.value(Value::Stat { construct: cast.source, stat: Stat::BluePower }).pct(values.dmg_multi())
-    };
-
-    game.action(cast,
-        Action::Damage {
-            construct: cast.target,
-            colour: Colour::Blue,
-            amount,
-        },
-    );
-}
-
 #[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
 enum Break { Base, Plus, PlusPlus }
 impl Break {
@@ -1108,34 +1283,6 @@ fn curse(cast: Cast, game: &mut Game, values: Curse) {
     );
 }
 
-#[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
-enum Chaos { Base, Plus, PlusPlus }
-impl Chaos {
-    fn dmg_multi(self) -> usize {
-        match self { Chaos::Base => 40, Chaos::Plus => 50, Chaos::PlusPlus => 65 }
-    }
-}
-
-fn chaos(cast: Cast, game: &mut Game, values: Chaos) {
-    let mut rng = thread_rng();
-    game.action(cast,
-        Action::Damage {
-            construct: cast.target,
-            colour: Colour::Red,
-            amount:
-                game.value(Value::Stat { construct: cast.source, stat: Stat::RedPower }).pct(values.dmg_multi().pct(rng.gen_range(100, 130)))
-        }
-    );
-    game.action(cast,
-        Action::Damage {
-            construct: cast.target,
-            colour: Colour::Blue,
-            amount:
-                game.value(Value::Stat { construct: cast.source, stat: Stat::BluePower }).pct(values.dmg_multi().pct(rng.gen_range(100, 130)))
-        },
-    );
-}
-
 #[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
 enum Counter { Base, Plus, PlusPlus }
 impl Counter {
@@ -1330,23 +1477,6 @@ fn electrocute_tick(cast: Cast, game: &mut Game) {
     );
 }
 
-enum Heal { Base, Plus, PlusPlus }
-impl Heal {
-    pub fn heal_multiplier(self) -> usize {
-        match self { Heal::Base => 115, Heal::Plus => 135, Heal::PlusPlus => 160 }
-    }
-}
-
-fn heal(cast: Cast, game: &mut Game, values: Heal) {
-    game.action(cast,
-        Action::Heal {
-            construct: cast.target,
-            colour: Colour::Green,
-            amount: game.value(Value::Stat { construct: cast.source, stat: Stat::GreenPower }).pct(values.heal_multiplier()),
-        },
-    );
-}
-
 #[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
 enum Haste { Base, Plus, PlusPlus }
 impl Haste {
@@ -1639,112 +1769,6 @@ fn ruin(cast: Cast, game: &mut Game, values: Ruin) {
     );
 }
 
-#[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
-enum Siphon { Base, Plus, PlusPlus }
-impl Siphon {
-    pub fn blue_dmg_multi(self) -> usize {
-        match self { Siphon::Base => 25, Siphon::Plus => 27, Siphon::PlusPlus => 30 }
-    }
-
-    pub fn green_dmg_multi(self) -> usize {
-        match self { Siphon::Base => 25, Siphon::Plus => 27, Siphon::PlusPlus => 30 }
-    }
-
-    pub fn duration(self) -> u8 {
-        match self { Siphon::Base => 2, Siphon::Plus => 3, Siphon::PlusPlus => 4 }
-    }
-}
-
-fn siphon(cast: Cast, game: &mut Game, values: Siphon) {
-    let amount =
-        game.value(Value::Stat { construct: cast.source, stat: Stat::BluePower }).pct(values.blue_dmg_multi())
-        + game.value(Value::Stat { construct: cast.source, stat: Stat::GreenPower }).pct(values.green_dmg_multi());
-
-    game.action(cast,
-        Action::Effect {
-            construct: cast.target,
-            effect: ConstructEffect { effect: Effect::Siphon, duration: values.duration(), meta:
-                Some(EffectMeta::CastTick { source: cast.source, target: cast.target, skill: Skill::SiphonTick, speed: cast.speed, amount }) },
-        }
-    );
-    game.action(cast,
-        Action::Damage {
-            construct: cast.target,
-            colour: Colour::Blue,
-            amount,
-        }
-    );
-    game.action(cast,
-        Action::Effect {
-            construct: cast.target,
-            effect: ConstructEffect { effect: Effect::Siphoned, duration: 1, meta: None }, // immunity to additional ticks
-        }
-    );
-    game.action(cast,
-        Action::Heal {
-            construct: cast.source,
-            colour: Colour::Green,
-            amount: game.value(Value::DamageReceived { construct: cast.target, colour: Colour::Blue }).pct(100),
-        },
-    );
-}
-
-fn siphon_tick(cast: Cast, game: &mut Game) {
-    game.action(cast,
-        Action::Damage {
-            construct: cast.target,
-            colour: Colour::Blue,
-            amount: game.value(Value::TickDamage { construct: cast.target, effect: Effect::Siphon }),
-        }
-    );
-    game.action(cast,
-        Action::Effect {
-            construct: cast.target,
-            effect: ConstructEffect { effect: Effect::Siphoned, duration: 1, meta: None }, // immunity to additional ticks
-        }
-    );
-    game.action(cast,
-        Action::Heal {
-            construct: cast.source,
-            colour: Colour::Green,
-            amount: game.value(Value::DamageReceived { construct: cast.target, colour: Colour::Blue }).pct(100),
-        },
-    );
-}
-
-#[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
-enum Slay { Base, Plus, PlusPlus }
-impl Slay {
-    pub fn blue_dmg_multi(self) -> usize {
-        match self { Slay::Base => 40, Slay::Plus => 50, Slay::PlusPlus => 65 }
-    }
-
-    pub fn green_dmg_multi(self) -> usize {
-        match self { Slay::Base => 40, Slay::Plus => 50, Slay::PlusPlus => 65 }
-    }
-}
-
-fn slay(cast: Cast, game: &mut Game, values: Slay) {
-    let amount =
-        game.value(Value::Stat { construct: cast.source, stat: Stat::BluePower }).pct(values.blue_dmg_multi())
-        + game.value(Value::Stat { construct: cast.source, stat: Stat::GreenPower }).pct(values.green_dmg_multi());
-
-    game.action(cast,
-        Action::Damage {
-            construct: cast.target,
-            colour: Colour::Red,
-            amount,
-        }
-    );
-    game.action(cast,
-        Action::Heal {
-            construct: cast.source,
-            colour: Colour::Green,
-            amount: game.value(Value::DamageReceived { construct: cast.target, colour: Colour::Red }),
-        },
-    );
-}
-
 #[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
 enum Sleep { Base, Plus, PlusPlus }
 impl Sleep {
@@ -1802,34 +1826,6 @@ fn silence(cast: Cast, game: &mut Game, values: Silence) {
     );
 }
 
-#[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
-enum Strike { Base, Plus, PlusPlus, Haste }
-impl Strike {
-    pub fn dmg_multi(self) -> usize {
-        match self {
-            Strike::Base => 90,
-            Strike::Plus => 110,
-            Strike::PlusPlus => 140,
-            Strike::Haste => 60,
-        }
-    }
-}
-
-fn strike(cast: Cast, game: &mut Game, values: Strike) {
-    let amount = match values {
-        Strike::Haste => game.value(Value::Stat { construct: cast.source, stat: Stat::Speed }).pct(values.dmg_multi()),
-        _ => game.value(Value::Stat { construct: cast.source, stat: Stat::RedPower }).pct(values.dmg_multi())
-    };
-
-    game.action(cast,
-        Action::Damage {
-            construct: cast.target,
-            colour: Colour::Red,
-            amount,
-        },
-    );
-}
-
 #[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
 enum Sustain { Base, Plus, PlusPlus }
 impl Sustain {