Exemplo n.º 1
0
        public TemplarAssassin(Unit9 owner, MultiSleeper abilitySleeper, Sleeper orbwalkSleeper, ControllableUnitMenu menu)
            : base(owner, abilitySleeper, orbwalkSleeper, menu)
        {
            this.ComboAbilities = new Dictionary <AbilityId, Func <ActiveAbility, UsableAbility> >
            {
                { AbilityId.templar_assassin_refraction, x => this.refraction = new BuffAbility(x) },
                { AbilityId.templar_assassin_meld, x => this.meld = new NukeAbility(x) },
                { AbilityId.templar_assassin_psionic_trap, x => this.trap = new Abilities.PsionicTrap(x) },

                { AbilityId.item_blink, x => this.blink = new BlinkAbility(x) },
                { AbilityId.item_swift_blink, x => this.blink = new BlinkAbility(x) },
                { AbilityId.item_arcane_blink, x => this.blink = new BlinkAbility(x) },
                { AbilityId.item_overwhelming_blink, x => this.blink = new BlinkAbility(x) },
                { AbilityId.item_orchid, x => this.orchid = new DisableAbility(x) },
                { AbilityId.item_bloodthorn, x => this.bloodthorn = new Bloodthorn(x) },
                { AbilityId.item_nullifier, x => this.nullifier = new Nullifier(x) },
                { AbilityId.item_force_staff, x => this.force = new ForceStaff(x) },
                { AbilityId.item_hurricane_pike, x => this.pike = new HurricanePike(x) },
                { AbilityId.item_sheepstick, x => this.hex = new DisableAbility(x) },
                { AbilityId.item_solar_crest, x => this.solar = new DebuffAbility(x) },
                { AbilityId.item_medallion_of_courage, x => this.medallion = new DebuffAbility(x) },
            };

            this.MoveComboAbilities.Add(AbilityId.templar_assassin_refraction, _ => this.refraction);
        }
Exemplo n.º 2
0
        public Slark(Unit9 owner, MultiSleeper abilitySleeper, Sleeper orbwalkSleeper, ControllableUnitMenu menu)
            : base(owner, abilitySleeper, orbwalkSleeper, menu)
        {
            this.ComboAbilities = new Dictionary <AbilityId, Func <ActiveAbility, UsableAbility> >
            {
                { AbilityId.slark_dark_pact, x => this.pact = new NukeAbility(x) },
                { AbilityId.slark_pounce, x => this.pounce = new Pounce(x) },
                { AbilityId.slark_shadow_dance, x => this.dance = new ShadowDance(x) },

                { AbilityId.item_phase_boots, x => this.phase = new SpeedBuffAbility(x) },
                { AbilityId.item_abyssal_blade, x => this.abyssal = new DisableAbility(x) },
                { AbilityId.item_sheepstick, x => this.hex = new DisableAbility(x) },
                { AbilityId.item_orchid, x => this.orchid = new DisableAbility(x) },
                { AbilityId.item_bloodthorn, x => this.bloodthorn = new Bloodthorn(x) },
                { AbilityId.item_nullifier, x => this.nullifier = new Nullifier(x) },
                { AbilityId.item_blink, x => this.blink = new BlinkAbility(x) },
                { AbilityId.item_swift_blink, x => this.blink = new BlinkAbility(x) },
                { AbilityId.item_arcane_blink, x => this.blink = new BlinkAbility(x) },
                { AbilityId.item_overwhelming_blink, x => this.blink = new BlinkAbility(x) },
                { AbilityId.item_solar_crest, x => this.solar = new DebuffAbility(x) },
                { AbilityId.item_medallion_of_courage, x => this.medallion = new DebuffAbility(x) },
                { AbilityId.item_diffusal_blade, x => this.diffusal = new DebuffAbility(x) },
                { AbilityId.item_silver_edge, x => this.silver = new BuffAbility(x) },
                { AbilityId.item_invis_sword, x => this.shadow = new BuffAbility(x) },
            };

            this.MoveComboAbilities.Add(AbilityId.slark_pounce, x => this.pounceBlink = new ForceStaff(x));
        }
Exemplo n.º 3
0
        public SkywrathMage(Unit9 owner, MultiSleeper abilitySleeper, Sleeper orbwalkSleeper, ControllableUnitMenu menu)
            : base(owner, abilitySleeper, orbwalkSleeper, menu)
        {
            this.ComboAbilities = new Dictionary <AbilityId, Func <ActiveAbility, UsableAbility> >
            {
                { AbilityId.skywrath_mage_arcane_bolt, x => this.bolt = new NukeAbility(x) },
                { AbilityId.skywrath_mage_ancient_seal, x => this.seal = new DebuffAbility(x) },
                { AbilityId.skywrath_mage_concussive_shot, x => this.concussive = new DebuffAbility(x) },
                { AbilityId.skywrath_mage_mystic_flare, x => this.flare = new MysticFlare(x) },

                { AbilityId.item_rod_of_atos, x => this.atos = new DisableAbility(x) },
                { AbilityId.item_gungir, x => this.gungir = new DisableAbility(x) },
                { AbilityId.item_veil_of_discord, x => this.veil = new DebuffAbility(x) },
                { AbilityId.item_force_staff, x => this.force = new ForceStaff(x) },
                { AbilityId.item_blink, x => this.blink = new BlinkAbility(x) },
                { AbilityId.item_swift_blink, x => this.blink = new BlinkAbility(x) },
                { AbilityId.item_arcane_blink, x => this.blink = new BlinkAbility(x) },
                { AbilityId.item_overwhelming_blink, x => this.blink = new BlinkAbility(x) },
                { AbilityId.item_sheepstick, x => this.hex = new HexSkywrath(x) },
                { AbilityId.item_ethereal_blade, x => this.ethereal = new EtherealBlade(x) },
                { AbilityId.item_nullifier, x => this.nullifier = new Nullifier(x) },
                { AbilityId.item_dagon_5, x => this.dagon = new NukeAbility(x) },
            };

            this.MoveComboAbilities.Add(AbilityId.skywrath_mage_ancient_seal, _ => this.seal);
            this.MoveComboAbilities.Add(AbilityId.skywrath_mage_concussive_shot, _ => this.concussive);
        }
