private async Task<bool> DoRotation(ExGatherTag tag)
		{
			// 96-180 with min perception
			// 138-259 with max perception
			await tag.Cast(Ability.DiscerningEye);
			await tag.Cast(Ability.InstinctualAppraisal);

			if (CurrentRarity < 240)
			{
				var perception = Core.Player.Stats.Perception;

				// Methodical range is 80-115
				// Discerning methodical is 120-172
				if (Core.Player.CurrentGP >= 200)
				{
					// TODO: not complete
				}

				await Methodical(tag);
			}

			await IncreaseChance(tag);

			return true;
		}
		protected override async Task<bool> IncreaseChance(ExGatherTag tag)
		{
			var level = Core.Player.ClassLevel;
			if (Core.Player.CurrentGP >= 250 && tag.GatherItem.Chance < 51 && level > 10)
			{
				return await tag.Cast(Ability.IncreaseGatherChance50);
			}

			if (Core.Player.CurrentGP >= 100 && tag.GatherItem.Chance < 95 && level > 4)
			{
				if (level >= 23 && GatheringManager.SwingsRemaining == 1)
				{
					return await tag.Cast(Ability.IncreaseGatherChanceOnce15);
				}

				return await tag.Cast(Ability.IncreaseGatherChance15);
			}

			if (Core.Player.CurrentGP >= 50 && tag.GatherItem.Chance < 100 && level > 3)
			{
				if (level >= 23 && GatheringManager.SwingsRemaining == 1)
				{
					return await tag.Cast(Ability.IncreaseGatherChanceOnce15);
				}

				return await tag.Cast(Ability.IncreaseGatherChance5);
			}

			return true;
		}
		public override async Task<bool> ExecuteRotation(ExGatherTag tag)
		{
			var level = Core.Player.ClassLevel;

			if (GatheringManager.SwingsRemaining > 4 || ShouldForceUseRotation(tag, level))
			{
				if (Core.Player.CurrentGP >= 500 && level >= 40)
				{
					await tag.Cast(Ability.IncreaseGatherYield2);
					return await base.ExecuteRotation(tag);
				}

				if (Core.Player.CurrentGP >= 400 && level >= 30 && (level < 40 || Core.Player.MaxGP < 500))
				{
					await tag.Cast(Ability.IncreaseGatherYield);
					return await base.ExecuteRotation(tag);
				}

				if (Core.Player.CurrentGP >= 300 && level >= 25 && (level < 30 || Core.Player.MaxGP < 400))
				{
					await Wait();

					if (!tag.GatherItem.TryGatherItem())
					{
						return false;
					}

					await tag.Cast(Ability.AdditionalAttempt);
					return await base.ExecuteRotation(tag);
				}
			}

			return true;
		}
		public override async Task<bool> ExecuteRotation(ExGatherTag tag)
		{
			var level = Core.Player.ClassLevel;

			if (GatheringManager.SwingsRemaining > 4 || ShouldForceUseRotation(tag, level))
			{
				if (Core.Player.CurrentGP >= 500 && level >= 40)
				{
					await tag.Cast(Ability.IncreaseGatherYield2);

					if (Core.Player.CurrentGP >= 100)
					{
						await tag.Cast(Ability.IncreaseGatherQuality10);

                        if (Core.Player.CurrentGP >= 100 && tag.GatherItem.Chance < 95)
                        {
                            await tag.Cast(Ability.IncreaseGatherChance15);
                        }
                        else
                        {
                            if (Core.Player.CurrentGP >= 50 && tag.GatherItem.Chance < 100)
                            {
                                await tag.Cast(Ability.IncreaseGatherChance5);
                            }
                        }

                        return await base.ExecuteRotation(tag);
					}
				}
			}

			return true;
		}
		public override async Task<bool> ExecuteRotation(ExGatherTag tag)
		{
			if (Core.Player.CurrentGP >= 300 && GatheringManager.SwingsRemaining > 4)
			{
				await tag.Cast(Ability.IncreaseGatherQuality30);
				await base.ExecuteRotation(tag);

				if (tag.GatherItem.Chance == 100 && Core.Player.CurrentGP >= 300 && GatheringManager.SwingsRemaining == 5)
				{
					await Wait();

					if (!tag.GatherItem.TryGatherItem())
					{
						return false;
					}

					await tag.Cast(Ability.AdditionalAttempt);
				}

				return true;
			}

			// Approx 30 gp or more between running to nodes, we are basically capped here so just use 100 gp
			if (Core.Player.CurrentGP >= Core.Player.MaxGP - 30)
			{
				await tag.Cast(Ability.IncreaseGatherQuality10);
				return true;
			}

			return true;
		}
