private static SwitchArgument <RepairState> GetRepairStep(RepairContext context)
{
var closeAction = new Action(r =>
{
Repair.Close();
context.State = BotManager.Current.Name != "Fate Bot"
? RepairState.MovingBack : RepairState.None;
Logger.AgilMessage("Ended repair step, now on: {0}", context.State);
});
var close = new Decorator(req => Equipment.GetCondition() >= context.MinimumDurability && Repair.IsOpen,
closeAction);
var dismount = new Decorator(req => Core.Me.IsMounted,
new Action(r => Actionmanager.Dismount()));
var selectYes = new Decorator(req => SelectYesno.IsOpen,
new Action(r => SelectYesno.ClickYes()));
var move = Movement.SprintMove(r => context.Location);
var repairAll = new RepairAll();
var selectRepair = new SetIconString(2);
var setTarget = new SetTarget(() => context.NpcId);
var interact = new Decorator(req => !Repair.IsOpen && !SelectIconString.IsOpen && !SelectYesno.IsOpen,
new Interact());
var repairStep = new PrioritySelector(move, dismount, close, selectYes, repairAll, selectRepair,
setTarget, interact, new Action(r => RunStatus.Success));
return(new SwitchArgument <RepairState>(repairStep, RepairState.Repairing));
}
public static async Task <bool> MoveTo(Vector3 location)
{
bool goalReached = false;
float distance = Core.Me.Location.Distance(location);
if (distance < 3f)
{
return(true);
}
while (Core.Me.IsAlive && !goalReached)
{
Navigator.MoveTo(location);
distance = Core.Me.Location.Distance(location);
goalReached = distance < 3f;
if (MovementManager.IsMoving && !Core.Me.IsMounted)
{
if (Actionmanager.IsSprintReady && WorldManager.InSanctuary)
{
Actionmanager.Sprint();
}
else if (Actionmanager.IsSprintReady && !WorldManager.InSanctuary && Core.Me.InCombat)
{
Actionmanager.Sprint();
}
}
await Coroutine.Yield();
}
return(true);
}
internal async Task UseItem()
{
if (_obj != null)
{
while (CanUseItem)
{
if (Item != null)
{
if (_obj.NpcId == ItemTarget)
{
Navigator.Stop();
if (Me.IsMounted)
{
await Dismount();
}
if (!Actionmanager.DoAction(Item.ActionType, Item.RawItemId, _obj) && Item.CanUse(_obj))
{
Log("Using {0} on {1}.", Item.Name, _obj.Name);
Item.UseItem(_obj);
await ShortCircuit(_obj, false, false, 5000);
}
}
}
await Coroutine.Yield();
}
}
else
{
return;
}
}
protected override async Task <bool> CustomLogic()
{
if (Target != null)
{
await MoveAndStop(Target.Location, Distance, "Moving to " + Target.Name, true);
if (InPosition(Target.Location, Distance))
{
if (Target.IsTargetable && Target.IsVisible)
{
Target.Face();
Log("Using {0} on {1}.", Spell.LocalizedName, Target.Name);
StatusText = "Using " + Spell.LocalizedName + " on " + Target.Name;
if (!Actionmanager.DoAction(Spell.Id, Target) && Actionmanager.CanCast(Spell, Target))
{
Actionmanager.DoAction(Spell.Id, Target);
}
else
if (!Actionmanager.DoActionLocation(Spell.Id, Target.Location) && Actionmanager.CanCastLocation(Spell, Target.Location))
{
Actionmanager.DoActionLocation(Spell.Id, Target.Location);
}
await ShortCircuit(Target, PersistentObject, IgnoreCombat, 5000);
}
}
}
return(false);
}
protected async Task <bool> Convert()
{
if (GatheringManager.WindowOpen)
{
Log("Waiting for gathering window to close");
Thread.Sleep(2000);
}
if (FishingManager.State != FishingState.None)
{
Log("Stop fishing");
Actionmanager.DoAction("Quit", Core.Me);
await Coroutine.Wait(5000, () => FishingManager.State == FishingState.None);
}
await CommonTasks.StopAndDismount();
if (ItemIds != null && ItemIds.Length > 0)
{
foreach (var id in ItemIds)
{
await ConvertByItemId((uint)id, (ushort)MaxWait, NqOnly);
}
}
return(_done = true);
}
private async Task UseItem()
{
if (TargetForUseItem != null)
{
while (CanUseItem)
{
if (Item != null)
{
if (TargetForUseItem.NpcId == ItemTarget)
{
Navigator.Stop();
if (Me.IsMounted)
{
await Dismount();
}
if (!Actionmanager.DoAction(Item.ActionType, Item.RawItemId, TargetForUseItem) && Item.CanUse(TargetForUseItem))
{
Log("Using {0} on {1}.", Item.Name, TargetForUseItem.Name);
Item.UseItem(TargetForUseItem);
await Coroutine.Wait(6000, () => !Me.IsCasting && (TargetForUseItem as BattleCharacter).HasAura(LacksAuraId));
}
}
}
await Coroutine.Yield();
}
}
else
{
return;
}
}
public static async Task <bool> Dismount(byte maxTicks = 100, ushort interval = 100)
{
var dismountTicks = 0;
while (dismountTicks++ < maxTicks && Core.Player.IsMounted && Behaviors.ShouldContinue)
{
if (MovementManager.IsFlying)
{
if (Navigator.PlayerMover is FlightEnabledSlideMover)
{
Navigator.Stop();
}
else
{
MovementManager.StartDescending();
}
}
else
{
Actionmanager.Dismount();
}
await Wait(interval, () => !Core.Player.IsMounted);
}
if (dismountTicks > maxTicks)
{
Logger.Instance.Error("Failed to dismount.");
return(false);
}
return(true);
}
private async Task <bool> FumaShuriken()
{
if (Ultima.UltSettings.NinjaFumaShuriken ||
Core.Player.ClassLevel < MySpells.Raiton.Level)
{
if (Actionmanager.CanCast(MySpells.Ten.ID, Core.Player) &&
DataManager.GetSpellData(2240).Cooldown.TotalMilliseconds >= 1000 &&
Core.Player.HasTarget &&
Core.Player.CurrentTarget.Type == GameObjectType.BattleNpc &&
Core.Player.CurrentTarget.InLineOfSight() &&
Core.Player.Distance(Core.Player.CurrentTarget) <= 25 ||
Core.Player.HasAura("Mudra"))
{
if (Ultima.LastSpell.ID != MySpells.Ten.ID &&
Ultima.LastSpell.ID != MySpells.Chi.ID &&
Ultima.LastSpell.ID != MySpells.Jin.ID)
{
if (await MySpells.Ten.Cast())
{
await Coroutine.Wait(2000, () => Actionmanager.CanCast(MySpells.Ten.ID, Core.Player));
}
}
if (Ultima.LastSpell.ID == MySpells.Ten.ID)
{
if (await MySpells.FumaShuriken.Cast())
{
await Coroutine.Wait(2000, () => !Core.Player.HasAura("Mudra"));
return(true);
}
}
}
}
return(false);
}
private async Task <bool> ShadowFlare()
{
if (!Core.Player.HasAura(MySpells.ShadowFlare.Name, true, 4000) &&
Core.Player.CurrentTarget.HasAura(MySpells.Bio.Name, true, 4000))
{
if (Actionmanager.CanCast(MySpells.RuinII.Name, Core.Player.CurrentTarget) &&
Actionmanager.CanCast(MySpells.CrossClass.Swiftcast.Name, Core.Player))
{
if (await MySpells.RuinII.Cast())
{
await Coroutine.Wait(5000, () => Actionmanager.CanCast(MySpells.CrossClass.Swiftcast.Name, Core.Player));
}
}
if (Actionmanager.CanCast(MySpells.CrossClass.Swiftcast.Name, Core.Player))
{
if (await MySpells.CrossClass.Swiftcast.Cast())
{
await Coroutine.Wait(5000, () => Actionmanager.CanCast(MySpells.ShadowFlare.Name, Core.Player.CurrentTarget) &&
Core.Player.HasAura(MySpells.CrossClass.Swiftcast.Name));
}
}
if (await MySpells.ShadowFlare.Cast())
{
await Coroutine.Wait(3000, () => Core.Player.HasAura(MySpells.ShadowFlare.Name));
}
return(true);
}
return(false);
}
private async Task <bool> Thundercloud()
{
if (Core.Player.HasAura("Thundercloud"))
{
if (!UmbralAura)
{
if (Ultima.LastSpell.Name == MySpells.Fire.Name ||
Ultima.LastSpell.Name == MySpells.FireII.Name ||
!Core.Player.HasAura("Thundercloud", false, 5000))
{
if (!Actionmanager.HasSpell(MySpells.ThunderIII.Name))
{
return(await MySpells.ThunderII.Cast());
}
return(await MySpells.ThunderIII.Cast());
}
}
if (UmbralAura)
{
Spell.RecentSpell.RemoveAll(t => DateTime.UtcNow > t);
if (!RecentThunder)
{
if (!Actionmanager.HasSpell(MySpells.ThunderIII.Name))
{
return(await MySpells.ThunderII.Cast());
}
return(await MySpells.ThunderIII.Cast());
}
}
}
return(false);
}
private async Task <bool> Flare()
{
if (Actionmanager.HasSpell(MySpells.Flare.Name) &&
AstralAura &&
Actionmanager.CanCast(MySpells.Convert.Name, Core.Player))
{
if (Core.Player.CurrentMana <= 904 ||
Ultima.LastSpell.Name == MySpells.FireII.Name &&
Core.Player.CurrentMana <= 1116)
{
if (Actionmanager.CanCast(MySpells.Swiftcast.Name, Core.Player) ||
Core.Player.HasAura(MySpells.Swiftcast.Name))
{
if (await MySpells.Swiftcast.Cast())
{
await Coroutine.Wait(3000, () => Actionmanager.CanCast(MySpells.Flare.Name, Core.Player.CurrentTarget));
}
if (await MySpells.Flare.Cast())
{
await Coroutine.Wait(3000, () => Actionmanager.CanCast(MySpells.Convert.Name, Core.Player));
}
if (await MySpells.Convert.Cast())
{
await Coroutine.Wait(3000, () => !Actionmanager.CanCast(MySpells.Convert.Name, Core.Player));
}
return(true);
}
}
}
return(false);
}
private async Task <bool> RuinII()
{
if (MovementManager.IsMoving)
{
return(await MySpells.RuinII.Cast());
}
if (Core.Player.CurrentManaPercent > 40)
{
if (Actionmanager.CanCast(MySpells.Aetherflow.Name, Core.Player) &&
!Core.Player.HasAura(MySpells.Aetherflow.Name) ||
Actionmanager.CanCast(MySpells.EnergyDrain.Name, Core.Player.CurrentTarget) &&
Core.Player.CurrentManaPercent <= 90 &&
Helpers.EnemiesNearTarget(8) <= 1 &&
Ultima.UltSettings.SmartTarget ||
Actionmanager.CanCast(MySpells.EnergyDrain.Name, Core.Player.CurrentTarget) &&
Core.Player.CurrentManaPercent <= 90 &&
Ultima.UltSettings.SingleTarget ||
Actionmanager.CanCast(MySpells.Bane.Name, Core.Player.CurrentTarget) &&
!Ultima.UltSettings.SingleTarget &&
Helpers.EnemiesNearTarget(8) > 1 &&
Core.Player.CurrentTarget.HasAura(MySpells.BioII.Name, true, 8000) &&
Core.Player.CurrentTarget.HasAura(MySpells.Miasma.Name, true, 8000) &&
Core.Player.CurrentTarget.HasAura(MySpells.Bio.Name, true, 5000) ||
Actionmanager.CanCast(MySpells.Rouse.Name, Core.Player))
{
return(await MySpells.RuinII.Cast());
}
}
return(false);
}
private async Task <bool> Transpose()
{
if (AstralAura)
{
if (!Core.Player.InCombat &&
LowMP)
{
return(await MySpells.Transpose.Cast());
}
}
if (UmbralAura &&
Core.Player.HasAura("Firestarter"))
{
if (Ultima.LastSpell.Name == MySpells.Scathe.Name &&
Core.Player.CurrentManaPercent != 100)
{
await Coroutine.Wait(5000, () => Core.Player.CurrentManaPercent == 100 ||
MovementManager.IsMoving);
}
if (Core.Player.CurrentManaPercent == 100)
{
return(await MySpells.Transpose.Cast());
}
}
if (!Actionmanager.HasSpell(MySpells.BlizzardIII.Name) &&
LowMP)
{
return(await MySpells.Transpose.Cast());
}
return(false);
}
private async Task <bool> Thunder()
{
if (UmbralAura &&
Core.Player.CurrentManaPercent < 100)
{
if (!Actionmanager.HasSpell(MySpells.BlizzardIII.Name) &&
!Core.Player.CurrentTarget.HasAura("Thunder", true, 3000))
{
return(await MySpells.Thunder.Cast());
}
Spell.RecentSpell.RemoveAll(t => DateTime.UtcNow > t);
if (!RecentThunder)
{
return(await MySpells.Thunder.Cast());
}
}
if (!AstralAura &&
!UmbralAura)
{
if (!Actionmanager.HasSpell(MySpells.ThunderII.Name) &&
!Core.Player.CurrentTarget.HasAura("Thunder", true))
{
return(await MySpells.Thunder.Cast());
}
}
return(false);
}
private async Task <bool> Raise()
{
if (Ultima.UltSettings.ConjurerRaise &&
!Helpers.HealManager.Any(hm => hm.CurrentHealthPercent <= 70))
{
var target = Helpers.PartyMembers.FirstOrDefault(pm =>
pm.IsDead &&
pm.Type == GameObjectType.Pc &&
!pm.HasAura(MySpells.Raise.Name));
if (target != null &&
Actionmanager.CanCast(MySpells.Raise.Name, target))
{
if (Actionmanager.CanCast(MySpells.CrossClass.Swiftcast.Name, Core.Player))
{
if (await MySpells.CrossClass.Swiftcast.Cast())
{
await Coroutine.Wait(3000, () => Actionmanager.CanCast(MySpells.Raise.Name, target) &&
Core.Player.HasAura(MySpells.CrossClass.Swiftcast.Name));
}
}
return(await MySpells.Raise.Cast(target));
}
}
return(false);
}
private async Task <bool> PowerSurge()
{
if (Ultima.UltSettings.DragoonPowerSurge &&
Actionmanager.CanCast(MySpells.Jump.Name, Core.Player.CurrentTarget))
{
return(await MySpells.PowerSurge.Cast());
}
return(false);
}
private async Task <bool> Barrage()
{
if (!Actionmanager.HasSpell(MySpells.EmpyrealArrow.Name) &&
DataManager.GetSpellData(97).Cooldown.TotalMilliseconds <= 1000)
{
return(await MySpells.Barrage.Cast());
}
return(false);
}
private async Task <bool> Enkindle()
{
if (!Actionmanager.CanCast(MySpells.Rouse.Name, Core.Player) &&
!Actionmanager.CanCast(MySpells.Spur.Name, Core.Player))
{
return(await MySpells.Enkindle.Cast());
}
return(false);
}
private async Task <bool> Ninjutsu()
{
if (Actionmanager.CanCast(MySpells.Ten.ID, Core.Player) &&
Core.Player.HasAura("Mudra"))
{
return(await MySpells.Ninjutsu.Cast());
}
return(false);
}
private async Task <bool> ImpulseDrive()
{
if (Actionmanager.HasSpell(MySpells.Disembowel.Name) &&
!Core.Player.CurrentTarget.HasAura(MySpells.Disembowel.Name, false, 5000) ||
Actionmanager.HasSpell(MySpells.ChaosThrust.Name) &&
!Core.Player.CurrentTarget.HasAura(MySpells.ChaosThrust.Name, true, 5000))
{
return(await MySpells.ImpulseDrive.Cast());
}
return(false);
}
public override async Task <bool> ExecuteRotation(ExGatherTag tag)
{
if (Core.Player.CurrentGP > 399)
{
await Wait();
Actionmanager.DoAction(293U, Core.Player);
}
return(await base.ExecuteRotation(tag));
}
public static Composite SprintMove(ValueRetriever <Vector3> location)
{
var move = CommonBehaviors.MoveAndStop(location, 1f, true);
var sprint = new Decorator(req => CanSprint,
new Action(r =>
{
Actionmanager.Sprint();
return(RunStatus.Failure);
}));
return(new PrioritySelector(sprint, move));
}
private async Task <bool> Mutilate()
{
if (!Actionmanager.HasSpell(MySpells.ShadowFang.Name) ||
Core.Player.CurrentTarget.HasAura(MySpells.ShadowFang.Name, true, 4000))
{
if (!Core.Player.CurrentTarget.HasAura("Mutilation", true, 4000))
{
return(await MySpells.Mutilate.Cast());
}
}
return(false);
}
private async Task <bool> HawksEye()
{
if (Core.Player.HasAura(MySpells.CrossClass.BloodForBlood.Name))
{
return(await MySpells.HawksEye.Cast());
}
if (!Actionmanager.HasSpell(MySpells.CrossClass.BloodForBlood.Name))
{
return(await MySpells.HawksEye.Cast());
}
return(false);
}
private async Task <bool> AeolianEdge()
{
if (Actionmanager.LastSpell.Name == MySpells.GustSlash.Name)
{
if (await MySpells.Duality.Cast())
{
await Coroutine.Wait(3000, () => Actionmanager.CanCast(MySpells.AeolianEdge.Name, Core.Player.CurrentTarget));
}
return(await MySpells.AeolianEdge.Cast());
}
return(false);
}
private async Task <bool> KissOfTheWasp()
{
if (Ultima.UltSettings.RogueKissOfTheWasp ||
!Actionmanager.HasSpell(MySpells.KissOfTheViper.Name))
{
if (!Core.Player.HasAura(MySpells.KissOfTheWasp.Name))
{
return(await MySpells.KissOfTheWasp.Cast());
}
}
return(false);
}
private async Task <bool> Swiftcast()
{
if (AstralAura)
{
if (!Actionmanager.CanCast(MySpells.Convert.Name, Core.Player) &&
!LowMP)
{
return(await MySpells.Swiftcast.Cast());
}
}
return(false);
}
private async Task <bool> FullThrust()
{
if (Actionmanager.LastSpell.Name == MySpells.VorpalThrust.Name)
{
if (await MySpells.LifeSurge.Cast())
{
await Coroutine.Wait(3000, () => Actionmanager.CanCast(MySpells.FullThrust.Name, Core.Player.CurrentTarget));
}
return(await MySpells.FullThrust.Cast());
}
return(false);
}
private async Task <bool> SwordOath()
{
if (Ultima.UltSettings.PaladinSwordOath ||
!Actionmanager.HasSpell(MySpells.ShieldOath.Name))
{
if (!Core.Player.HasAura(MySpells.SwordOath.Name))
{
return(await MySpells.SwordOath.Cast());
}
}
return(false);
}
protected Composite Behavior()
{
return(new PrioritySelector(
new Decorator(ret => Condition != null && !ConditionCheck(),
new Action(ret => _done = true)),
new Decorator(ret => QuestId != 0 && StepId != 0 && QuestLogManager.GetQuestById(QuestId).Step > StepId,
new Action(r =>
{
_done = true;
})
),
new Decorator(ret => Core.Player.IsMounted,
CommonBehaviors.Dismount()
),
new Decorator(ret => Talk.DialogOpen,
new Action(r =>
{
Talk.Next();
})
),
new Decorator(ret => casted,
new Sequence(
new Sleep(3, 5),
new Action(r => casted = false)
)
),
new Decorator(ret => Core.Me.Location.Distance(Position) <= Distance && IsFinished,
new Action(ret => _done = true)),
new Decorator(ret => Core.Me.Location.Distance(Position) <= Distance && !casted,
new Action(r =>
{
Navigator.PlayerMover.MoveStop();
if (!Core.Player.IsCasting)
{
GameObjectManager.GetObjectByNPCId(NPC).Face();
if (Actionmanager.DoAction(SpellID, GameObjectManager.GetObjectByNPCId(NPC)))
{
Actionmanager.DoAction(SpellID, GameObjectManager.GetObjectByNPCId(NPC));
casted = true;
}
else
{
Actionmanager.DoActionLocation(SpellID, Core.Player.Location);
casted = true;
}
}
})
),
CommonBehaviors.MoveAndStop(ret => Position, Distance, stopInRange: true, destinationName: Name),
new ActionAlwaysSucceed()
));
}