Exemplo n.º 4
0
        public EarthSpirit(Unit9 owner, MultiSleeper abilitySleeper, Sleeper orbwalkSleeper, ControllableUnitMenu menu)
            : base(owner, abilitySleeper, orbwalkSleeper, menu)
        {
            this.ComboAbilities = new Dictionary <AbilityId, Func <ActiveAbility, UsableAbility> >
            {
                { AbilityId.earth_spirit_boulder_smash, x => this.smash = new BoulderSmash(x) },
                { AbilityId.earth_spirit_rolling_boulder, x => this.rolling = new RollingBoulder(x) },
                { AbilityId.earth_spirit_geomagnetic_grip, x => this.grip = new GeomagneticGrip(x) },
                { AbilityId.earth_spirit_magnetize, x => this.mag = new AoeAbility(x) },
                { AbilityId.earth_spirit_stone_caller, x => this.stone = new StoneRemnant(x) },
                //{ AbilityId.earth_spirit_petrify, x => this.petrify = new NukeAbility(x) },

                { AbilityId.item_blink, x => this.blink = new BlinkAbility(x) },
                { AbilityId.item_swift_blink, x => this.blink = new BlinkAbility(x) },
                { AbilityId.item_arcane_blink, x => this.blink = new BlinkAbility(x) },
                { AbilityId.item_overwhelming_blink, x => this.blink = new BlinkAbility(x) },
                { AbilityId.item_force_staff, x => this.force = new ForceStaff(x) },
                { AbilityId.item_spirit_vessel, x => this.vessel = new DebuffAbility(x) },
                { AbilityId.item_urn_of_shadows, x => this.urn = new DebuffAbility(x) },
                { AbilityId.item_veil_of_discord, x => this.veil = new DebuffAbility(x) },
                { AbilityId.item_blade_mail, x => this.bladeMail = new ShieldAbility(x) },
                { AbilityId.item_heavens_halberd, x => this.halberd = new DisableAbility(x) },
                { AbilityId.item_shivas_guard, x => this.shiva = new DebuffAbility(x) },
            };

            this.MoveComboAbilities.Add(AbilityId.earth_spirit_rolling_boulder, x => this.rollingBlink = new RollingBoulderBlink(x));
            this.MoveComboAbilities.Add(AbilityId.earth_spirit_stone_caller, x => this.stoneBlink      = new StoneRemnantBlink(x));
            this.MoveComboAbilities.Add(AbilityId.earth_spirit_boulder_smash, _ => this.smash);
        }
Exemplo n.º 5
0
        public DarkWillow(Unit9 owner, MultiSleeper abilitySleeper, Sleeper orbwalkSleeper, ControllableUnitMenu menu)
            : base(owner, abilitySleeper, orbwalkSleeper, menu)
        {
            this.ComboAbilities = new Dictionary <AbilityId, Func <ActiveAbility, UsableAbility> >
            {
                { AbilityId.dark_willow_bramble_maze, x => this.maze = new BrambleMaze(x) },
                { AbilityId.dark_willow_shadow_realm, x => this.realm = new ShadowRealm(x) },
                { AbilityId.dark_willow_cursed_crown, x => this.crown = new DebuffAbility(x) },
                { AbilityId.dark_willow_bedlam, x => this.bedlam = new NukeAbility(x) },
                { AbilityId.dark_willow_terrorize, x => this.terror = new DisableAbility(x) },

                { AbilityId.item_blink, x => this.blink = new BlinkAbility(x) },
                { AbilityId.item_cyclone, x => this.eul = new EulsScepterOfDivinityDarkWillow(x) },
                { AbilityId.item_veil_of_discord, x => this.veil = new DebuffAbility(x) },
                { AbilityId.item_force_staff, x => this.force = new ForceStaff(x) },
                { AbilityId.item_spirit_vessel, x => this.vessel = new DebuffAbility(x) },
                { AbilityId.item_urn_of_shadows, x => this.urn = new DebuffAbility(x) },
                { AbilityId.item_sheepstick, x => this.hex = new DisableAbility(x) },
                { AbilityId.item_nullifier, x => this.nullifier = new Nullifier(x) },
                { AbilityId.item_orchid, x => this.orchid = new DisableAbility(x) },
                { AbilityId.item_bloodthorn, x => this.bloodthorn = new Bloodthorn(x) },
                { AbilityId.item_rod_of_atos, x => this.atos = new DisableAbility(x) },
            };

            this.MoveComboAbilities.Add(AbilityId.dark_willow_shadow_realm, x => this.moveRealm = new ShieldAbility(x));
            this.MoveComboAbilities.Add(AbilityId.dark_willow_cursed_crown, x => this.moveCrown = new DisableAbility(x));
        }