예제 #6
0
		public virtual async Task<bool> Gather(ExGatherTag tag)
		{
			tag.StatusText = "Gathering items";

			while (tag.Node.CanGather && GatheringManager.SwingsRemaining > tag.SwingsRemaining && Behaviors.ShouldContinue)
			{
				await Wait();

				if (Memory.Gathering.HqChain == 2 && GatheringManager.SwingsRemaining > tag.SwingsRemaining)
				{
					await tag.Cast(Ability.Luck);

					await Wait();
				}

				if (GatheringManager.GatheringCombo == 4 && GatheringManager.SwingsRemaining > tag.SwingsRemaining)
				{
					await tag.Cast(Ability.IncreaseGatherChanceQuality100);

					await Wait();
				}

				if (!await tag.ResolveGatherItem())
				{
					return false;
				}

				var swingsRemaining = GatheringManager.SwingsRemaining - 1;

				if (!tag.GatherItem.TryGatherItem())
				{
					return false;
				}

				var ticks = 0;
				while (swingsRemaining != GatheringManager.SwingsRemaining && ticks++ < 60 && Behaviors.ShouldContinue)
				{
					await Coroutine.Yield();
				}
			}

			tag.StatusText = "Gathering items complete";

			return true;
		}
		public override async Task<bool> ExecuteRotation(ExGatherTag tag)
		{
			if (Core.Player.CurrentGP >= 500)
			{
				await tag.Cast(Ability.IncreaseGatherYield2);
			}

			return await base.ExecuteRotation(tag);
		}
예제 #8
0
		public override async Task<bool> Gather(ExGatherTag tag)
		{
			tag.StatusText = "Gathering items";

			while (tag.Node.CanGather && GatheringManager.SwingsRemaining > tag.SwingsRemaining && Behaviors.ShouldContinue)
			{
				await Wait();

				if (GatheringManager.GatheringCombo == 4 && GatheringManager.SwingsRemaining > tag.SwingsRemaining)
				{
					await tag.Cast(Ability.IncreaseGatherChanceQuality100);
					await tag.Cast(Ability.IncreaseGatherYieldOnce);
					await Wait();
				}

				// No way to tell if we missed the first swing afaik... so we have to check if we have a combo of 0 anytime after the second swing.
				if (GatheringManager.GatheringCombo == 0 && GatheringManager.SwingsRemaining < 5 && !Core.Player.HasAura(220))
				{
					await tag.Cast(Ability.IncreaseGatherQuality10);
				}

				if (!await tag.ResolveGatherItem())
				{
					return false;
				}

				var swingsRemaining = GatheringManager.SwingsRemaining - 1;

				if (!tag.GatherItem.TryGatherItem())
				{
					return false;
				}

				var ticks = 0;
				while (swingsRemaining != GatheringManager.SwingsRemaining && ticks++ < 60 && Behaviors.ShouldContinue)
				{
					await Coroutine.Yield();
				}
			}

			tag.StatusText = "Gathering items complete";

			return true;
		}
		public override async Task<bool> Prepare(ExGatherTag tag)
		{
			// TODO: how much gathering to 1 hit?  needs to be added into this logic.
			if (Core.Player.CurrentGP >= 500)
			{
				await tag.Cast(Ability.Toil);
			}

			return await base.Prepare(tag);
		}
		public override async Task<bool> Prepare(ExGatherTag tag)
		{
			var unknownItems = GatheringManager.GatheringWindowItems.Where(i => i.IsUnknownChance() && i.Amount > 0).ToArray();

			if (tag.IsUnspoiled() && Core.Player.CurrentGP >= 550 && unknownItems.Length > 1)
			{
				await tag.Cast(Ability.Toil);
			}

			return await base.Prepare(tag);
		}
		private async Task<bool> DoLevel50Rotation(ExGatherTag tag)
		{
			// 240-345 collectability
			await Methodical(tag);
			await Methodical(tag);
			await Methodical(tag);

			if (Core.Player.CurrentGP >= 300)
			{
				await tag.Cast(Ability.AdditionalAttempt);
			}

			return true;
		}
		public override async Task<bool> ExecuteRotation(ExGatherTag tag)
		{
			var gpRequired = 0U;
			var skillList = new List<SpellData>();
			foreach (var gatheringSkill in tag.GatheringSkillOrder.GatheringSkills)
			{
				// Ignoring times to cast.... no skills would ever be cast more than once.
				SpellData spellData;

				if (!Actionmanager.CurrentActions.TryGetValue(gatheringSkill.SpellName, out spellData))
				{
					Actionmanager.CurrentActions.TryGetValue(gatheringSkill.SpellId, out spellData);
				}

				if (spellData == null)
				{
					tag.Logger.Warn("Unable to find skill -> Name: {0}, Id: {1}", gatheringSkill.SpellName, gatheringSkill.SpellId);
				}
				else
				{
					skillList.Add(spellData);
					gpRequired += spellData.Cost;
				}
			}
			if (!tag.GatheringSkillOrder.AllOrNone || gpRequired <= Core.Player.CurrentGP)
			{
				foreach (var skill in skillList)
				{
					if (Core.Player.CurrentGP > skill.Cost)
					{
						await tag.Cast(skill.Id);
					}
				}
			}

			return true;
		}
 protected async Task Impulsive(ExGatherTag tag)
 {
     await tag.Cast(Ability.ImpulsiveAppraisal);
 }
