示例#1
0
        public override void CreateVariables()
        {
            new SkinManager(9);

            damageManager = new DamageManager
            (
                new List<Bases.Damage>()
                {
                    new Bases.Damage
                    (
                        Q, DamageType.Magical, new float[]{ 0, 60 , 105 , 150 , 195 , 240 },

                        new List<Scale>()
                        {
                            new Scale(new float[] { 0, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f }, ScalingTypes.AP)
                        }
                    ),

                    new Bases.Damage
                    (
                        W, DamageType.Magical, new float[]{ 0, 55 , 110 , 165 , 220 , 275 },

                        new List<Scale>()
                        {
                            new Scale(new float[] { 0, 0.7f, 0.7f, 0.7f, 0.7f, 0.7f }, ScalingTypes.AP)
                        }
                    )
                }
            );
        }
示例#2
0
        public override void CreateVariables()
        {
            new SkinManager(9);

            var slot = Player.GetSpellSlotFromName("summonerflash");

            if (slot != SpellSlot.Unknown)
                Flash = new Spell.Skillshot(slot, 425, SkillShotType.Linear);

            W.MinimumHitChance = HitChance.Medium;
            W.AllowedCollisionCount = int.MaxValue;
            W.ConeAngleDegrees = 50;

            R.AllowedCollisionCount = int.MaxValue;
            R.MinimumHitChance = HitChance.Medium;

            damageManager = new DamageManager
            (
                new List<Bases.Damage>()
                {
                    new Bases.Damage
                    (
                        Q, DamageType.Magical, new float[] { 0, 80, 115, 150, 185, 220 },

                        new List<Scale>()
                        {
                            new Scale(new float[] { 0, 0.8f, 0.8f, 0.8f, 0.8f, 0.8f }, ScalingTypes.AP)
                        },
                        true, true
                    ),

                    new Bases.Damage
                    (
                        W, DamageType.Magical, new float[] { 0, 70, 115, 160, 205, 250 },

                        new List<Scale>()
                        {
                            new Scale(new float[] { 0, 0.85f, 0.85f, 0.85f, 0.85f, 0.85f }, ScalingTypes.AP)
                        }
                    ),

                    new Bases.Damage
                    (
                        R, DamageType.Magical, new float[] { 0, 175, 300, 425 },

                        new List<Scale>()
                        {
                            new Scale(new float[] { 0, 0.8f, 0.8f, 0.8f }, ScalingTypes.AP)
                        }
                    )
                }
            );
        }
示例#3
0
        public override void CreateVariables()
        {
            new SkinManager(8);

            Q.MinimumHitChance = HitChance.Medium;
            W.AllowedCollisionCount = int.MaxValue;
            
            damageManager = new DamageManager
            (
                new List<Bases.Damage>()
                {
                    new Bases.Damage
                    (
                        Q, DamageType.Magical, new float[] { 0, 80, 135, 190, 245, 300 },
                        
                        new List<Scale>()
                        {
                            new Scale(new float[] { 0, 0.9f, 0.9f, 0.9f, 0.9f, 0.9f }, ScalingTypes.AP)
                        }
                    ),

                    new Bases.Damage
                    (
                        W, DamageType.Magical, new float[] { 0, 80, 160, 240, 320, 400 },

                        new List<Scale>()
                        {
                            //The true value is 1.1f and not 0.8f, really ? 5 seconds on a tormented soil ?
                            new Scale(new float[] { 0, 0.8f, 0.8f, 0.8f, 0.8f, 0.8f }, ScalingTypes.AP)
                        }
                    ),

                    new Bases.Damage
                    (
                        R, DamageType.Magical, new float[] { 0, 150, 225, 300 },

                        new List<Scale>()
                        {
                            new Scale(new float[] { 0, 0.7f, 0.7f, 0.7f, 0.7f, 0.7f }, ScalingTypes.AP)
                        }
                    )
                }
            );
        }