Exemplo n.º 6
0
        public Lina(Unit9 owner, MultiSleeper abilitySleeper, Sleeper orbwalkSleeper, ControllableUnitMenu menu)
            : base(owner, abilitySleeper, orbwalkSleeper, menu)
        {
            this.ComboAbilities = new Dictionary <AbilityId, Func <ActiveAbility, UsableAbility> >
            {
                { AbilityId.lina_dragon_slave, x => this.dragon = new NukeAbility(x) },
                { AbilityId.lina_light_strike_array, x => this.array = new DisableAbility(x) },
                { AbilityId.lina_laguna_blade, x => this.laguna = new NukeAbility(x) },

                { AbilityId.item_phase_boots, x => this.phase = new SpeedBuffAbility(x) },
                { AbilityId.item_force_staff, x => this.force = new ForceStaff(x) },
                { AbilityId.item_hurricane_pike, x => this.pike = new HurricanePike(x) },
                { AbilityId.item_ethereal_blade, x => this.ethereal = new EtherealBlade(x) },
                { AbilityId.item_blink, x => this.blink = new BlinkAbility(x) },
                { AbilityId.item_swift_blink, x => this.blink = new BlinkAbility(x) },
                { AbilityId.item_arcane_blink, x => this.blink = new BlinkAbility(x) },
                { AbilityId.item_overwhelming_blink, x => this.blink = new BlinkAbility(x) },
                { AbilityId.item_cyclone, x => this.euls = new EulsScepterOfDivinity(x) },
                { AbilityId.item_wind_waker, x => this.euls = new EulsScepterOfDivinity(x) },
                { AbilityId.item_sheepstick, x => this.hex = new DisableAbility(x) },
                { AbilityId.item_orchid, x => this.orchid = new DisableAbility(x) },
                { AbilityId.item_bloodthorn, x => this.bloodthorn = new Bloodthorn(x) },
                { AbilityId.item_veil_of_discord, x => this.veil = new DebuffAbility(x) },
                { AbilityId.item_rod_of_atos, x => this.atos = new DisableAbility(x) },
                { AbilityId.item_gungir, x => this.gungir = new DisableAbility(x) },
            };

            this.MoveComboAbilities.Add(AbilityId.lina_light_strike_array, _ => this.array);
        }
Exemplo n.º 7
0
        public Slardar(Unit9 owner, MultiSleeper abilitySleeper, Sleeper orbwalkSleeper, ControllableUnitMenu menu)
            : base(owner, abilitySleeper, orbwalkSleeper, menu)
        {
            this.ComboAbilities = new Dictionary <AbilityId, Func <ActiveAbility, UsableAbility> >
            {
                { AbilityId.slardar_sprint, x => this.sprint = new BuffAbility(x) },
                { AbilityId.slardar_slithereen_crush, x => this.crush = new DisableAbility(x) },
                { AbilityId.slardar_amplify_damage, x => this.amplify = new DebuffAbility(x) },

                { AbilityId.item_phase_boots, x => this.phase = new SpeedBuffAbility(x) },
                { AbilityId.item_blink, x => this.blink = new BlinkDaggerAOE(x) },
                { AbilityId.item_force_staff, x => this.force = new ForceStaff(x) },
                { AbilityId.item_blade_mail, x => this.bladeMail = new ShieldAbility(x) },
                { AbilityId.item_black_king_bar, x => this.bkb = new ShieldAbility(x) },
                { AbilityId.item_armlet, x => this.armlet = new BuffAbility(x) },
                { AbilityId.item_solar_crest, x => this.solar = new DebuffAbility(x) },
                { AbilityId.item_medallion_of_courage, x => this.medallion = new DebuffAbility(x) },
                { AbilityId.item_heavens_halberd, x => this.halberd = new DisableAbility(x) },
                { AbilityId.item_orchid, x => this.orchid = new DisableAbility(x) },
                { AbilityId.item_bloodthorn, x => this.bloodthorn = new Bloodthorn(x) },
                { AbilityId.item_nullifier, x => this.nullifier = new Nullifier(x) },
            };

            this.MoveComboAbilities.Add(AbilityId.slardar_slithereen_crush, _ => this.crush);
            this.MoveComboAbilities.Add(AbilityId.slardar_sprint, _ => this.sprint);
        }
Exemplo n.º 8
0
        public bool UseDoubleBlinkCombo(ForceStaff force, BlinkAbility blink, float minDistance = 0)
        {
            if (!this.CanBeCasted(force, false) || !this.CanBeCasted(blink, false))
            {
                return(false);
            }

            var target = this.TargetManager.Target;
            var owner  = force.Ability.Owner;

            if (owner.Distance(target) < minDistance || owner.Distance(target) < blink.Ability.Range)
            {
                return(false);
            }

            var range = blink.Ability.Range + force.Ability.Range;

            if (owner.Distance(target) > range)
            {
                return(false);
            }

            if (owner.GetAngle(target.Position) > 0.5f)
            {
                owner.BaseUnit.Move(target.Position);
                this.comboSleeper.Sleep(0.1f);
                return(false);
            }

            force.Ability.UseAbility(owner);
            this.comboSleeper.Sleep(force.Ability.GetCastDelay() + 0.3f);
            return(false);
        }
Exemplo n.º 9
0
        public bool UseForceStaffAway(ForceStaff force, int range)
        {
            if (!this.CanBeCasted(force))
            {
                return(false);
            }

            var target = this.TargetManager.Target;

            if (target.IsRanged || target.IsStunned || target.IsRooted || target.IsHexed || target.IsDisarmed)
            {
                return(false);
            }

            var owner = force.Ability.Owner;

            if (target.Distance(owner) > range)
            {
                return(false);
            }

            var mouse = Game.MousePosition;

            if (owner.GetAngle(mouse) > 1f)
            {
                owner.BaseUnit.Move(mouse);
                UpdateManager.BeginInvoke(() => force.Ability.UseAbility(owner), 200);
                return(true);
            }

            return(false);
        }