예제 #14
0
		public override async Task<bool> ExecuteRotation(ExGatherTag tag)
		{
			await tag.Cast(Ability.Toil);

			return await base.ExecuteRotation(tag);
		}
        protected async Task SingleMindMethodical(ExGatherTag tag)
        {
            await tag.Cast(Ability.SingleMind);

            await tag.Cast(Ability.MethodicalAppraisal);
        }
		protected async Task DiscerningImpulsive(ExGatherTag tag)
		{
			await tag.Cast(Ability.DiscerningEye);
			await tag.Cast(Ability.ImpulsiveAppraisal);
		}
		protected async Task AppraiseAndRebuff(ExGatherTag tag)
		{
			await Impulsive(tag);

			if (HasDiscerningEye)
			{
				await tag.Cast(Ability.SingleMind);
			}
			else
			{
				await tag.Cast(Ability.DiscerningEye);
			}
		}
 protected async Task Discerning(ExGatherTag tag)
 {
     await tag.Cast(Ability.DiscerningEye);
 }
 protected async Task Methodical(ExGatherTag tag)
 {
     await tag.Cast(Ability.MethodicalAppraisal);
 }
예제 #20
0
		public override async Task<bool> ExecuteRotation(ExGatherTag tag)
		{
			var level = Core.Player.ClassLevel;
			var gp = Core.Player.CurrentGP;

			// Yield And Quality
			if (tag.GatherIncrease == GatherIncrease.YieldAndQuality
				|| (tag.GatherIncrease == GatherIncrease.Auto && level >= 40 && gp >= 650))
			{
				if (gp >= 500 && level >= 40)
				{
					await tag.Cast(Ability.IncreaseGatherYield2);

					if (Core.Player.CurrentGP >= 100)
					{
						await tag.Cast(Ability.IncreaseGatherQuality10);
					}

					return await base.ExecuteRotation(tag);
				}

				return true;
			}

			// Yield
			if (tag.GatherIncrease == GatherIncrease.Yield
				|| (tag.GatherIncrease == GatherIncrease.Auto && level >= 40))
			{
				if (gp >= 500 && level >= 40)
				{
					await tag.Cast(Ability.IncreaseGatherYield2);
					return await base.ExecuteRotation(tag);
				}

				if (gp >= 400 && level >= 30 && (level < 40 || Core.Player.MaxGP < 500))
				{
					await tag.Cast(Ability.IncreaseGatherYield);
					return await base.ExecuteRotation(tag);
				}

				if (gp >= 300 && level >= 25 && (level < 30 || Core.Player.MaxGP < 400))
				{
					await Wait();

					if (!tag.GatherItem.TryGatherItem())
					{
						return false;
					}

					await tag.Cast(Ability.AdditionalAttempt);
					return await base.ExecuteRotation(tag);
				}

				return true;
			}

			// Quality
			if (tag.GatherIncrease == GatherIncrease.Quality
				|| (tag.GatherIncrease == GatherIncrease.Auto && level >= 15 && level < 40))
			{
				if (Core.Player.CurrentGP >= 300)
				{
					await tag.Cast(Ability.IncreaseGatherQuality30);
					return await base.ExecuteRotation(tag);;
				}

				return true;
			}

			return await base.ExecuteRotation(tag);
		}