示例#4
0
        public override void CreateVariables()
        {
            new SkinManager(8);

            R.MinimumHitChance = HitChance.High;
            R.AllowedCollisionCount = int.MaxValue;

            damageManager = new DamageManager
            (
                new List<Bases.Damage>()
                {
                    new Bases.Damage
                    (
                        Q, DamageType.Magical, new float[] { 0, 70, 120, 170, 220, 270 },

                        new List<Scale>()
                        {
                            new Scale(new float[] { 0, 0.6f, 0.6f, 0.6f, 0.6f, 0.6f }, ScalingTypes.AP)
                        },

                        true, true
                    ),

                    new Bases.Damage
                    (
                        W, DamageType.Physical, new float[] { 0, 15, 30, 45, 60, 75 },

                        new List<Scale>()
                        {
                            new Scale(new float[] { 0, 0.1f, 0.1f, 0.1f, 0.1f, 0.1f }, ScalingTypes.AP),
                            new Scale(new float[] { 0, 0.1f, 0.1f, 0.1f, 0.1f, 0.1f }, ScalingTypes.Armor),
                        }
                    ),

                    new Bases.Damage
                    (
                        E, DamageType.Magical, new float[] { 0, 60, 100, 140, 180, 220 },

                        new List<Scale>()
                        {
                            new Scale(new float[] { 0, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f }, ScalingTypes.AP),
                            new Scale(new float[] { 0, 0.3f, 0.3f, 0.3f, 0.3f, 0.3f }, ScalingTypes.Armor),
                        }
                    ),

                    new Bases.Damage
                    (
                        R, DamageType.Magical, new float[] { 0, 200, 300, 400 },

                        new List<Scale>()
                        {
                            new Scale(new float[] { 0, 1, 1, 1, 1, 1 }, ScalingTypes.AP)
                        }
                    )
                }
            );
        }
示例#5
0
        public override void CreateVariables()
        {
            new SkinManager(11);

            damageManager = new DamageManager
            (
                new List<Bases.Damage>()
                {
                    new Bases.Damage
                    (
                        Q, DamageType.Physical, new float[] { 0, 70, 110, 150, 190, 230 },

                        new List<Scale>()
                        {
                            new Scale(new float[] { 0, 0.6f, 0.6f, 0.6f, 0.6f, 0.6f }, ScalingTypes.AD),
                            new Scale(new float[] { 0, 1, 1, 1, 1, 1 }, ScalingTypes.AP)
                        },
                        true, true
                    ),

                    new Bases.Damage
                    (
                        W, DamageType.Magical, new float[] { 0, 40, 75, 110, 145, 180 },

                        new List<Scale>()
                        {
                            new Scale(new float[] { 0, 0.6f, 0.6f, 0.6f, 0.6f, 0.6f }, ScalingTypes.AP)
                        },
                        true, true
                    ),

                    new Bases.Damage
                    (
                        E, DamageType.Physical, new float[] { 0, 50, 75, 100, 125, 150 },

                        new List<Scale>()
                        {
                            new Scale(new float[] { 0, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f }, ScalingTypes.APBonus)
                        }
                    )
                }
            );
        }