Exemplo n.º 10
0
        // Token: 0x06000A13 RID: 2579 RVA: 0x0002BF58 File Offset: 0x0002A158
        public bool UseForceStaffAway(ForceStaff force, int range)
        {
            if (!this.CanBeCasted(force, true, true, true, true))
            {
                return(false);
            }
            Unit9 target = this.TargetManager.Target;

            if (target.IsRanged || target.IsStunned || target.IsRooted || target.IsHexed || target.IsDisarmed)
            {
                return(false);
            }
            Unit9 owner = force.Ability.Owner;

            if (target.Distance(owner) > (float)range)
            {
                return(false);
            }
            Vector3 mousePosition = Game.MousePosition;

            if (owner.GetAngle(mousePosition, false) > 1f)
            {
                owner.BaseUnit.Move(mousePosition);
                UpdateManager.BeginInvoke(delegate
                {
                    force.Ability.UseAbility(owner, false, false);
                }, 200);
                return(true);
            }
            return(false);
        }
Exemplo n.º 11
0
        public Earthshaker(Unit9 owner, MultiSleeper abilitySleeper, Sleeper orbwalkSleeper, ControllableUnitMenu menu)
            : base(owner, abilitySleeper, orbwalkSleeper, menu)
        {
            this.ComboAbilities = new Dictionary <AbilityId, Func <ActiveAbility, UsableAbility> >
            {
                { AbilityId.earthshaker_fissure, x => this.fissure = new Fissure(x) },
                { AbilityId.earthshaker_enchant_totem, x => this.totem = new EnchantTotem(x) },
                { AbilityId.earthshaker_echo_slam, x => this.echo = new EchoSlam(x) },

                { AbilityId.item_blink, x => this.blink = new BlinkDaggerShaker(x) },
                { AbilityId.item_force_staff, x => this.force = new ForceStaff(x) },
            };
        }
Exemplo n.º 12
0
        public ElderTitan(Unit9 owner, MultiSleeper abilitySleeper, Sleeper orbwalkSleeper, ControllableUnitMenu menu)
            : base(owner, abilitySleeper, orbwalkSleeper, menu)
        {
            this.ComboAbilities = new Dictionary <AbilityId, Func <ActiveAbility, UsableAbility> >
            {
                { AbilityId.elder_titan_echo_stomp, x => this.stomp = new DisableAbility(x) },
                { AbilityId.elder_titan_ancestral_spirit, x => this.spirit = new NukeAbility(x) },
                { AbilityId.elder_titan_earth_splitter, x => this.splitter = new NukeAbility(x) },

                { AbilityId.item_force_staff, x => this.force = new ForceStaff(x) },
                { AbilityId.item_cyclone, x => this.euls = new EulsScepterOfDivinity(x) },
                { AbilityId.item_meteor_hammer, x => this.hammer = new DisableAbility(x) },
                { AbilityId.item_rod_of_atos, x => this.atos = new DisableAbility(x) },
            };
        }
Exemplo n.º 13
0
        public Tidehunter(Unit9 owner, MultiSleeper abilitySleeper, Sleeper orbwalkSleeper, ControllableUnitMenu menu)
            : base(owner, abilitySleeper, orbwalkSleeper, menu)
        {
            this.ComboAbilities = new Dictionary <AbilityId, Func <ActiveAbility, UsableAbility> >
            {
                { AbilityId.tidehunter_gush, x => this.gush = new NukeAbility(x) },
                { AbilityId.tidehunter_anchor_smash, x => this.smash = new NukeAbility(x) },
                { AbilityId.tidehunter_ravage, x => this.ravage = new Ravage(x) },

                { AbilityId.item_blink, x => this.blink = new BlinkDaggerAOE(x) },
                { AbilityId.item_force_staff, x => this.force = new ForceStaff(x) },
                { AbilityId.item_blade_mail, x => this.bladeMail = new ShieldAbility(x) },
                { AbilityId.item_shivas_guard, x => this.shiva = new DebuffAbility(x) },
                { AbilityId.item_refresher, x => this.refresher = new UntargetableAbility(x) },
                { AbilityId.item_refresher_shard, x => this.refresherShard = new UntargetableAbility(x) },
            };
        }
Exemplo n.º 14
0
        public ShadowShaman(Unit9 owner, MultiSleeper abilitySleeper, Sleeper orbwalkSleeper, ControllableUnitMenu menu)
            : base(owner, abilitySleeper, orbwalkSleeper, menu)
        {
            this.ComboAbilities = new Dictionary <AbilityId, Func <ActiveAbility, UsableAbility> >
            {
                { AbilityId.shadow_shaman_ether_shock, x => this.shock = new NukeAbility(x) },
                { AbilityId.shadow_shaman_voodoo, x => this.hex = new DisableAbility(x) },
                { AbilityId.shadow_shaman_shackles, x => this.shackles = new DisableAbility(x) },
                { AbilityId.shadow_shaman_mass_serpent_ward, x => this.wards = new Wards(x) },

                { AbilityId.item_force_staff, x => this.force = new ForceStaff(x) },
                { AbilityId.item_blink, x => this.blink = new BlinkAbility(x) },
                { AbilityId.item_cyclone, x => this.euls = new EulsScepterOfDivinity(x) },
            };

            this.MoveComboAbilities.Add(AbilityId.shadow_shaman_voodoo, _ => this.hex);
        }
