public override async Task<bool> ExecuteRotation(ExGatherTag tag)
{
if (tag.IsUnspoiled())
{
await SingleMindMethodical(tag);
await SingleMindMethodical(tag);
await UtmostCaution(tag);
await Methodical(tag);
await UtmostCaution(tag);
await Methodical(tag);
}
else
{
if (Core.Player.CurrentGP >= 600)
{
await SingleMindMethodical(tag);
await SingleMindMethodical(tag);
await UtmostCaution(tag);
await Methodical(tag);
await UtmostCaution(tag);
await Methodical(tag);
return true;
}
await Impulsive(tag);
await Impulsive(tag);
await Methodical(tag);
}
return true;
}
public override async Task<bool> ExecuteRotation(ExGatherTag tag)
{
var gp = GameObjectManager.LocalPlayer.CurrentGP;
if (gp >= 600)
{
await Discerning(tag);
await AppraiseAndRebuff(tag);
await AppraiseAndRebuff(tag);
await Methodical(tag);
}
else
{
tag.Logger.Warn("Using alternate rotation to collect one or two due to CurrentGP: {0} being less than RequiredGP: {1}", gp, 600);
// Less than 600 GP collect 1-2 rotation
await UtmostImpulsive(tag);
if (HasDiscerningEye)
{
await UtmostSingleMindMethodical(tag);
}
else
{
await UtmostCaution(tag);
await AppraiseAndRebuff(tag);
}
await Methodical(tag);
await Methodical(tag);
}
await IncreaseChance(tag);
return true;
}
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;
}
public override async Task<bool> MoveToSpot(ExGatherTag tag)
{
tag.StatusText = "Moving to " + this;
if (ApproachLocation == Vector3.Zero)
{
return false;
}
var result =
await
ApproachLocation.MoveTo(
UseMesh,
radius: tag.Radius,
name: "Approach Location",
stopCallback: tag.MovementStopCallback);
if (result)
{
await Coroutine.Yield();
result = await NodeLocation.MoveToNoMount(UseMesh, tag.Distance, tag.Node.EnglishName, tag.MovementStopCallback);
}
return result;
}
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;
}
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)
{
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;
}
public override async Task<bool> MoveToSpot(ExGatherTag tag)
{
tag.StatusText = "Moving to " + this;
if (StealthLocation == Vector3.Zero)
{
return false;
}
var result =
await
StealthLocation.MoveTo(UseMesh,
radius: tag.Radius,
name: "Stealth Location",
stopCallback: tag.MovementStopCallback,
dismountAtDestination: true);
if (result)
{
await Coroutine.Yield();
await tag.CastAura(Ability.Stealth, AbilityAura.Stealth);
result =
await NodeLocation.MoveToNoMount(UseMesh, tag.Distance, tag.Node.EnglishName, tag.MovementStopCallback);
}
return result;
}
public override async Task<bool> ExecuteRotation(ExGatherTag tag)
{
await Methodical(tag);
await IncreaseChance(tag);
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);
}
int IGetOverridePriority.GetOverridePriority(ExGatherTag tag)
{
if (tag.IsUnspoiled() && tag.CollectableItem == null)
{
return 8000;
}
return -1;
}
int IGetOverridePriority.GetOverridePriority(ExGatherTag tag)
{
// if we have a collectable && the collectable value is greater than or equal to 346: Priority 346
if (tag.CollectableItem != null && tag.CollectableItem.Value >= 346)
{
return 346;
}
return -1;
}
int IGetOverridePriority.GetOverridePriority(ExGatherTag tag)
{
if (tag.IsEphemeral() || tag.IsUnspoiled())
{
return -1;
}
return 8000;
}
public override async Task<bool> ExecuteRotation(ExGatherTag tag)
{
if (Core.Player.ClassLevel > 50)
{
return await DoRotation(tag);
}
return await DoLevel50Rotation(tag);
}
protected virtual IGatheringRotation ResolveInternalGatheringRotation(ExGatherTag tag)
{
if (tag.IsUnspoiled())
{
return ExGatherTag.Rotations["Unspoiled"];
}
return ExGatherTag.Rotations["RegularNode"];
}
int IGetOverridePriority.GetOverridePriority(ExGatherTag tag)
{
// if we have a collectable && the collectable value is greater than or equal to 402: Priority 402
if (tag.CollectableItem != null && tag.CollectableItem.Value >= 402)
{
return 402;
}
return -1;
}
int IGetOverridePriority.GetOverridePriority(ExGatherTag tag)
{
if (tag.IsEphemeral() || tag.IsUnspoiled() || tag.CollectableItem != null)
{
return -1;
}
return 8000;
}
int IGetOverridePriority.GetOverridePriority(ExGatherTag tag)
{
// if we have a collectable && the collectable value is greater than or equal to 515: Priority 515
if (tag.CollectableItem != null && tag.CollectableItem.Value >= 515)
{
return 515;
}
return -1;
}
int IGetOverridePriority.GetOverridePriority(ExGatherTag tag)
{
if (tag.IsEphemeral() && tag.CollectableItem == null)
{
return 9100;
}
return -1;
}
int IGetOverridePriority.GetOverridePriority(ExGatherTag tag)
{
// if we have a collectable Priority 0
if (tag.CollectableItem != null && tag.CollectableItem.Value == 0)
{
return 80;
}
return -1;
}
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);
}
public override async Task<bool> MoveFromSpot(ExGatherTag tag)
{
tag.StatusText = "Moving from " + this;
if (UnstealthAfter && Core.Player.HasAura((int) AbilityAura.Stealth))
{
return await tag.CastAura(Ability.Stealth);
}
return true;
}
int IGetOverridePriority.GetOverridePriority(ExGatherTag tag)
{
// if we have a collectable && the collectable value is greater than or equal to 240: Priority 240
if (tag.CollectableItem != null && tag.CollectableItem.Value >= 240)
{
// Not complete
//return 240;
}
return -1;
}
public override async Task<bool> ExecuteRotation(ExGatherTag tag)
{
await DiscerningMethodical(tag);
await Discerning(tag);
await AppraiseAndRebuff(tag);
await Methodical(tag);
await IncreaseChance(tag);
return true;
}
protected bool ShouldForceUseRotation(ExGatherTag tag, uint level)
{
if (!tag.GatherItemIsFallback && ((level < 50 && tag.NodesGatheredAtMaxGp > 4) || tag.NodesGatheredAtMaxGp > 6))
{
tag.Logger.Info("Using Gp since we have gathered {0} nodes at max Gp.", tag.NodesGatheredAtMaxGp);
return true;
}
return false;
}
public override async Task<bool> ExecuteRotation(ExGatherTag tag)
{
await UtmostCaution(tag);
await AppraiseAndRebuff(tag);
await UtmostMethodical(tag);
await Methodical(tag);
await SingleMindMethodical(tag); // TODO: display message we are using alternate since not enough gp
await IncreaseChance(tag);
return true;
}
public override async Task<bool> MoveFromSpot(ExGatherTag tag)
{
tag.StatusText = "Moving from " + this;
var result = true;
if (ReturnToApproachLocation)
{
result &= await ApproachLocation.MoveToNoMount(UseMesh, tag.Radius, tag.Node.EnglishName, tag.MovementStopCallback);
}
return result;
}
public virtual async Task<bool> MoveToSpot(ExGatherTag tag)
{
tag.StatusText = "Moving to " + this;
var result =
await
NodeLocation.MoveTo(UseMesh,
radius: tag.Distance,
name: tag.Node.EnglishName,
stopCallback: tag.MovementStopCallback);
return result;
}
protected async Task SingleMindMethodical(ExGatherTag tag)
{
await SingleMind(tag);
await Methodical(tag);
}
protected async Task SingleMindImpulsive(ExGatherTag tag)
{
await SingleMind(tag);
await Impulsive(tag);
}
protected async Task Methodical(ExGatherTag tag)
{
await tag.Cast(Ability.MethodicalAppraisal);
}
public override async Task <bool> ExecuteRotation(ExGatherTag tag)
{
return(true);
}
protected async Task UtmostSingleMind(ExGatherTag tag)
{
await UtmostCaution(tag);
await SingleMind(tag);
}
public override async Task <bool> ExecuteRotation(ExGatherTag tag)
{
await tag.Cast(Ability.Toil);
return(await base.ExecuteRotation(tag));
}
protected async Task Stickler(ExGatherTag tag)
{
await tag.Cast(Ability.Stickler);
}
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));
}
protected async Task DiscerningInstinctual(ExGatherTag tag)
{
await Discerning(tag);
await Instinctual(tag);
}
protected async Task SingleMindInstinctual(ExGatherTag tag)
{
await SingleMind(tag);
await Instinctual(tag);
}
public override async Task <bool> Prepare(ExGatherTag tag)
{
var unknownItems = GatheringManager.GatheringWindowItems.Where(i => i.IsUnknownChance() && i.Amount > 0).ToArray();
return(await base.Prepare(tag));
}
protected async Task UtmostCaution(ExGatherTag tag)
{
await tag.Cast(Ability.UtmostCaution);
}
protected async Task UtmostInstinctual(ExGatherTag tag)
{
await UtmostCaution(tag);
await Instinctual(tag);
}
public virtual async Task <bool> ExecuteRotation(ExGatherTag tag)
{
await IncreaseChance(tag);
return(true);
}
protected async Task Instinctual(ExGatherTag tag)
{
await tag.Cast(Ability.InstinctualAppraisal);
}
protected async Task DiscerningImpulsive(ExGatherTag tag)
{
await Discerning(tag);
await Impulsive(tag);
}
protected async Task UtmostImpulsive(ExGatherTag tag)
{
await UtmostCaution(tag);
await Impulsive(tag);
}
protected async Task UtmostMethodical(ExGatherTag tag)
{
await UtmostCaution(tag);
await Methodical(tag);
}
protected async Task Discerning(ExGatherTag tag)
{
await tag.Cast(Ability.DiscerningEye);
}
protected async Task SingleMind(ExGatherTag tag)
{
await tag.Cast(Ability.SingleMind);
}
protected async Task UtmostDiscerning(ExGatherTag tag)
{
await UtmostCaution(tag);
await Discerning(tag);
}
public override bool ShouldForceGather(ExGatherTag tag)
{
return(!tag.IsUnspoiled());
}
protected async Task DiscerningMethodical(ExGatherTag tag)
{
await Discerning(tag);
await Methodical(tag);
}
public override Task <bool> Prepare(ExGatherTag tag)
{
return(ResolveInternalGatheringRotation(tag).Prepare(tag));
}
public virtual async Task <bool> MoveFromSpot(ExGatherTag tag)
{
tag.StatusText = "Moving from " + this;
return(true);
}