示例#6
0
        public override void CreateVariables()
        {
            new SkinManager(8);
            
            R.ConeAngleDegrees = 45;
            R.AllowedCollisionCount = int.MaxValue;
            E.AllowedCollisionCount = int.MaxValue;
            //Q.AllowedCollisionCount = int.MaxValue;

            var slot = Player.GetSpellSlotFromName("summonerflash");

            if (slot != SpellSlot.Unknown)
                flash = new Spell.Skillshot(slot, 425, SkillShotType.Linear);

            damageManager = new DamageManager
            (
                new List<Bases.Damage>()
                {
                    new Bases.Damage
                    (
                        Q, DamageType.Physical, new float[] { 0, 10, 30, 50, 70, 90 },

                        new List<Scale>()
                        {
                            new Scale(new float[] { 0, 0.4f, 0.45f, 0.5f, 0.55f, 0.6f }, ScalingTypes.AD)
                        }
                    ),

                    new Bases.Damage
                    (
                        W, DamageType.Physical, new float[] { 0, 50, 80, 110, 140, 170 },

                        new List<Scale>()
                        {
                            new Scale(new float[] { 0, 1, 1, 1, 1, 1 }, ScalingTypes.ADBonus)
                        }
                    ),

                    new Bases.Damage
                    (
                        R, DamageType.Physical, new float[] { 0, 80, 120, 160 },

                        new List<Scale>()
                        {
                            new Scale(new float[] { 0, 0.6f, 0.6f, 0.6f }, ScalingTypes.ADBonus)
                        }
                    )
                }
            );
        }
示例#7
0
        public override void CreateVariables()
        {
            new SkinManager(8);

            damageManager = new DamageManager
            (
                new List<Bases.Damage>()
                {
                    new Bases.Damage
                    (
                        Q, DamageType.Physical, new float[] { 0, 30, 55, 80, 105, 130 },

                        new List<Scale>()
                        {
                            new Scale(new float[] { 0, 1.4f, 1.4f, 1.4f, 1.4f, 1.4f }, ScalingTypes.AD)
                        },
                        true, true, true
                    ),

                    new Bases.Damage
                    (
                        E, DamageType.Magical, new float[] { 0, 15, 18.8f, 22.5f, 26.3f, 30 },

                        new List<Scale>()
                        {
                            new Scale(new float[] { 0, 0.345f, 0.353f, 0.36f, 0.368f, 0.375f }, ScalingTypes.AD)
                        }
                    ),

                    new Bases.Damage
                    (
                        R, DamageType.Physical, new float[] { 0, 175, 350, 525 },

                        new List<Scale>()
                        {
                            new Scale(new float[] { 0, 0.286f, 0.333f, 0.4f }, ScalingTypes.TargetLostLife)
                        },
                        true, true
                    )
                }
            );
        }
示例#8
0
        public override void CreateVariables()
        {
            new SkinManager(9);

            damageManager = new DamageManager
            (
                new List<Bases.Damage>()
                {
                    new Bases.Damage
                    (
                        Q, DamageType.Physical, new float[] { 0, 25, 60, 95, 130, 165 },
                        
                        new List<Scale>()
                        {
                            new Scale(new float[] { 0, 1, 1, 1, 1, 1 }, ScalingTypes.AD)
                        },

                        true, true
                    ),
                    
                    new Bases.Damage
                    (
                        E, DamageType.True, new float[] { 0, 10, 15, 20, 25, 30 },

                        new List<Scale>()
                        {
                            new Scale(new float[] { 0, 0.1f, 0.125f, 0.15f, 0.175f, 0.2f }, ScalingTypes.AD)
                        }
                    )
                }
            );
        }
示例#9
0
        public override void CreateVariables()
        {
            new SkinManager(6);

            QSpeed = Player.Spellbook.GetSpell(SpellSlot.Q).SData.MissileSpeed;

            R.AllowedCollisionCount = int.MaxValue;

            damageManager = new DamageManager
            (
                new List<Bases.Damage>()
                {
                    new Bases.Damage
                    (
                        Q, DamageType.Physical, new float[] { 0, 20, 50, 80, 110, 140 },

                        new List<Scale>()
                        {
                            new Scale(new float[] { 0, 1, 1, 1, 1, 1 }, ScalingTypes.AD)
                        },
                        true, true, true
                    ),

                    new Bases.Damage
                    (
                        W, DamageType.True, new float[] { 0, 15, 30, 45, 60, 75 }
                    ),

                    new Bases.Damage
                    (
                        E, DamageType.Magical, new float[] { 0, 80, 120, 160, 200, 240 },

                        new List<Scale>()
                        {
                            new Scale(new float[] { 0, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f }, ScalingTypes.AP)
                        },
                        true, true
                    ),

                    new Bases.Damage
                    (
                        R, DamageType.Physical, new float[] { 0, 80, 120, 160 },

                        new List<Scale>()
                        {
                            new Scale(new float[] { 0, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f }, ScalingTypes.AP),
                            new Scale(new float[] { 0, 0.6f, 0.6f, 0.6f, 0.6f, 0.6f }, ScalingTypes.ADBonus)
                        }
                    )
                }
            );
        }