Exemplo n.º 15
0
        public Warlock(Unit9 owner, MultiSleeper abilitySleeper, Sleeper orbwalkSleeper, ControllableUnitMenu menu)
            : base(owner, abilitySleeper, orbwalkSleeper, menu)
        {
            this.ComboAbilities = new Dictionary <AbilityId, Func <ActiveAbility, UsableAbility> >
            {
                { AbilityId.warlock_fatal_bonds, x => this.bonds = new FatalBonds(x) },
                { AbilityId.warlock_shadow_word, x => this.word = new DebuffAbility(x) },
                { AbilityId.warlock_upheaval, x => this.upheaval = new DebuffAbility(x) },
                { AbilityId.warlock_rain_of_chaos, x => this.chaos = new ChaoticOffering(x) },

                { AbilityId.item_refresher, x => this.refresher = new UntargetableAbility(x) },
                { AbilityId.item_refresher_shard, x => this.refresherShard = new UntargetableAbility(x) },
                { AbilityId.item_force_staff, x => this.force = new ForceStaff(x) },
                { AbilityId.item_sheepstick, x => this.hex = new DisableAbility(x) },
                { AbilityId.item_rod_of_atos, x => this.atos = new DisableAbility(x) },
            };
        }
Exemplo n.º 16
0
        public SandKing(Unit9 owner, MultiSleeper abilitySleeper, Sleeper orbwalkSleeper, ControllableUnitMenu menu)
            : base(owner, abilitySleeper, orbwalkSleeper, menu)
        {
            this.ComboAbilities = new Dictionary <AbilityId, Func <ActiveAbility, UsableAbility> >
            {
                { AbilityId.sandking_burrowstrike, x => this.burrow = new Burrowstrike(x) },
                { AbilityId.sandking_sand_storm, x => this.sandstorm = new UntargetableAbility(x) },
                { AbilityId.sandking_epicenter, x => this.epicenter = new Epicenter(x) },

                { AbilityId.item_veil_of_discord, x => this.veil = new DebuffAbility(x) },
                { AbilityId.item_blink, x => this.blink = new BlinkAbility(x) },
                { AbilityId.item_force_staff, x => this.force = new ForceStaff(x) },
                { AbilityId.item_shivas_guard, x => this.shiva = new DebuffAbility(x) },
                { AbilityId.item_sheepstick, x => this.hex = new DisableAbility(x) },
            };

            this.MoveComboAbilities.Add(AbilityId.sandking_burrowstrike, x => this.burrowBlink = new BlinkAbility(x));
        }
Exemplo n.º 17
0
        public CrystalMaiden(Unit9 owner, MultiSleeper abilitySleeper, Sleeper orbwalkSleeper, ControllableUnitMenu menu)
            : base(owner, abilitySleeper, orbwalkSleeper, menu)
        {
            this.ComboAbilities = new Dictionary <AbilityId, Func <ActiveAbility, UsableAbility> >
            {
                { AbilityId.crystal_maiden_crystal_nova, x => this.nova = new NukeAbility(x) },
                { AbilityId.crystal_maiden_frostbite, x => this.frostbite = new DisableAbility(x) },
                { AbilityId.crystal_maiden_freezing_field, x => this.field = new FreezingField(x) },

                { AbilityId.item_force_staff, x => this.force = new ForceStaff(x) },
                { AbilityId.item_blink, x => this.blink = new BlinkDaggerCM(x) },
                { AbilityId.item_glimmer_cape, x => this.glimmer = new ShieldAbility(x) },
                { AbilityId.item_black_king_bar, x => this.bkb = new ShieldAbility(x) },
                { AbilityId.item_rod_of_atos, x => this.atos = new DisableAbility(x) },
            };

            this.MoveComboAbilities.Add(AbilityId.crystal_maiden_frostbite, _ => this.frostbite);
        }
Exemplo n.º 18
0
        public Mirana(Unit9 owner, MultiSleeper abilitySleeper, Sleeper orbwalkSleeper, ControllableUnitMenu menu)
            : base(owner, abilitySleeper, orbwalkSleeper, menu)
        {
            this.ComboAbilities = new Dictionary <AbilityId, Func <ActiveAbility, UsableAbility> >
            {
                { AbilityId.mirana_starfall, x => this.starstorm = new NukeAbility(x) },
                { AbilityId.mirana_arrow, x => this.arrow = new DisableAbility(x) },
                { AbilityId.mirana_leap, x => this.leap = new ForceStaff(x) },

                { AbilityId.item_phase_boots, x => this.phase = new SpeedBuffAbility(x) },
                { AbilityId.item_diffusal_blade, x => this.diffusal = new DebuffAbility(x) },
                { AbilityId.item_manta, x => this.manta = new BuffAbility(x) },
                { AbilityId.item_blink, x => this.blink = new BlinkAbility(x) },
                { AbilityId.item_rod_of_atos, x => this.atos = new DisableAbility(x) },
            };

            this.MoveComboAbilities.Add(AbilityId.mirana_leap, _ => this.leap);
        }