예제 #21
0
        public override async Task <bool> ExecuteRotation(ExGatherTag tag)
        {
            double YieldsLeft()
            {
                return(Math.Min(GatheringManager.SwingsRemaining, Math.Max(0, (Core.Player.CurrentGP + GatheringManager.SwingsRemaining * 5) / 100)));
            }

            var bountifulYield = tag.GatherItem.Level <= 70 ? 3 : 2;

            int pickCleanYield;

            if (tag.GatherItem.Level <= 50)
            {
                pickCleanYield = 3;
            }
            else
            {
                pickCleanYield = tag.GatherItem.Level <= 70 ? 2 : 1;
            }

            await IncreaseChance(tag);
            await Wait();

            if (Core.Player.CurrentGP >= 250 && level >= 77)
            {
                var yieldCalc      = Math.Max(0, (Core.Player.CurrentGP + (GatheringManager.MaxSwings - 1) * 5) / 100.0);
                var adjustedGp     = yieldCalc - Math.Floor(yieldCalc);
                var pickCleanBonus = adjustedGp >= 0.50 && adjustedGp <= 0.999 ? 1 : 0;

                if (pickCleanYield * GatheringManager.MaxSwings > bountifulYield * (3 - pickCleanBonus))
                {
                    await tag.Cast(Ability.PickClean);
                    await Wait();
                }
            }

            double uncappedYields = Math.Floor((Core.Player.CurrentGP + (GatheringManager.MaxSwings - 1) * 5) / 100d);

            if (Core.Player.CurrentGP >= 500 && level >= 40)
            {
                if ((GatheringManager.MaxSwings * 2) + (uncappedYields - 5) >= bountifulYield * Math.Floor(YieldsLeft()))
                {
                    await tag.Cast(Ability.IncreaseGatherYield2);
                    await Wait();
                }
            }

            bool usedVigorForce = false;

            while (tag.Node.CanGather && GatheringManager.SwingsRemaining > tag.SwingsRemaining && Behaviors.ShouldContinue)
            {
                await Wait();

                if (!usedVigorForce && GatheringManager.GatheringCombo == 4 && GatheringManager.SwingsRemaining > 0 && ((tag.GatherItem.HqChance > 0 && tag.GatherItem.HqChance < 100) || tag.GatherItem.Chance < 100))
                {
                    await tag.Cast(Ability.IncreaseGatherChanceQuality100);

                    usedVigorForce = true;
                }

                if (Core.Player.CurrentGP >= 100 && level >= 68 && (tag.GatherItem.HqChance == 100 || GatheringManager.SwingsRemaining <= YieldsLeft()) && !Core.Player.HasAura(1286))
                {
                    await tag.Cast(Ability.IncreaseGatherYieldOnce2);

                    await Coroutine.Wait(2000, () => Core.Player.HasAura(1286));
                }

                //double counsels = Math.Floor(YieldsLeft() + 0.1);

                //if (Core.Player.CurrentGP >= 10 && level >= 67 && tag.GatherItem.HqChance > 0 && tag.GatherItem.HqChance < 100 && YieldsLeft() >= counsels && !Core.Player.HasAura(1262))
                //{
                //    await tag.Cast(Ability.IncreaseGatherQualityRandomOnce);
                //    await Coroutine.Wait(2000, () => Core.Player.HasAura(1262));
                //}

                if (!await tag.ResolveGatherItem())
                {
                    return(false);
                }

                if (!tag.GatherItem.TryGatherItem())
                {
                    return(false);
                }

                var swingsRemaining = GatheringManager.SwingsRemaining;

                await Coroutine.Yield();

                await Coroutine.Wait(3000, () => swingsRemaining != GatheringManager.SwingsRemaining);
            }

            return(true);
        }
        protected async Task UtmostMethodical(ExGatherTag tag)
        {
            await tag.Cast(Ability.UtmostCaution);

            await tag.Cast(Ability.MethodicalAppraisal);
        }
        protected async Task UtmostImpulsive(ExGatherTag tag)
        {
            await tag.Cast(Ability.UtmostCaution);

            await tag.Cast(Ability.ImpulsiveAppraisal);
        }
 protected async Task UtmostCaution(ExGatherTag tag)
 {
     await tag.Cast(Ability.UtmostCaution);
 }
        protected async Task DiscerningMethodical(ExGatherTag tag)
        {
            await tag.Cast(Ability.DiscerningEye);

            await tag.Cast(Ability.MethodicalAppraisal);
        }
		protected async Task Methodical(ExGatherTag tag)
		{
			await tag.Cast(Ability.MethodicalAppraisal);
		}
        protected async Task DiscerningImpulsive(ExGatherTag tag)
        {
            await tag.Cast(Ability.DiscerningEye);

            await tag.Cast(Ability.ImpulsiveAppraisal);
        }
		protected async Task UtmostCaution(ExGatherTag tag)
		{
			await tag.Cast(Ability.UtmostCaution);
		}
