context: #region LICENSE
  
  /*
   Copyright 2014 - 2014 LeagueSharp
   Damage.cs is part of LeagueSharp.Common.
   
   LeagueSharp.Common is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
   
   LeagueSharp.Common is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
   GNU General Public License for more details.
   
   You should have received a copy of the GNU General Public License
   along with LeagueSharp.Common. If not, see <http://www.gnu.org/licenses/>.
  */
  
  #endregion
  
  #region
  
  using System;
  using System.Collections.Generic;
  using System.Linq;
  
  #endregion
  
  namespace LeagueSharp.Common
  {
      public delegate double SpellDamageDelegate(Obj_AI_Base source, Obj_AI_Base target, int level);
  
      public class DamageSpell
      {
          public double CalculatedDamage;
          public SpellDamageDelegate Damage;
          public Damage.DamageType DamageType;
          public SpellSlot Slot;
          public int Stage;
      }
  
      public static class Damage
      {
          public enum DamageItems
          {
              Hexgun,
              Dfg,
              Botrk,
              Bilgewater,
              Tiamat,
              Hydra,
              BlackFireTorch,
              OdingVeils,
              FrostQueenClaim,
              LiandrysTorment,
          }
  
          public enum DamageType
          {
              Physical,
              Magical,
              True
          }
  
          public enum SummonerSpell
          {
              Ignite,
              Smite,
          }
  
          public static Dictionary<string, List<DamageSpell>> Spells =
              new Dictionary<string, List<DamageSpell>>(StringComparer.OrdinalIgnoreCase);
  
          private static readonly List<PassiveDamage> AttackPassives = new List<PassiveDamage>();
          //attack passives are handled in the orbwalker, it will be changed in the future :^)
  
          static Damage()
          {
              //Add the passive damages
              PassiveDamage p;
  
              #region PassiveDamages
  
              #region Aatrox
  
              p = new PassiveDamage
              {
                  ChampionName = "Aatrox",
                  IsActive = (source, target) => (source.HasBuff("AatroxWPower") && source.HasBuff("AatroxWONHPowerBuff")),
                  GetDamage = (source, target) => ((float) source.GetSpellDamage(target, SpellSlot.W)),
              };
              AttackPassives.Add(p);
  
              #endregion
  
              #region Alistar
  
              p = new PassiveDamage
              {
                  ChampionName = "Alistar",
                  IsActive = (source, target) => (source.HasBuff("Trample")),
                  GetDamage =
                      (source, target) =>
                          ((float)
                              source.CalcDamage(
                                  target, DamageType.Magical, 6d + source.Level + (0.1d * source.FlatMagicDamageMod))),
              };
              AttackPassives.Add(p);
  
              #endregion
  
              #region Caitlyn
  
              p = new PassiveDamage
              {
                  ChampionName = "Caitlyn",
                  IsActive = (source, target) => (source.HasBuff("CaitlynHeadshotReady")),
                  GetDamage =
                      (source, target) =>
                          ((float)
                              source.CalcDamage(
                                  target, DamageType.Physical,
                                  1.5d * (source.BaseAttackDamage + source.FlatPhysicalDamageMod))),
              };
              AttackPassives.Add(p);
  
              #endregion
  
              #region Draven
  
              p = new PassiveDamage
              {
                  ChampionName = "Draven",
                  IsActive = (source, target) => (source.HasBuff("dravenspinning")),
                  GetDamage =
                      (source, target) =>
                          ((float)
                              source.CalcDamage(
                                  target, DamageType.Physical,
                                  0.45d * (source.BaseAttackDamage + source.FlatPhysicalDamageMod))),
              };
              AttackPassives.Add(p);
  
              #endregion
  
              #region Corki
  
              p = new PassiveDamage
              {
                  ChampionName = "Corki",
                  IsActive = (source, target) => (source.HasBuff("rapidreload")),
                  GetDamage =
                      (source, target) => ((float) 0.1d * (source.BaseAttackDamage + source.FlatPhysicalDamageMod)),
              };
              AttackPassives.Add(p);
  
              #endregion
  
              #region Gnar
  
              p = new PassiveDamage
              {
                  ChampionName = "Gnar",
                  IsActive =
                      (source, target) =>
                          (from buff in target.Buffs where buff.DisplayName == "GnarWProc" select buff.Count)
                              .FirstOrDefault() == 2,
                  GetDamage = (source, target) => ((float) source.GetSpellDamage(target, SpellSlot.W)),
              };
              AttackPassives.Add(p);
  
              #endregion
  
              #region Jinx
  
              p = new PassiveDamage
              {
                  ChampionName = "Jinx",
                  IsActive = (source, target) => (source.HasBuff("JinxQ")),
                  GetDamage =
                      (source, target) =>
                          ((float)
                              source.CalcDamage(
                                  target, DamageType.Physical,
                                  0.1d * (source.BaseAttackDamage + source.FlatPhysicalDamageMod))),
              };
              AttackPassives.Add(p);
  
              #endregion
  
              #region Katarina
  
              p = new PassiveDamage
              {
                  ChampionName = "Katarina",
                  IsActive = (source, target) => (target.HasBuff("KataQMark1")),
                  GetDamage = (source, target) => ((float) source.GetSpellDamage(target, SpellSlot.Q, 1)),
              };
              AttackPassives.Add(p);
  
              #endregion
  
              #region KogMaw
  
              p = new PassiveDamage
              {
                  ChampionName = "KogMaw",
                  IsActive = (source, target) => (source.HasBuff("KogMawBioArcaneBarrage")),
                  GetDamage = (source, target) => ((float) source.GetSpellDamage(target, SpellSlot.W)),
              };
              AttackPassives.Add(p);
  
              #endregion
  
              #region MissFortune
  
              p = new PassiveDamage
              {
                  ChampionName = "MissFortune",
                  IsActive = (source, target) => (source.HasBuff("MissFortunePassive")),
                  GetDamage =
                      (source, target) =>
                          (float)
                              source.CalcDamage(
                                  target, DamageType.Magical,
                                  (float) 0.06 * (source.BaseAttackDamage + source.FlatPhysicalDamageMod)),
              };
              AttackPassives.Add(p);
  
              #endregion
  
              #region Nasus
  
              p = new PassiveDamage
              {
                  ChampionName = "Nasus",
                  IsActive = (source, target) => (source.HasBuff("NasusQ")),
                  GetDamage = (source, target) => ((float) source.GetSpellDamage(target, SpellSlot.Q)),
              };
              AttackPassives.Add(p);
  
              #endregion
  
              #region Orianna
  
              p = new PassiveDamage
              {
                  ChampionName = "Orianna",
                  IsActive = (source, target) => (source.HasBuff("orianaspellsword")),
                  GetDamage =
                      (source, target) =>
                          (float)
                              source.CalcDamage(
                                  target, DamageType.Magical,
                                  (float) 0.15 * source.FlatMagicDamageMod +
                                  new float[] { 10, 10, 10, 18, 18, 18, 26, 26, 26, 34, 34, 34, 42, 42, 42, 50, 50, 50 }[
                                      source.Level - 1]),
              };
              AttackPassives.Add(p);
  
              #endregion
  
              #region Riven
  
              p = new PassiveDamage
              {
                  ChampionName = "Riven",
                  IsActive = (source, target) => source.GetBuffCount("rivenpassiveaaboost") > 0,
                  GetDamage =
                      (source, target) =>
                          ((float)
                              source.CalcDamage(
                                  target, DamageType.Physical,
                                  new double[] { 0.2, 0.2, 0.25, 0.25, 0.25, 0.3, 0.3, 0.3, 0.35, 0.35, 0.35, 0.4, 0.4, 0.4, 0.45, 0.45, 0.45, 0.5 }[
                                  source.Level - 1] * (source.BaseAttackDamage + source.FlatPhysicalDamageMod))),
              };
              AttackPassives.Add(p);
  
              #endregion
  
              #region Teemo
  
              p = new PassiveDamage
              {
                  ChampionName = "Teemo",
                  IsActive = (source, target) => (source.HasBuff("ToxicShot")),
                  GetDamage =
                      (source, target) =>
                          ((float)
                              source.CalcDamage(
                                  target, DamageType.Magical,
                                  source.Spellbook.GetSpell(SpellSlot.E).Level * 10 + source.FlatMagicDamageMod * 0.3)),
              };
              AttackPassives.Add(p);
  
              #endregion
  
              #region TwistedFate
  
              p = new PassiveDamage
              {
                  ChampionName = "TwistedFate",
                  IsActive = (source, target) => (source.HasBuff("bluecardpreattack")),
                  GetDamage =
                      (source, target) =>
                          (float) source.GetSpellDamage(target, SpellSlot.W) -
                          (float)
                              source.CalcDamage(
                                  target, DamageType.Physical, (source.BaseAttackDamage + source.FlatPhysicalDamageMod)),
              };
              AttackPassives.Add(p);
  
              p = new PassiveDamage
              {
                  ChampionName = "TwistedFate",
                  IsActive = (source, target) => (source.HasBuff("cardmasterstackparticle")),
                  GetDamage = (source, target) => (float) source.GetSpellDamage(target, SpellSlot.E),
              };
              AttackPassives.Add(p);
  
              #endregion
  
              #region Varus
  
              p = new PassiveDamage
              {
                  ChampionName = "Varus",
                  IsActive = (source, target) => (source.HasBuff("VarusW")),
                  GetDamage = (source, target) => ((float) source.GetSpellDamage(target, SpellSlot.W)),
              };
              AttackPassives.Add(p);
  
              #endregion
  
              #region Vayne
  
              p = new PassiveDamage
              {
                  ChampionName = "Vayne",
                  IsActive = (source, target) => (source.HasBuff("vaynetumblebonus")),
                  GetDamage = (source, target) => ((float) source.GetSpellDamage(target, SpellSlot.Q)),
              };
              AttackPassives.Add(p);
  
              p = new PassiveDamage
              {
                  ChampionName = "Vayne",
                  IsActive =
                      (source, target) =>
                          (from buff in target.Buffs where buff.Name == "vaynesilvereddebuff" select buff.Count)
                              .FirstOrDefault() == 2,
                  GetDamage = (source, target) => ((float) source.GetSpellDamage(target, SpellSlot.W)),
              };
              AttackPassives.Add(p);
  
              #endregion
  
              #region Ziggs
  
              p = new PassiveDamage
              {
                  ChampionName = "Ziggs",
                  IsActive = (source, target) => (source.HasBuff("ziggsshortfuse")),
                  GetDamage =
                      (source, target) =>
                          (float)
                              source.CalcDamage(
                                  target, DamageType.Magical,
                                  (float) 0.25d * source.FlatMagicDamageMod +
                                  new float[]
                                  { 20, 24, 28, 32, 36, 40, 48, 56, 64, 72, 80, 88, 100, 112, 124, 136, 148, 160 }[
                                      source.Level - 1]),
              };
              AttackPassives.Add(p);
  
              #endregion
  
              #endregion
  
              //Synced on -[dte]- 18:53 with patch 4.16 data.
  
              #region Spells
  
              Spells.Add(
                  "Aatrox", new List<DamageSpell>
                  {
                      //Q
                      new DamageSpell
                      {
                          Slot = SpellSlot.Q,
                          DamageType = DamageType.Physical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 70, 115, 160, 205, 250 }[level] + 0.6 * source.FlatPhysicalDamageMod
                      },
                      //W
                      new DamageSpell
                      {
                          Slot = SpellSlot.W,
                          DamageType = DamageType.Physical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 60, 95, 130, 165, 200 }[level] + 1 * source.FlatPhysicalDamageMod
                      },
                      //E
                      new DamageSpell
                      {
                          Slot = SpellSlot.E,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 75, 110, 145, 180, 215 }[level] + 0.6 * source.FlatMagicDamageMod +
                                  0.6 * source.FlatPhysicalDamageMod
                      },
                      //R
                      new DamageSpell
                      {
                          Slot = SpellSlot.R,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 200, 300, 400 }[level] + 1 * source.FlatMagicDamageMod
                      },
                  });
  
              Spells.Add(
                  "Ahri", new List<DamageSpell>
                  {
                      //Normal Q
                      new DamageSpell
                      {
                          Slot = SpellSlot.Q,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 40, 65, 90, 115, 140 }[level] + 0.35 * source.FlatMagicDamageMod
                      },
                      //Q Return
                      new DamageSpell
                      {
                          Slot = SpellSlot.Q,
                          Stage = 1,
                          DamageType = DamageType.True,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 40, 65, 90, 115, 140 }[level] + 0.35 * source.FlatMagicDamageMod
                      },
                      //W => Magic Damage to the Same Target
                      new DamageSpell
                      {
                          Slot = SpellSlot.W,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 64, 104, 144, 184, 224 }[level] + 0.64 * source.FlatMagicDamageMod
                      },
                      //W => 1 FF
                      new DamageSpell
                      {
                          Slot = SpellSlot.W,
                          Stage = 1,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 40, 65, 90, 115, 140 }[level] + 0.4 * source.FlatMagicDamageMod
                      },
                      //E
                      new DamageSpell
                      {
                          Slot = SpellSlot.E,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 60, 95, 130, 165, 200 }[level] + 0.35 * source.FlatMagicDamageMod
                      },
                      //R, per dash
                      new DamageSpell
                      {
                          Slot = SpellSlot.R,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 70, 110, 150 }[level] + 0.3 * source.FlatMagicDamageMod
                      },
                  });
  
              Spells.Add(
                  "Akali", new List<DamageSpell>
                  {
                      //Q Initial
                      new DamageSpell
                      {
                          Slot = SpellSlot.Q,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 35, 55, 75, 95, 115 }[level] + 0.4 * source.FlatMagicDamageMod
                      },
                      //Q Detonation
                      new DamageSpell
                      {
                          Slot = SpellSlot.Q,
                          Stage = 1,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 45, 70, 95, 120, 145 }[level] + 0.5 * source.FlatMagicDamageMod
                      },
                      //E
                      new DamageSpell
                      {
                          Slot = SpellSlot.E,
                          DamageType = DamageType.Physical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 30, 55, 80, 105, 130 }[level] + 0.4 * source.FlatMagicDamageMod +
                                  0.6 * (source.BaseAttackDamage + source.FlatPhysicalDamageMod)
                      },
                      //R
                      new DamageSpell
                      {
                          Slot = SpellSlot.R,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 100, 175, 250 }[level] + 0.5 * source.FlatMagicDamageMod
                      },
                  });
  
              Spells.Add(
                  "Alistar", new List<DamageSpell>
                  {
                      //Q Initial
                      new DamageSpell
                      {
                          Slot = SpellSlot.Q,
                          DamageType = DamageType.Physical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 60, 105, 150, 195, 240 }[level] + 0.5 * source.FlatMagicDamageMod
                      },
                      //W
                      new DamageSpell
                      {
                          Slot = SpellSlot.W,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 55, 110, 165, 220, 275 }[level] + 0.7 * source.FlatMagicDamageMod
                      },
                  });
  
              Spells.Add(
                  "Amumu", new List<DamageSpell>
                  {
                      //Q
                      new DamageSpell
                      {
                          Slot = SpellSlot.Q,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 80, 130, 180, 230, 280 }[level] + 0.7 * source.FlatMagicDamageMod
                      },
                      //W - per second
                      new DamageSpell
                      {
                          Slot = SpellSlot.W,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 8, 12, 16, 20, 24 }[level] +
                                  (new[] { 0.01, 0.015, 0.02, 0.025, 0.03 }[level] +
                                   0.01 * source.FlatMagicDamageMod / 100) * target.MaxHealth
                      },
                      //E
                      new DamageSpell
                      {
                          Slot = SpellSlot.E,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 75, 100, 125, 150, 175 }[level] + 0.5 * source.FlatMagicDamageMod
                      },
                      //R
                      new DamageSpell
                      {
                          Slot = SpellSlot.R,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 150, 250, 350 }[level] + 0.8 * source.FlatMagicDamageMod
                      },
                  });
  
              Spells.Add(
                  "Anivia", new List<DamageSpell>
                  {
                      //Q
                      new DamageSpell
                      {
                          Slot = SpellSlot.Q,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 60, 90, 120, 150, 180 }[level] + 0.5 * source.FlatMagicDamageMod
                      },
                      //Q - max
                      new DamageSpell
                      {
                          Slot = SpellSlot.Q,
                          Stage = 1,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 60, 90, 120, 150, 180 }[level] * 2 + 1 * source.FlatMagicDamageMod
                      },
                      //E - not chilled targets - TODO
                      new DamageSpell
                      {
                          Slot = SpellSlot.E,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 55, 85, 115, 145, 175 }[level] + 0.5 * source.FlatMagicDamageMod
                      },
                      //R - per second
                      new DamageSpell
                      {
                          Slot = SpellSlot.R,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 80, 120, 160 }[level] + 0.25 * source.FlatMagicDamageMod
                      },
                  });
  
              Spells.Add(
                  "Annie", new List<DamageSpell>
                  {
                      //Q
                      new DamageSpell
                      {
                          Slot = SpellSlot.Q,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 80, 115, 150, 185, 220 }[level] + 0.8 * source.FlatMagicDamageMod
                      },
                      //W
                      new DamageSpell
                      {
                          Slot = SpellSlot.W,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 70, 115, 160, 205, 250 }[level] + 0.85 * source.FlatMagicDamageMod
                      },
                      //R - total
                      new DamageSpell
                      {
                          Slot = SpellSlot.R,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 210, 335, 460 }[level] + 1 * source.FlatMagicDamageMod
                      },
                  });
  
              Spells.Add(
                  "Ashe", new List<DamageSpell>
                  {
                      //W
                      new DamageSpell
                      {
                          Slot = SpellSlot.W,
                          DamageType = DamageType.Physical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 20, 35, 50, 65, 80 }[level] +
                                  1 * (source.BaseAttackDamage + source.FlatPhysicalDamageMod)
                      },
                      //R - total
                      new DamageSpell
                      {
                          Slot = SpellSlot.R,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 250, 425, 600 }[level] + 1 * source.FlatMagicDamageMod
                      },
                      //R - Min
                      new DamageSpell
                      {
                          Slot = SpellSlot.R,
                          Stage = 1,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  (new double[] { 250, 425, 600 }[level] + 1 * source.FlatMagicDamageMod) / 2
                      },
                  });
  
              Spells.Add(
                  "Azir", new List<DamageSpell>
                  {
                      //Q
                      new DamageSpell
                      {
                          Slot = SpellSlot.Q,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 65, 85, 105, 125, 145 }[level] + 0.5 * source.FlatMagicDamageMod
                      },
                      //W - Soldier auto attacks
                      new DamageSpell
                      {
                          Slot = SpellSlot.W,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  45 +
                                  new double[]
                                  { 50, 55, 60, 65, 70, 75, 80, 85, 90, 95, 100, 110, 120, 130, 140, 150, 160, 170 }[
                                      ((Obj_AI_Hero) source).Level - 1] + 0.6 * source.FlatMagicDamageMod
                      },
                      //E
                      new DamageSpell
                      {
                          Slot = SpellSlot.E,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 80, 120, 160, 200, 240 }[level] + 0.4 * source.FlatMagicDamageMod
                      },
                      //R
                      new DamageSpell
                      {
                          Slot = SpellSlot.R,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 150, 225, 300 }[level] + 0.6 * source.FlatMagicDamageMod
                      },
                  });
  
              Spells.Add(
                  "Blitzcrank", new List<DamageSpell>
                  {
                      //Q
                      new DamageSpell
                      {
                          Slot = SpellSlot.Q,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 80, 135, 190, 245, 300 }[level] + 1 * source.FlatMagicDamageMod
                      },
                      //E
                      new DamageSpell
                      {
                          Slot = SpellSlot.E,
                          DamageType = DamageType.Physical,
                          Damage = (source, target, level) => 1 * (source.BaseAttackDamage + source.FlatPhysicalDamageMod)
                      },
                      //R
                      new DamageSpell
                      {
                          Slot = SpellSlot.R,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 250, 375, 500 }[level] + 1 * source.FlatMagicDamageMod
                      },
                  });
  
              Spells.Add(
                  "Bard", new List<DamageSpell>
                  {
                      //Q
                      new DamageSpell
                      {
                          Slot = SpellSlot.Q,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 80, 125, 170, 215, 260 }[level] + 0.65 * source.FlatMagicDamageMod
                      },
                  });
  
              Spells.Add(
                  "Brand", new List<DamageSpell>
                  {
                      //Q
                      new DamageSpell
                      {
                          Slot = SpellSlot.Q,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 80, 120, 160, 200, 240 }[level] + 0.65 * source.FlatMagicDamageMod
                      },
                      //W
                      new DamageSpell
                      {
                          Slot = SpellSlot.W,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 75, 120, 165, 210, 255 }[level] + 0.6 * source.FlatMagicDamageMod
                      },
                      //E
                      new DamageSpell
                      {
                          Slot = SpellSlot.E,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 70, 105, 140, 175, 210 }[level] + 0.55 * source.FlatMagicDamageMod
                      },
                      //R
                      new DamageSpell
                      {
                          Slot = SpellSlot.R,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 150, 250, 350 }[level] + 0.5 * source.FlatMagicDamageMod
                      },
                  });
  
              Spells.Add(
                  "Braum", new List<DamageSpell>
                  {
                      //Q
                      new DamageSpell
                      {
                          Slot = SpellSlot.Q,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 60, 105, 150, 195, 240 }[level] + 0.025 * source.MaxHealth
                      },
                      //R
                      new DamageSpell
                      {
                          Slot = SpellSlot.R,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 150, 250, 350 }[level] + 0.6 * source.FlatMagicDamageMod
                      },
                  });
  
              Spells.Add(
                  "Caitlyn", new List<DamageSpell>
                  {
                      //Q
                      new DamageSpell
                      {
                          Slot = SpellSlot.Q,
                          DamageType = DamageType.Physical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 20, 60, 100, 140, 180 }[level] +
                                  1.3 * (source.BaseAttackDamage + source.FlatPhysicalDamageMod)
                      },
                      //W
                      new DamageSpell
                      {
                          Slot = SpellSlot.W,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 80, 130, 180, 230, 280 }[level] + 0.6 * source.FlatMagicDamageMod
                      },
                      //E
                      new DamageSpell
                      {
                          Slot = SpellSlot.E,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 80, 130, 180, 230, 280 }[level] + 0.8 * source.FlatMagicDamageMod
                      },
                      //R
                      new DamageSpell
                      {
                          Slot = SpellSlot.R,
                          DamageType = DamageType.Physical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 250, 475, 700 }[level] + 2 * source.FlatPhysicalDamageMod
                      },
                  });
  
              Spells.Add(
                  "Cassiopeia", new List<DamageSpell>
                  {
                      //Q
                      new DamageSpell
                      {
                          Slot = SpellSlot.Q,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 75, 115, 155, 195, 235 }[level] + 0.45 * source.FlatMagicDamageMod
                      },
                      //W
                      new DamageSpell
                      {
                          Slot = SpellSlot.W,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 10, 15, 20, 25, 30 }[level] + 0.1 * source.FlatMagicDamageMod
                      },
                      //E 
                      new DamageSpell
                      {
                          Slot = SpellSlot.E,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 55, 80, 105, 130, 155 }[level] + 0.55 * source.FlatMagicDamageMod
                      },
                      //R
                      new DamageSpell
                      {
                          Slot = SpellSlot.R,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 150, 250, 350 }[level] + 0.5 * source.FlatMagicDamageMod
                      },
                  });
  
              Spells.Add(
                  "ChoGath", new List<DamageSpell>
                  {
                      //Q
                      new DamageSpell
                      {
                          Slot = SpellSlot.Q,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 80, 135, 190, 245, 305 }[level] + 1 * source.FlatMagicDamageMod
                      },
                      //W
                      new DamageSpell
                      {
                          Slot = SpellSlot.W,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 75, 125, 175, 225, 275 }[level] + 0.7 * source.FlatMagicDamageMod
                      },
                      //E
                      new DamageSpell
                      {
                          Slot = SpellSlot.E,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 20, 35, 50, 65, 80 }[level] + 0.3 * source.FlatMagicDamageMod
                      },
                      //R
                      new DamageSpell
                      {
                          Slot = SpellSlot.R,
                          DamageType = DamageType.True,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 300, 475, 650 }[level] + 0.7 * source.FlatMagicDamageMod
                      },
                  });
  
              Spells.Add(
                  "Corki", new List<DamageSpell>
                  {
                      //Q
                      new DamageSpell
                      {
                          Slot = SpellSlot.Q,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 80, 130, 180, 230, 280 }[level] + 0.5 * source.FlatMagicDamageMod +
                                  0.5 * source.FlatPhysicalDamageMod
                      },
                      //W
                      new DamageSpell
                      {
                          Slot = SpellSlot.W,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 60, 90, 120, 150, 180 }[level] + 0.4 * source.FlatMagicDamageMod
                      },
                      //E
                      new DamageSpell
                      {
                          Slot = SpellSlot.E,
                          DamageType = DamageType.Physical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 20, 32, 44, 56, 68 }[level] + 0.4 * source.FlatPhysicalDamageMod
                      },
                      //R - Normal missile
                      new DamageSpell
                      {
                          Slot = SpellSlot.R,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 100, 180, 260 }[level] + 0.3 * source.FlatMagicDamageMod +
                                  new double[] { 20, 30, 40 }[level] / 100 *
                                  (source.BaseAttackDamage + source.FlatPhysicalDamageMod)
                      },
                      //R - Big missile
                      new DamageSpell
                      {
                          Slot = SpellSlot.R,
                          Stage = 1,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 150, 270, 390 }[level] + 0.45 * source.FlatMagicDamageMod +
                                  new double[] { 30, 40, 60 }[level] / 100 *
                                  (source.BaseAttackDamage + source.FlatPhysicalDamageMod)
                      },
                  });
  
              Spells.Add(
                  "Darius", new List<DamageSpell>
                  {
                      //Q
                      new DamageSpell
                      {
                          Slot = SpellSlot.Q,
                          DamageType = DamageType.Physical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 70, 105, 140, 175, 210 }[level] + 0.7 * source.FlatPhysicalDamageMod
                      },
                      //Q - Blade
                      new DamageSpell
                      {
                          Slot = SpellSlot.Q,
                          Stage = 1,
                          DamageType = DamageType.Physical,
                          Damage =
                              (source, target, level) =>
                                  new[] { 105, 157.5, 210, 262.5, 315 }[level] + 1.05 * source.FlatPhysicalDamageMod
                      },
                      //W
                      new DamageSpell
                      {
                          Slot = SpellSlot.W,
                          DamageType = DamageType.Physical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 20, 40, 60, 80, 100 }[level] / 100 *
                                  (source.BaseAttackDamage + source.FlatPhysicalDamageMod)
                      },
                      //R 
                      new DamageSpell
                      {
                          Slot = SpellSlot.R,
                          DamageType = DamageType.True,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 160, 250, 340 }[level] + 0.75 * source.FlatPhysicalDamageMod
                      },
                  });
  
              Spells.Add(
                  "Diana", new List<DamageSpell>
                  {
                      //Q
                      new DamageSpell
                      {
                          Slot = SpellSlot.Q,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 60, 95, 130, 165, 200 }[level] + 0.7 * source.FlatMagicDamageMod
                      },
                      //W
                      new DamageSpell
                      {
                          Slot = SpellSlot.W,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 22, 34, 46, 58, 70 }[level] + 0.2 * source.FlatMagicDamageMod
                      },
                      //R - total
                      new DamageSpell
                      {
                          Slot = SpellSlot.R,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 100, 160, 220 }[level] + 0.6 * source.FlatMagicDamageMod
                      },
                  });
  
              Spells.Add(
                  "DrMundo", new List<DamageSpell>
                  {
                      //Q
                      new DamageSpell
                      {
                          Slot = SpellSlot.Q,
                          DamageType = DamageType.Magical,
                          Damage = (source, target, level) =>
                          {
                              if (target is Obj_AI_Minion)
                              {
                                  return Math.Min(
                                      new double[] { 300, 400, 500, 600, 700 }[level],
                                      Math.Max(
                                          new double[] { 80, 130, 180, 230, 280 }[level],
                                          new double[] { 15, 18, 21, 23, 25 }[level] / 100 * target.Health));
                              }
                              return Math.Max(
                                  new double[] { 80, 130, 180, 230, 280 }[level],
                                  new double[] { 15, 18, 21, 23, 25 }[level] / 100 * target.Health);
                          }
                      },
                      //W - per second
                      new DamageSpell
                      {
                          Slot = SpellSlot.W,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 35, 50, 65, 80, 95 }[level] + 0.2 * source.FlatMagicDamageMod
                      }
                  });
  
              Spells.Add(
                  "Draven", new List<DamageSpell>
                  {
                      //Q
                      new DamageSpell
                      {
                          Slot = SpellSlot.Q,
                          DamageType = DamageType.Physical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 45, 55, 65, 75, 85 }[level] / 100 *
                                  (source.BaseAttackDamage + source.FlatPhysicalDamageMod)
                      },
                      //E
                      new DamageSpell
                      {
                          Slot = SpellSlot.E,
                          DamageType = DamageType.Physical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 70, 105, 140, 175, 210 }[level] + 0.5 * source.FlatPhysicalDamageMod
                      },
                      //R
                      new DamageSpell
                      {
                          Slot = SpellSlot.R,
                          DamageType = DamageType.Physical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 175, 275, 375 }[level] + 1.1 * source.FlatPhysicalDamageMod
                      },
                  });
  
              Spells.Add(
                  "Ekko", new List<DamageSpell>
                   {
                      // Q - Outgoing
                      new DamageSpell
                      {
                          Slot = SpellSlot.Q,
                          DamageType = DamageType.Magical,
                          Damage = 
                              (source, target, level) => 
                                  new double[] { 60, 75, 90, 105, 120 }[level] + 0.2 * source.FlatMagicDamageMod
                      },
                      // Q - Incoming
                      new DamageSpell
                      {
                          Slot = SpellSlot.Q,
                          Stage = 1,
                          DamageType = DamageType.Magical,
                          Damage = 
                              (source, target, level) =>
                                  new double[] { 60, 85, 110, 135, 160 }[level] + 0.6 * source.FlatMagicDamageMod
                      },
                      // W
                      new DamageSpell
                      {
                          Slot = SpellSlot.W,
                          DamageType = DamageType.Magical,
                          Damage = 
                              (source, target, level) =>  
                                  new double[] { 150, 195, 240, 285, 330 }[level] + 0.8 * source.FlatMagicDamageMod
                      },
                      // E
                      new DamageSpell
                      {
                          Slot = SpellSlot.E,
                          DamageType = DamageType.Magical,
                          Damage = 
                              (source, target, level) => 
                                  new double[] { 50, 80, 110, 140, 170 }[level] + 0.2 * source.FlatMagicDamageMod
                      },
                      // R
                      new DamageSpell
                      {
                          Slot = SpellSlot.R,
                          DamageType = DamageType.Magical,
                          Damage = 
                              (source, target, level) => 
                                  new double[] { 200, 350, 500 }[level] + 1.3 * source.FlatMagicDamageMod    
                      }
                   });
  
              Spells.Add(
                  "Elise", new List<DamageSpell>
                  {
                      //Q - Human
                      new DamageSpell
                      {
                          Slot = SpellSlot.Q,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 40, 75, 110, 145, 180 }[level] +
                                  (0.08 + 0.03 / 100 * source.FlatMagicDamageMod) * target.Health
                      },
                      //Q - Spider
                      new DamageSpell
                      {
                          Slot = SpellSlot.Q,
                          Stage = 1,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 60, 100, 140, 180, 220 }[level] +
                                  (0.08 + 0.03 / 100 * source.FlatMagicDamageMod) * (target.MaxHealth - target.Health)
                      },
                      //W - Human
                      new DamageSpell
                      {
                          Slot = SpellSlot.W,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 75, 125, 175, 225, 275 }[level] + 0.8 * source.FlatMagicDamageMod
                      },
                  });
  
              Spells.Add(
                  "Evelynn", new List<DamageSpell>
                  {
                      //Q
                      new DamageSpell
                      {
                          Slot = SpellSlot.Q,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 40, 55, 70, 85, 100 }[level] +
                                  new double[] { 35, 40, 45, 50, 55 }[level] / 100 * source.FlatMagicDamageMod +
                                  new double[] { 50, 55, 60, 65, 70 }[level] / 100 * source.FlatPhysicalDamageMod
                      },
                      //E
                      new DamageSpell
                      {
                          Slot = SpellSlot.E,
                          DamageType = DamageType.Physical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 70, 110, 150, 190, 230 }[level] + 1 * source.FlatMagicDamageMod +
                                  1 * source.FlatPhysicalDamageMod
                      },
                      //R - total
                      new DamageSpell
                      {
                          Slot = SpellSlot.R,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  (new[] { 0.15, 0.20, 0.25 }[level] + 0.01 / 100 * source.FlatMagicDamageMod) *
                                  target.Health
                      },
                  });
  
              Spells.Add(
                  "Ezreal", new List<DamageSpell>
                  {
                      //Q
                      new DamageSpell
                      {
                          Slot = SpellSlot.Q,
                          DamageType = DamageType.Physical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 35, 55, 75, 95, 115 }[level] + 0.4 * source.FlatMagicDamageMod +
                                  1.1 * (source.BaseAttackDamage + source.FlatPhysicalDamageMod)
                      },
                      //W
                      new DamageSpell
                      {
                          Slot = SpellSlot.W,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 70, 115, 160, 205, 250 }[level] + 0.8 * source.FlatMagicDamageMod
                      },
                      //E
                      new DamageSpell
                      {
                          Slot = SpellSlot.E,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 75, 125, 175, 225, 275 }[level] + 0.75 * source.FlatMagicDamageMod
                      },
                      //R
                      new DamageSpell
                      {
                          Slot = SpellSlot.R,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 350, 500, 650 }[level] + 0.9 * source.FlatMagicDamageMod +
                                  1 * source.FlatPhysicalDamageMod
                      },
                  });
  
              Spells.Add(
                  "Fiddlesticks", new List<DamageSpell>
                  {
                      //W - Per second
                      new DamageSpell
                      {
                          Slot = SpellSlot.W,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 60, 90, 120, 150, 180 }[level] + 0.45 * source.FlatMagicDamageMod
                      },
                      //E - Per bounce
                      new DamageSpell
                      {
                          Slot = SpellSlot.E,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 65, 85, 105, 125, 145 }[level] + 0.45 * source.FlatMagicDamageMod
                      },
                      //R - Per second
                      new DamageSpell
                      {
                          Slot = SpellSlot.R,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 125, 225, 325 }[level] + 0.45 * source.FlatMagicDamageMod
                      },
                  });
  
              Spells.Add(
                  "Fiora", new List<DamageSpell>
                  {
                      //Q - per dash
                      new DamageSpell
                      {
                          Slot = SpellSlot.Q,
                          DamageType = DamageType.Physical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 40, 65, 90, 115, 140 }[level] + 0.6 * source.FlatPhysicalDamageMod
                      },
                      //W 
                      new DamageSpell
                      {
                          Slot = SpellSlot.W,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 60, 110, 160, 210, 260 }[level] + 1 * source.FlatMagicDamageMod
                      },
                      //R - Max damage
                      new DamageSpell
                      {
                          Slot = SpellSlot.R,
                          DamageType = DamageType.Physical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 325, 663, 1001 }[level] + 2.34 * source.FlatPhysicalDamageMod
                      },
                  });
  
              Spells.Add(
                  "Fizz", new List<DamageSpell>
                  {
                      //Q - AA excluded.
                      new DamageSpell
                      {
                          Slot = SpellSlot.Q,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 10, 25, 40, 55, 70 }[level] + 0.3 * source.FlatMagicDamageMod
                      },
                      //W - Per attack
                      new DamageSpell
                      {
                          Slot = SpellSlot.W,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 10, 20, 30, 40, 50 }[level] + 0.25 * source.FlatMagicDamageMod
                      },
                      //E
                      new DamageSpell
                      {
                          Slot = SpellSlot.E,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 70, 120, 170, 220, 270 }[level] + 0.75 * source.FlatMagicDamageMod
                      },
                      //R
                      new DamageSpell
                      {
                          Slot = SpellSlot.R,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 200, 325, 450 }[level] + 1 * source.FlatMagicDamageMod
                      },
                  });
  
              Spells.Add(
                  "Galio", new List<DamageSpell>
                  {
                      //Q 
                      new DamageSpell
                      {
                          Slot = SpellSlot.Q,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 80, 135, 190, 245, 300 }[level] + 0.6 * source.FlatMagicDamageMod
                      },
                      //E
                      new DamageSpell
                      {
                          Slot = SpellSlot.E,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 60, 105, 150, 195, 240 }[level] + 0.5 * source.FlatMagicDamageMod
                      },
                      //R - max
                      new DamageSpell
                      {
                          Slot = SpellSlot.R,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 308, 462, 616 }[level] + 0.84 * source.FlatMagicDamageMod
                      },
                  });
  
              Spells.Add(
                  "GangPlank", new List<DamageSpell>
                  {
                      //Q 
                      new DamageSpell
                      {
                          Slot = SpellSlot.Q,
                          DamageType = DamageType.Physical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 20, 45, 70, 95, 120 }[level] +
                                  1 * (source.BaseAttackDamage + source.FlatPhysicalDamageMod)
                      },
                      //R - per cannonball
                      new DamageSpell
                      {
                          Slot = SpellSlot.R,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 75, 120, 165 }[level] + 0.2 * source.FlatMagicDamageMod
                      },
                  });
  
              Spells.Add(
                  "Garen", new List<DamageSpell>
                  {
                      //Q
                      new DamageSpell
                      {
                          Slot = SpellSlot.Q,
                          DamageType = DamageType.Physical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 30, 55, 80, 105, 130 }[level] +
                                  1.4 * (source.BaseAttackDamage + source.FlatPhysicalDamageMod)
                      },
                      //E 
                      new DamageSpell
                      {
                          Slot = SpellSlot.E,
                          DamageType = DamageType.Physical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 20, 45, 70, 95, 120 }[level] +
                                  new double[] { 70, 80, 90, 100, 110 }[level] / 100 *
                                  (source.BaseAttackDamage + source.FlatPhysicalDamageMod)
                      },
                      //R - Max damage
                      new DamageSpell
                      {
                          Slot = SpellSlot.R,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 175, 350, 525 }[level] +
                                  new[] { 28.57, 33.33, 40 }[level] / 100 * (target.MaxHealth - target.Health)
                      },
                  });
  
              Spells.Add(
                  "Gnar", new List<DamageSpell>
                  {
                      //Q - mini
                      new DamageSpell
                      {
                          Slot = SpellSlot.Q,
                          DamageType = DamageType.Physical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 5, 35, 65, 95, 125 }[level] +
                                  1.15 * (source.BaseAttackDamage + source.FlatPhysicalDamageMod)
                      },
                      //Q - big
                      new DamageSpell
                      {
                          Slot = SpellSlot.Q,
                          Stage = 1,
                          DamageType = DamageType.Physical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 5, 45, 85, 125, 165 }[level] +
                                  1.2 * (source.BaseAttackDamage + source.FlatPhysicalDamageMod)
                      },
                      //W - mini
                      new DamageSpell
                      {
                          Slot = SpellSlot.W,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 10, 20, 30, 40, 50 }[level] + 1 * source.FlatMagicDamageMod +
                                  new double[] { 6, 8, 10, 12, 14 }[level] / 100 * target.MaxHealth
                      },
                      //W - big
                      new DamageSpell
                      {
                          Slot = SpellSlot.W,
                          Stage = 1,
                          DamageType = DamageType.Physical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 25, 45, 65, 85, 105 }[level] +
                                  1 * (source.BaseAttackDamage + source.FlatPhysicalDamageMod)
                      },
                      //E - mini
                      new DamageSpell
                      {
                          Slot = SpellSlot.E,
                          DamageType = DamageType.Physical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 20, 60, 100, 140, 180 }[level] + source.MaxHealth * 0.06
                      },
                      //E - big
                      new DamageSpell
                      {
                          Slot = SpellSlot.E,
                          Stage = 1,
                          DamageType = DamageType.Physical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 20, 60, 100, 140, 180 }[level] + source.MaxHealth * 0.06
                      },
                      //R - Max damage
                      new DamageSpell
                      {
                          Slot = SpellSlot.R,
                          DamageType = DamageType.Physical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 200, 300, 400 }[level] + 0.5 * source.FlatMagicDamageMod +
                                  0.2 * source.FlatPhysicalDamageMod
                      },
                  });
  
              Spells.Add(
                  "Gragas", new List<DamageSpell>
                  {
                      //Q
                      new DamageSpell
                      {
                          Slot = SpellSlot.Q,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 80, 120, 160, 200, 240 }[level] + 0.6 * source.FlatMagicDamageMod
                      },
                      //W
                      new DamageSpell
                      {
                          Slot = SpellSlot.W,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 20, 50, 80, 110, 140 }[level] +
                                  new double[] { 8, 9, 10, 11, 12 }[level] / 100 * target.MaxHealth +
                                  0.3 * source.FlatMagicDamageMod
                      },
                      //E
                      new DamageSpell
                      {
                          Slot = SpellSlot.E,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 80, 130, 180, 230, 280 }[level] + 0.6 * source.FlatMagicDamageMod
                      },
                      //R
                      new DamageSpell
                      {
                          Slot = SpellSlot.R,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 200, 300, 400 }[level] + 0.7 * source.FlatMagicDamageMod
                      },
                  });
  
              Spells.Add(
                  "Graves", new List<DamageSpell>
                  {
                      //Q
                      new DamageSpell
                      {
                          Slot = SpellSlot.Q,
                          DamageType = DamageType.Physical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 60, 90, 120, 150, 180 }[level] + 0.75 * source.FlatPhysicalDamageMod
                      },
                      //Q
                      new DamageSpell
                      {
                          Slot = SpellSlot.Q,
                          Stage = 1,
                          DamageType = DamageType.Physical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 120, 180, 240, 300, 360 }[level] + 1.50 * source.FlatPhysicalDamageMod
                      },                    
                      //W
                      new DamageSpell
                      {
                          Slot = SpellSlot.W,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 60, 110, 160, 210, 260 }[level] + 0.6 * source.FlatMagicDamageMod
                      },
                      //R - Max damage
                      new DamageSpell
                      {
                          Slot = SpellSlot.R,
                          DamageType = DamageType.Physical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 250, 400, 550 }[level] + 1.5 * source.FlatPhysicalDamageMod
                      },
                  });
  
              Spells.Add(
                  "Hecarim", new List<DamageSpell>
                  {
                      //Q
                      new DamageSpell
                      {
                          Slot = SpellSlot.Q,
                          DamageType = DamageType.Physical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 60, 95, 130, 165, 200 }[level] + 0.6 * source.FlatPhysicalDamageMod
                      },
                      //W
                      new DamageSpell
                      {
                          Slot = SpellSlot.W,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 20, 30, 40, 50, 60 }[level] + 0.2 * source.FlatMagicDamageMod
                      },
                      //E
                      new DamageSpell
                      {
                          Slot = SpellSlot.E,
                          DamageType = DamageType.Physical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 40, 75, 110, 145, 180 }[level] + 0.5 * source.FlatPhysicalDamageMod
                      },
                      //R
                      new DamageSpell
                      {
                          Slot = SpellSlot.R,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 150, 250, 350 }[level] + 1 * source.FlatMagicDamageMod
                      },
                  });
  
              Spells.Add(
                  "Heimerdinger", new List<DamageSpell>
                  {
                      //W
                      new DamageSpell
                      {
                          Slot = SpellSlot.W,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 60, 90, 120, 150, 180 }[level] + 0.45 * source.FlatMagicDamageMod
                      },
                      //W
                      new DamageSpell
                      {
                          Slot = SpellSlot.W,
                          Stage = 1,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 135, 180, 225 }[source.Spellbook.GetSpell(SpellSlot.R).Level - 1] +
                                  0.45 * source.FlatMagicDamageMod
                      },
                      //E
                      new DamageSpell
                      {
                          Slot = SpellSlot.E,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 60, 100, 140, 180, 220 }[level] + 0.6 * source.FlatMagicDamageMod
                      },
                      //E
                      new DamageSpell
                      {
                          Slot = SpellSlot.E,
                          Stage = 1,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 150, 200, 250 }[source.Spellbook.GetSpell(SpellSlot.R).Level - 1] +
                                  0.6 * source.FlatMagicDamageMod
                      },
                  });
  
              Spells.Add(
                  "Irelia", new List<DamageSpell>
                  {
                      //Q
                      new DamageSpell
                      {
                          Slot = SpellSlot.Q,
                          DamageType = DamageType.Physical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 20, 50, 80, 110, 140 }[level] +
                                  1 * (source.BaseAttackDamage + source.FlatPhysicalDamageMod)
                      },
                      //W
                      new DamageSpell
                      {
                          Slot = SpellSlot.W,
                          DamageType = DamageType.True,
                          Damage = (source, target, level) => new double[] { 15, 30, 45, 60, 75 }[level]
                      },
                      //E
                      new DamageSpell
                      {
                          Slot = SpellSlot.E,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 80, 120, 160, 200, 240  }[level] + 0.5 * source.FlatMagicDamageMod
                      },
                      //R - per blade
                      new DamageSpell
                      {
                          Slot = SpellSlot.R,
                          DamageType = DamageType.Physical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 80, 120, 160 }[level] + 0.5 * source.FlatMagicDamageMod +
                                  0.6 * source.FlatPhysicalDamageMod
                      },
                  });
  
              Spells.Add(
                  "Janna", new List<DamageSpell>
                  {
                      //Q
                      new DamageSpell
                      {
                          Slot = SpellSlot.Q,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 60, 85, 110, 135, 160 }[level] + 0.35 * source.FlatMagicDamageMod
                      },
                      //W
                      new DamageSpell
                      {
                          Slot = SpellSlot.W,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 60, 115, 170, 225, 280 }[level] + 0.5 * source.FlatMagicDamageMod
                      },
                  });
  
              Spells.Add(
                  "JarvanIV", new List<DamageSpell>
                  {
                      //Q
                      new DamageSpell
                      {
                          Slot = SpellSlot.Q,
                          DamageType = DamageType.Physical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 70, 115, 160, 205, 250 }[level] + 1.2 * source.FlatPhysicalDamageMod
                      },
                      //E
                      new DamageSpell
                      {
                          Slot = SpellSlot.E,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 60, 105, 150, 195, 240 }[level] + 0.8 * source.FlatMagicDamageMod
                      },
                      //R
                      new DamageSpell
                      {
                          Slot = SpellSlot.R,
                          DamageType = DamageType.Physical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 200, 325, 450 }[level] + 1.5 * source.FlatPhysicalDamageMod
                      },
                  });
  
              Spells.Add(
                  "Jax", new List<DamageSpell>
                  {
                      //Q
                      new DamageSpell
                      {
                          Slot = SpellSlot.Q,
                          DamageType = DamageType.Physical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 70, 110, 150, 190, 230 }[level] + 1 * source.FlatPhysicalDamageMod +
                                  0.6 * source.FlatMagicDamageMod
                      },
                      //W
                      new DamageSpell
                      {
                          Slot = SpellSlot.W,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 40, 75, 110, 145, 180 }[level] + 0.6 * source.FlatMagicDamageMod
                      },
                      //E
                      new DamageSpell
                      {
                          Slot = SpellSlot.E,
                          DamageType = DamageType.Physical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 50, 75, 100, 125, 150 }[level] + 0.5 * source.FlatPhysicalDamageMod
                      },
                      //R
                      new DamageSpell
                      {
                          Slot = SpellSlot.R,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 100, 160, 220 }[level] + 0.7 * source.FlatMagicDamageMod
                      },
                  });
  
              Spells.Add(
                  "Jayce", new List<DamageSpell>
                  {
                      //Q 
                      new DamageSpell
                      {
                          Slot = SpellSlot.Q,
                          DamageType = DamageType.Physical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 70, 120, 170, 220, 270, 320 }[level] + 1.2 * source.FlatPhysicalDamageMod
                      },
                      //Q - Melee
                      new DamageSpell
                      {
                          Slot = SpellSlot.Q,
                          Stage = 1,
                          DamageType = DamageType.Physical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 30, 70, 110, 150, 190, 230 }[level] + 1 * source.FlatPhysicalDamageMod
                      },
                      //W - per second
                      new DamageSpell
                      {
                          Slot = SpellSlot.W,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new[] { 25, 40, 55, 70, 85, 100 }[level] + 0.25 * source.FlatMagicDamageMod
                      },
  
                      //E
                      new DamageSpell
                      {
                          Slot = SpellSlot.E,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  (new[] { 8, 10.4, 12.8, 15.2, 17.6, 20 }[level] / 100) * target.MaxHealth +
                                  1 * source.FlatPhysicalDamageMod
                      },
                  });
  
              Spells.Add(
                  "Jinx", new List<DamageSpell>
                  {
                      //Q
                      new DamageSpell
                      {
                          Slot = SpellSlot.Q,
                          DamageType = DamageType.Physical,
                          Damage =
                              (source, target, level) => 0.1 * (source.BaseAttackDamage + source.FlatPhysicalDamageMod)
                      },
                      //W
                      new DamageSpell
                      {
                          Slot = SpellSlot.W,
                          DamageType = DamageType.Physical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 10, 60, 110, 160, 210 }[level] +
                                  1.4 * (source.BaseAttackDamage + source.FlatPhysicalDamageMod)
                      },
                      //E
                      new DamageSpell
                      {
                          Slot = SpellSlot.E,
                          DamageType = DamageType.Magical,
                          Damage =
                              (source, target, level) =>
                                  new double[] { 80, 135, 190, 245, 300 }[level] + 1 * source.FlatMagicDamageMod
                      },
                      //R - Min
                      new DamageSpell
                      {
                          Slot = SpellSlot.R,
                          DamageType = DamageType.Physical,
                          Damage =
  
gt:                             (source, target, level) =>