Exemplo n.º 19
0
        public DarkSeer(Unit9 owner, MultiSleeper abilitySleeper, Sleeper orbwalkSleeper, ControllableUnitMenu menu)
            : base(owner, abilitySleeper, orbwalkSleeper, menu)
        {
            this.ComboAbilities = new Dictionary <AbilityId, Func <ActiveAbility, UsableAbility> >
            {
                {
                    AbilityId.dark_seer_vacuum, x =>
                    {
                        this.vacuum = new Vacuum(x);
                        if (this.wall != null)
                        {
                            this.wall.Vacuum = this.vacuum;
                        }

                        return(this.vacuum);
                    }
                },
                { AbilityId.dark_seer_ion_shell, x => this.shell = new IonShell(x) },
                { AbilityId.dark_seer_surge, x => this.surge = new BuffAbility(x) },
                {
                    AbilityId.dark_seer_wall_of_replica, x =>
                    {
                        this.wall = new WallOfReplica(x);
                        if (this.vacuum != null)
                        {
                            this.wall.Vacuum = this.vacuum;
                        }

                        return(this.wall);
                    }
                },

                { AbilityId.item_blink, x => this.blink = new BlinkAbility(x) },
                { AbilityId.item_swift_blink, x => this.blink = new BlinkAbility(x) },
                { AbilityId.item_arcane_blink, x => this.blink = new BlinkAbility(x) },
                { AbilityId.item_overwhelming_blink, x => this.blink = new BlinkAbility(x) },
                { AbilityId.item_shivas_guard, x => this.shiva = new DebuffAbility(x) },
                { AbilityId.item_blade_mail, x => this.bladeMail = new ShieldAbility(x) },
                { AbilityId.item_force_staff, x => this.force = new ForceStaff(x) },
            };

            this.MoveComboAbilities.Add(AbilityId.dark_seer_surge, _ => this.surge);
        }
Exemplo n.º 20
0
        public Gyrocopter(Unit9 owner, MultiSleeper abilitySleeper, Sleeper orbwalkSleeper, ControllableUnitMenu menu)
            : base(owner, abilitySleeper, orbwalkSleeper, menu)
        {
            this.ComboAbilities = new Dictionary <AbilityId, Func <ActiveAbility, UsableAbility> >
            {
                { AbilityId.gyrocopter_rocket_barrage, x => this.barrage = new NukeAbility(x) },
                { AbilityId.gyrocopter_homing_missile, x => this.missile = new NukeAbility(x) },
                { AbilityId.gyrocopter_flak_cannon, x => this.flak = new FlakCannon(x) },
                { AbilityId.gyrocopter_call_down, x => this.callDown = new NukeAbility(x) },

                { AbilityId.item_phase_boots, x => this.phase = new SpeedBuffAbility(x) },
                { AbilityId.item_hurricane_pike, x => this.pike = new HurricanePike(x) },
                { AbilityId.item_force_staff, x => this.force = new ForceStaff(x) },
                { AbilityId.item_manta, x => this.manta = new BuffAbility(x) },
                { AbilityId.item_mjollnir, x => this.mjollnir = new ShieldAbility(x) },
            };

            this.MoveComboAbilities.Add(AbilityId.gyrocopter_homing_missile, _ => this.missile);
        }
Exemplo n.º 21
0
        public Venomancer(Unit9 owner, MultiSleeper abilitySleeper, Sleeper orbwalkSleeper, ControllableUnitMenu menu)
            : base(owner, abilitySleeper, orbwalkSleeper, menu)
        {
            this.ComboAbilities = new Dictionary <AbilityId, Func <ActiveAbility, UsableAbility> >
            {
                { AbilityId.venomancer_venomous_gale, x => this.gale = new DebuffAbility(x) },
                { AbilityId.venomancer_plague_ward, x => this.ward = new PlagueWardAbility(x) },
                { AbilityId.venomancer_poison_nova, x => this.nova = new PoisonNova(x) },

                { AbilityId.item_veil_of_discord, x => this.veil = new DebuffAbility(x) },
                { AbilityId.item_blink, x => this.blink = new BlinkDaggerAOE(x) },
                { AbilityId.item_shivas_guard, x => this.shiva = new DebuffAbility(x) },
                { AbilityId.item_force_staff, x => this.force = new ForceStaff(x) },
                { AbilityId.item_orchid, x => this.orchid = new DisableAbility(x) },
                { AbilityId.item_bloodthorn, x => this.bloodthorn = new Bloodthorn(x) },
            };

            this.MoveComboAbilities.Add(AbilityId.venomancer_venomous_gale, _ => this.gale);
        }
Exemplo n.º 22
0
        public Disruptor(Unit9 owner, MultiSleeper abilitySleeper, Sleeper orbwalkSleeper, ControllableUnitMenu menu)
            : base(owner, abilitySleeper, orbwalkSleeper, menu)
        {
            this.ComboAbilities = new Dictionary <AbilityId, Func <ActiveAbility, UsableAbility> >
            {
                { AbilityId.disruptor_thunder_strike, x => this.thunder = new NukeAbility(x) },
                { AbilityId.disruptor_glimpse, x => this.glimpse = new TargetableAbility(x) },
                { AbilityId.disruptor_kinetic_field, x => this.field = new KineticField(x) },
                { AbilityId.disruptor_static_storm, x => this.storm = new StaticStorm(x) },

                { AbilityId.item_blink, x => this.blink = new BlinkAbility(x) },
                { AbilityId.item_force_staff, x => this.force = new ForceStaff(x) },
                { AbilityId.item_veil_of_discord, x => this.veil = new DebuffAbility(x) },
            };

            this.MoveComboAbilities.Add(AbilityId.disruptor_kinetic_field, _ => this.field);

            Entity.OnParticleEffectAdded += this.OnParticleEffectAdded;
        }