예제 #29
0
		public virtual async Task<bool> Prepare(ExGatherTag tag)
		{
			if (Core.Player.HasAura((int)AbilityAura.CollectorsGlove))
			{
				return await tag.Cast(Ability.CollectorsGlove);
			}

			return true;
		}
 protected async Task SingleMind(ExGatherTag tag)
 {
     await tag.Cast(Ability.SingleMind);
 }
 protected async Task Instinctual(ExGatherTag tag)
 {
     await tag.Cast(Ability.InstinctualAppraisal);
 }
예제 #32
0
        public override async Task <bool> ExecuteRotation(ExGatherTag tag)
        {
            var level = Core.Player.ClassLevel;
            var gp    = Core.Player.CurrentGP;

            // Yield And Quality
            if (tag.GatherIncrease == GatherIncrease.YieldAndQuality ||
                (tag.GatherIncrease == GatherIncrease.Auto && level >= 40 && gp >= 650))
            {
                if (gp >= 500 && level >= 40)
                {
                    await tag.Cast(Ability.IncreaseGatherYield2);

                    if (Core.Player.CurrentGP >= 100)
                    {
                        await tag.Cast(Ability.IncreaseGatherQuality10);
                    }

                    return(await base.ExecuteRotation(tag));
                }

                return(true);
            }

            // Yield
            if (tag.GatherIncrease == GatherIncrease.Yield || (tag.GatherIncrease == GatherIncrease.Auto && level >= 40))
            {
                if (gp >= 500 && level >= 40)
                {
                    await tag.Cast(Ability.IncreaseGatherYield2);

                    return(await base.ExecuteRotation(tag));
                }

                if (gp >= 400 && level >= 30 && (level < 40 || Core.Player.MaxGP < 500))
                {
                    await tag.Cast(Ability.IncreaseGatherYield);

                    return(await base.ExecuteRotation(tag));
                }

                if (gp >= 300 && level >= 25 && (level < 30 || Core.Player.MaxGP < 400))
                {
                    await Wait();

                    if (!tag.GatherItem.TryGatherItem())
                    {
                        return(false);
                    }

                    await tag.Cast(Ability.AdditionalAttempt);

                    return(await base.ExecuteRotation(tag));
                }

                return(true);
            }

            // Quality
            if (tag.GatherIncrease == GatherIncrease.Quality ||
                (tag.GatherIncrease == GatherIncrease.Auto && level >= 15 && level < 40))
            {
                if (Core.Player.CurrentGP >= 300)
                {
                    if (Core.Player.ClassLevel >= 63)
                    {
                        await tag.Cast(Ability.IncreaseGatherQuality30100);
                    }
                    else
                    {
                        await tag.Cast(Ability.IncreaseGatherQuality30);
                    }
                    return(await base.ExecuteRotation(tag));

                    ;
                }

                return(true);
            }

            return(await base.ExecuteRotation(tag));
        }
		protected async Task Discerning(ExGatherTag tag)
		{
			await tag.Cast(Ability.DiscerningEye);
		}
        public override async Task <bool> ExecuteRotation(ExGatherTag tag)
        {
            if (Core.Player.CurrentGP >= 300 && level >= 63 && tag.GatherItem.HqChance < 100)
            {
                if (tag.GatherItem.HqChance >= 90)
                {
                    await tag.Cast(Ability.IncreaseGatherQuality10);
                    await Wait();
                }
                else
                {
                    await tag.Cast(Ability.IncreaseGatherQuality30100);
                    await Wait();
                }

                await IncreaseChance(tag);
                await Wait();
            }

            double YieldsLeft()
            {
                return(Math.Min(GatheringManager.SwingsRemaining, Math.Max(0, (Core.Player.CurrentGP + GatheringManager.SwingsRemaining * 5) / 100)));
            }

            var bountifulYield = tag.GatherItem.Level <= 70 ? 3 : 2;

            double uncappedYields = Math.Floor((Core.Player.CurrentGP + (GatheringManager.MaxSwings - 1) * 5) / 100d);

            if (Core.Player.CurrentGP >= 500 && level >= 40)
            {
                if ((GatheringManager.MaxSwings * 2) + (uncappedYields - 5) >= bountifulYield * Math.Floor(YieldsLeft()))
                {
                    await tag.Cast(Ability.IncreaseGatherYield2);
                    await Wait();
                }
            }

            bool usedVigorForce = false;

            while (tag.Node.CanGather && GatheringManager.SwingsRemaining > 0 && Behaviors.ShouldContinue)
            {
                await Wait();

                if (!usedVigorForce && GatheringManager.GatheringCombo == 4 && GatheringManager.SwingsRemaining > tag.SwingsRemaining && ((tag.GatherItem.HqChance > 0 && tag.GatherItem.HqChance < 100) || tag.GatherItem.Chance < 100))
                {
                    await tag.Cast(Ability.IncreaseGatherChanceQuality100);

                    usedVigorForce = true;
                }

                if (Core.Player.CurrentGP >= 100 && level >= 68 && (tag.GatherItem.HqChance == 100 || GatheringManager.SwingsRemaining <= YieldsLeft()) && !Core.Player.HasAura(1286))
                {
                    await tag.Cast(Ability.IncreaseGatherYieldOnce2);

                    await Coroutine.Wait(2000, () => Core.Player.HasAura(1286));
                    await Wait();
                }

                //double counsels = Math.Floor(YieldsLeft() + 0.1);

                //if (Core.Player.CurrentGP >= 10 && level >= 67 && tag.GatherItem.HqChance > 0 && tag.GatherItem.HqChance < 100 && YieldsLeft() >= counsels && !Core.Player.HasAura(1262))
                //{
                //    await tag.Cast(Ability.IncreaseGatherQualityRandomOnce);
                //    await Coroutine.Wait(2000, () => Core.Player.HasAura(1262));
                //    await Wait();
                //}

                if (!await tag.ResolveGatherItem())
                {
                    return(false);
                }

                if (!tag.GatherItem.TryGatherItem())
                {
                    return(false);
                }

                await Coroutine.Yield();
            }

            return(true);
        }
		protected async Task Impulsive(ExGatherTag tag)
		{
			await tag.Cast(Ability.ImpulsiveAppraisal);
		}
        protected async Task SingleMindImpulsive(ExGatherTag tag)
        {
            await tag.Cast(Ability.SingleMind);

            await tag.Cast(Ability.ImpulsiveAppraisal);
        }
		protected async Task SingleMindImpulsive(ExGatherTag tag)
		{
			await tag.Cast(Ability.SingleMind);
			await tag.Cast(Ability.ImpulsiveAppraisal);
		}
		protected async Task UtmostImpulsive(ExGatherTag tag)
		{
			await tag.Cast(Ability.UtmostCaution);
			await tag.Cast(Ability.ImpulsiveAppraisal);
		}
		protected async Task UtmostDiscerningMethodical(ExGatherTag tag)
		{
			await tag.Cast(Ability.UtmostCaution);
			await tag.Cast(Ability.DiscerningEye);
			await tag.Cast(Ability.MethodicalAppraisal);
		}
예제 #40
0
 protected async Task Stickler(ExGatherTag tag)
 {
     await tag.Cast(Ability.Stickler);
 }
		protected async Task UtmostSingleMindMethodical(ExGatherTag tag)
		{
			await tag.Cast(Ability.UtmostCaution);
			await tag.Cast(Ability.SingleMind);
			await tag.Cast(Ability.MethodicalAppraisal);
		}
예제 #42
0
        public override async Task <bool> ExecuteRotation(ExGatherTag tag)
        {
            await tag.Cast(Ability.Toil);

            return(await base.ExecuteRotation(tag));
        }