示例#10
0
        public override void CreateVariables()
        {
            new SkinManager(8);

            Q.MinimumHitChance = HitChance.Medium;

            damageManager = new DamageManager
            (
                new List<Bases.Damage>()
                {
                    new Bases.Damage
                    (
                        Q, DamageType.Magical, new float[] { 0, 75, 115, 155, 195, 235 },

                        new List<Scale>()
                        {
                            new Scale(new float[] { 0, 0.75f, 0.75f, 0.75f, 0.75f, 0.75f }, ScalingTypes.AP)
                        }
                    ),

                    new Bases.Damage
                    (
                        W, DamageType.Magical, new float[] { 0, 65, 95, 125, 15, 185 },

                        new List<Scale>()
                        {
                            new Scale(new float[] { 0, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f }, ScalingTypes.AD),
                            new Scale(new float[] { 0, 0.55f, 0.55f, 0.55f, 0.55f, 0.55f }, ScalingTypes.AP)
                        }
                    ),

                    new Bases.Damage
                    (
                        E, DamageType.Magical, new float[] { 0, 85, 125, 165, 205, 245 },

                        new List<Scale>()
                        {
                            new Scale(new float[] { 0, 0.6f, 0.6f, 0.6f, 0.6f, 0.6f }, ScalingTypes.AP)
                        }
                    ),

                    new Bases.Damage
                    (
                        R, DamageType.Magical, new float[] { 0, 80, 145, 210 },

                        new List<Scale>()
                        {
                            new Scale(new float[] { 0, 0.4f, 0.4f, 0.4f, 0.4f, 0.4f }, ScalingTypes.AP)
                        }
                    )
                }
            );
        }
示例#11
0
        public override void CreateVariables()
        {
            new SkinManager(2);

            Q.MinimumHitChance = HitChance.Medium;
            E.MinimumHitChance = HitChance.High;
            R.MinimumHitChance = HitChance.High;

            Q.AllowedCollisionCount = int.MaxValue;
            R.AllowedCollisionCount = int.MaxValue;

            damageManager = new DamageManager
            (
                new List<Bases.Damage>()
                {
                    new Bases.Damage
                    (
                        Q, DamageType.Magical, new float[] { 0, 65, 85, 105, 125, 145 },

                        new List<Scale>()
                        {
                            new Scale(new float[] { 0, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f }, ScalingTypes.AP)
                        }
                    ),

                    new Bases.Damage
                    (
                        W, DamageType.Magical, new float[] { 0, 0, 0, 0, 0, 0 },
                        
                        new List<Scale>()
                        {
                            new Scale(new float[] { 0, 0.6f, 0.6f, 0.6f, 0.6f, 0.6f }, ScalingTypes.AP)
                        }
                    ),

                    new Bases.Damage
                    (
                        E, DamageType.Magical, new float[] { 0, 60, 90, 120, 150, 180 },

                        new List<Scale>()
                        {
                            new Scale(new float[] { 0, 0.4f, 0.4f, 0.4f, 0.4f, 0.4f }, ScalingTypes.AP)
                        }
                    ),

                    new Bases.Damage
                    (
                        R, DamageType.Magical, new float[] { 0, 150, 225, 300 },

                        new List<Scale>()
                        {
                            new Scale(new float[] { 0, 0.6f, 0.6f, 0.6f }, ScalingTypes.AP)
                        }
                    )
                }
            );
        }