Exemplo n.º 23
0
        public Razor(Unit9 owner, MultiSleeper abilitySleeper, Sleeper orbwalkSleeper, ControllableUnitMenu menu)
            : base(owner, abilitySleeper, orbwalkSleeper, menu)
        {
            this.ComboAbilities = new Dictionary <AbilityId, Func <ActiveAbility, UsableAbility> >
            {
                { AbilityId.razor_plasma_field, x => this.plasma = new NukeAbility(x) },
                { AbilityId.razor_static_link, x => this.link = new StaticLink(x) },
                { AbilityId.razor_eye_of_the_storm, x => this.storm = new AoeAbility(x) },

                { AbilityId.item_phase_boots, x => this.phase = new SpeedBuffAbility(x) },
                { AbilityId.item_force_staff, x => this.force = new ForceStaff(x) },
                { AbilityId.item_hurricane_pike, x => this.pike = new HurricanePike(x) },
                { AbilityId.item_blade_mail, x => this.bladeMail = new ShieldAbility(x) },
                { AbilityId.item_rod_of_atos, x => this.atos = new DisableAbility(x) },
                { AbilityId.item_black_king_bar, x => this.bkb = new ShieldAbility(x) },
                { AbilityId.item_shivas_guard, x => this.shiva = new DebuffAbility(x) },
                { AbilityId.item_heavens_halberd, x => this.halberd = new DisableAbility(x) },
            };
        }
Exemplo n.º 24
0
        public VengefulSpirit(Unit9 owner, MultiSleeper abilitySleeper, Sleeper orbwalkSleeper, ControllableUnitMenu menu)
            : base(owner, abilitySleeper, orbwalkSleeper, menu)
        {
            this.ComboAbilities = new Dictionary <AbilityId, Func <ActiveAbility, UsableAbility> >
            {
                { AbilityId.vengefulspirit_magic_missile, x => this.missile = new DisableAbility(x) },
                { AbilityId.vengefulspirit_wave_of_terror, x => this.wave = new DebuffAbility(x) },
                { AbilityId.vengefulspirit_nether_swap, x => this.swap = new TargetableAbility(x) },

                { AbilityId.item_force_staff, x => this.force = new ForceStaff(x) },
                { AbilityId.item_hurricane_pike, x => this.pike = new HurricanePike(x) },
                { AbilityId.item_solar_crest, x => this.solar = new DebuffAbility(x) },
                { AbilityId.item_medallion_of_courage, x => this.medallion = new DebuffAbility(x) },
                { AbilityId.item_spirit_vessel, x => this.vessel = new DebuffAbility(x) },
                { AbilityId.item_urn_of_shadows, x => this.urn = new DebuffAbility(x) },
            };

            this.MoveComboAbilities.Add(AbilityId.lion_impale, _ => this.missile);
        }
Exemplo n.º 25
0
        public Lion(Unit9 owner, MultiSleeper abilitySleeper, Sleeper orbwalkSleeper, ControllableUnitMenu menu)
            : base(owner, abilitySleeper, orbwalkSleeper, menu)
        {
            this.ComboAbilities = new Dictionary <AbilityId, Func <ActiveAbility, UsableAbility> >
            {
                { AbilityId.lion_impale, x => this.impale = new DisableAbility(x) },
                { AbilityId.lion_mana_drain, x => this.drain = new ManaDrain(x) },
                { AbilityId.lion_voodoo, x => this.hex = new DisableAbility(x) },
                { AbilityId.lion_finger_of_death, x => this.finger = new NukeAbility(x) },

                { AbilityId.item_force_staff, x => this.force = new ForceStaff(x) },
                { AbilityId.item_veil_of_discord, x => this.veil = new DebuffAbility(x) },
                { AbilityId.item_blink, x => this.blink = new BlinkAbility(x) },
                { AbilityId.item_dagon_5, x => this.dagon = new NukeAbility(x) },
                { AbilityId.item_ethereal_blade, x => this.ethereal = new EtherealBlade(x) },
            };

            this.MoveComboAbilities.Add(AbilityId.lion_impale, _ => this.impale);
            this.MoveComboAbilities.Add(AbilityId.lion_voodoo, _ => this.hex);
        }
Exemplo n.º 26
0
Arquivo: Axe.cs Projeto: vana41203/O9K
        public Axe(Unit9 owner, MultiSleeper abilitySleeper, Sleeper orbwalkSleeper, ControllableUnitMenu menu)
            : base(owner, abilitySleeper, orbwalkSleeper, menu)
        {
            this.ComboAbilities = new Dictionary <AbilityId, Func <ActiveAbility, UsableAbility> >
            {
                { AbilityId.axe_berserkers_call, x => this.call = new DisableAbility(x) },
                { AbilityId.axe_battle_hunger, x => this.hunger = new DebuffAbility(x) },
                { AbilityId.axe_culling_blade, x => this.blade = new CullingBlade(x) },

                { AbilityId.item_blink, x => this.blink = new BlinkDaggerAOE(x) },
                { AbilityId.item_force_staff, x => this.force = new ForceStaff(x) },
                { AbilityId.item_blade_mail, x => this.bladeMail = new ShieldAbility(x) },
                { AbilityId.item_black_king_bar, x => this.bkb = new ShieldAbility(x) },
                { AbilityId.item_shivas_guard, x => this.shiva = new DebuffAbility(x) },
                { AbilityId.item_mjollnir, x => this.mjollnir = new ShieldAbility(x) },
                { AbilityId.item_meteor_hammer, x => this.meteor = new MeteorHammerAxe(x) },
                { AbilityId.item_dagon_5, x => this.dagon = new NukeAbility(x) },
            };

            this.MoveComboAbilities.Add(AbilityId.axe_berserkers_call, _ => this.call);
        }
Exemplo n.º 27
0
        public Magnus(Unit9 owner, MultiSleeper abilitySleeper, Sleeper orbwalkSleeper, ControllableUnitMenu menu)
            : base(owner, abilitySleeper, orbwalkSleeper, menu)
        {
            this.ComboAbilities = new Dictionary <AbilityId, Func <ActiveAbility, UsableAbility> >
            {
                { AbilityId.magnataur_shockwave, x => this.shockwave = new Shockwave(x) },
                {
                    AbilityId.magnataur_skewer, x =>
                    {
                        this.skewer = new Skewer(x);
                        this.polarity?.AddSkewer(this.skewer);
                        return(this.skewer);
                    }
                },
                {
                    AbilityId.magnataur_reverse_polarity, x =>
                    {
                        this.polarity = new ReversePolarity(x);
                        if (this.skewer != null)
                        {
                            this.polarity.AddSkewer(this.skewer);
                        }

                        return(this.polarity);
                    }
                },

                { AbilityId.item_blink, x => this.blink = new BlinkDaggerMagnus(x) },
                { AbilityId.item_swift_blink, x => this.blink = new BlinkDaggerMagnus(x) },
                { AbilityId.item_arcane_blink, x => this.blink = new BlinkDaggerMagnus(x) },
                { AbilityId.item_overwhelming_blink, x => this.blink = new BlinkDaggerMagnus(x) },
                { AbilityId.item_force_staff, x => this.force = new ForceStaff(x) },
                { AbilityId.item_shivas_guard, x => this.shiva = new ShivasGuard(x) },
                { AbilityId.item_refresher, x => this.refresher = new UntargetableAbility(x) },
                { AbilityId.item_refresher_shard, x => this.refresherShard = new UntargetableAbility(x) },
            };

            this.MoveComboAbilities.Add(AbilityId.magnataur_skewer, x => this.moveSkewer = new BlinkAbility(x));
        }
Exemplo n.º 28
0
        // Token: 0x0600068A RID: 1674 RVA: 0x0001FA94 File Offset: 0x0001DC94
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            AbilityHelper abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            if (abilityHelper.UseAbility(this.glimpse, true))
            {
                BlinkAbility blinkAbility = this.blink;
                if (blinkAbility != null)
                {
                    blinkAbility.Sleeper.Sleep(3f);
                }
                ForceStaff forceStaff = this.force;
                if (forceStaff != null)
                {
                    forceStaff.Sleeper.Sleep(3f);
                }
                return(true);
            }
            if (abilityHelper.CanBeCasted(this.glimpse, false, true, true, true))
            {
                if (abilityHelper.UseAbility(this.blink, this.glimpse.Ability.CastRange, this.glimpse.Ability.CastRange - 500f))
                {
                    return(true);
                }
            }
            else if (abilityHelper.UseAbility(this.blink, 800f, 500f))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.force, this.glimpse.Ability.CastRange, this.glimpse.Ability.CastRange - 500f))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.veil, true))
            {
                return(true);
            }
            float timeSinceCasted = this.glimpse.Ability.TimeSinceCasted;

            if ((double)timeSinceCasted < 1.8)
            {
                ParticleEffect particleEffect = this.glimpseParticle;
                if (particleEffect != null && particleEffect.IsValid && !targetManager.Target.IsMagicImmune)
                {
                    Vector3 controlPoint = this.glimpseParticle.GetControlPoint(1u);
                    if (abilityHelper.CanBeCasted(this.field, false, true, true, true) && this.field.UseAbility(controlPoint, base.ComboSleeper))
                    {
                        return(true);
                    }
                    float x = this.glimpseParticle.GetControlPoint(2u).X;
                    if (timeSinceCasted + 0.35f > x && abilityHelper.CanBeCasted(this.storm, false, true, true, true) && this.storm.UseAbility(controlPoint, targetManager, base.ComboSleeper))
                    {
                        return(true);
                    }
                    if (base.Owner.Distance(controlPoint) > this.storm.Ability.CastRange - 100f)
                    {
                        base.Owner.BaseUnit.Move(Vector3Extensions.Extend2D(controlPoint, base.Owner.Position, 500f));
                        return(true);
                    }
                }
                base.OrbwalkSleeper.Sleep(0.1f);
                return(true);
            }
            if (timeSinceCasted > 2f && abilityHelper.UseAbilityIfNone(this.field, new UsableAbility[]
            {
                this.glimpse
            }))
            {
                return(true);
            }
            if (abilityHelper.CanBeCasted(this.storm, true, true, true, true))
            {
                if (this.field.Ability.TimeSinceCasted <= 4f)
                {
                    if (this.storm.UseAbility(this.field.CastPosition, targetManager, base.ComboSleeper))
                    {
                        return(true);
                    }
                }
                else if (abilityHelper.UseAbility(this.storm, true))
                {
                    return(true);
                }
            }
            if (abilityHelper.CanBeCasted(this.thunder, true, true, true, true))
            {
                float num = base.Owner.Mana - this.thunder.Ability.ManaCost;
                if (abilityHelper.CanBeCasted(this.field, true, true, true, true))
                {
                    num -= this.field.Ability.ManaCost;
                }
                if (abilityHelper.CanBeCasted(this.storm, true, true, true, true))
                {
                    num -= this.storm.Ability.ManaCost;
                }
                if (num > 0f)
                {
                    abilityHelper.UseAbility(this.thunder, true);
                }
            }
            return(false);
        }