fix: changed from count to animationLockTime.

RotationSolver.Basic/Actions/BaseAction_ActionInfo.cs

@@ -32,7 +32,7 @@ private bool WillCooldown
                         && ChoiceTarget != TargetFilter.FindTargetForMoving
                         && DataCenter.LastAction == (ActionID)AdjustedID) return false;
 
-                    if (!WillHaveOneCharge(DataCenter.AbilityRemain, false)) return false;
+                    if (!WillHaveOneCharge(DataCenter.ActionRemain, false)) return false;
                 }
             }
 

RotationSolver.Basic/Actions/BaseAction_Cooldown.cs

@@ -4,11 +4,11 @@ namespace RotationSolver.Basic.Actions;
 
 public partial class BaseAction
 {
-    public bool ElapsedOneChargeAfterGCD(uint gcdCount = 0, int abilityCount = 0)
+    public bool ElapsedOneChargeAfterGCD(uint gcdCount = 0, float offset = 0)
     {
         if (!IsCoolingDown) return false;
         var elapsed = RecastTimeElapsedOneCharge;
-        return CooldownHelper.ElapsedAfterGCD(elapsed, gcdCount, abilityCount);
+        return CooldownHelper.ElapsedAfterGCD(elapsed, gcdCount, offset);
     }
 
     public bool ElapsedOneChargeAfter(float time)
@@ -18,11 +18,11 @@ public bool ElapsedOneChargeAfter(float time)
         return CooldownHelper.ElapsedAfter(elapsed, time);
     }
 
-    public bool ElapsedAfterGCD(uint gcdCount = 0, int abilityCount = 0)
+    public bool ElapsedAfterGCD(uint gcdCount = 0, float offset = 0)
     {
         if (!IsCoolingDown) return false;
         var elapsed = RecastTimeElapsed;
-        return CooldownHelper.ElapsedAfterGCD(elapsed, gcdCount, abilityCount);
+        return CooldownHelper.ElapsedAfterGCD(elapsed, gcdCount, offset);
     }
 
     public bool ElapsedAfter(float time)
@@ -33,11 +33,11 @@ public bool ElapsedAfter(float time)
     }
 
 
-    public bool WillHaveOneChargeGCD(uint gcdCount = 0, int abilityCount = 0)
+    public bool WillHaveOneChargeGCD(uint gcdCount = 0, float offset = 0)
     {
         if (HasOneCharge) return true;
         var recast = RecastTimeRemainOneCharge;
-        return CooldownHelper.RecastAfterGCD(recast, gcdCount, abilityCount);
+        return CooldownHelper.RecastAfterGCD(recast, gcdCount, offset);
     }
 
     public bool WillHaveOneCharge(float remain) => WillHaveOneCharge(remain, true);

RotationSolver.Basic/Actions/BaseItem.cs

@@ -87,7 +87,8 @@ public unsafe bool CanUse(out IAction item)
 
         var remain = RecastTimeOneCharge - RecastTimeElapsed;
 
-        if (CooldownHelper.RecastAfter(DataCenter.AbilityRemain, remain, false)) return false;
+        if (CooldownHelper.RecastAfter((float)(DataCenter.NextActionTime - DateTime.Now).TotalSeconds,
+            remain, false)) return false;
 
         if (OtherCheck != null && !OtherCheck()) return false;
 

RotationSolver.Basic/Actions/IBaseAction.cs

@@ -78,12 +78,12 @@ public interface IBaseAction : IAction
         bool HasOneCharge { get; }
 
         /// <summary>
-        /// Has it been in cooldown for <paramref name="gcdCount"/> gcds and <paramref name="abilityCount"/> abilities?
+        /// Has it been in cooldown for <paramref name="gcdCount"/> gcds and <paramref name="offset"/> abilities?
         /// </summary>
         /// <param name="gcdCount"></param>
-        /// <param name="abilityCount"></param>
+        /// <param name="offset"></param>
         /// <returns></returns>
-        bool ElapsedOneChargeAfterGCD(uint gcdCount = 0, int abilityCount = 0);
+        bool ElapsedOneChargeAfterGCD(uint gcdCount = 0, float offset = 0);
 
         /// <summary>
         /// Has it been in cooldown for <paramref name="time"/> seconds?
@@ -93,12 +93,12 @@ public interface IBaseAction : IAction
         bool ElapsedOneChargeAfter(float time);
 
         /// <summary>
-        /// Has it been in cooldown for <paramref name="gcdCount"/> gcds and <paramref name="abilityCount"/> abilities?
+        /// Has it been in cooldown for <paramref name="gcdCount"/> gcds and <paramref name="offset"/> abilities?
         /// </summary>
         /// <param name="gcdCount"></param>
-        /// <param name="abilityCount"></param>
+        /// <param name="offset"></param>
         /// <returns></returns>
-        bool ElapsedAfterGCD(uint gcdCount = 0, int abilityCount = 0);
+        bool ElapsedAfterGCD(uint gcdCount = 0, float offset = 0);
 
         /// <summary>
         /// Has it been in cooldown for <paramref name="time"/> seconds?
@@ -108,12 +108,12 @@ public interface IBaseAction : IAction
         bool ElapsedAfter(float time);
 
         /// <summary>
-        /// Will have at least one charge after <paramref name="gcdCount"/> gcds and <paramref name="abilityCount"/> abilities?
+        /// Will have at least one charge after <paramref name="gcdCount"/> gcds and <paramref name="offset"/> abilities?
         /// </summary>
         /// <param name="gcdCount"></param>
-        /// <param name="abilityCount"></param>
+        /// <param name="offset"></param>
         /// <returns></returns>
-        bool WillHaveOneChargeGCD(uint gcdCount = 0, int abilityCount = 0);
+        bool WillHaveOneChargeGCD(uint gcdCount = 0, float offset = 0);
 
         /// <summary>
         /// Will have at least one charge after <paramref name="remain"/> seconds?

RotationSolver.Basic/Configuration/PluginConfiguration.cs

@@ -107,7 +107,7 @@ public class PluginConfiguration : IPluginConfiguration
 
     public bool InterruptibleMoreCheck = true;
     public float SpecialDuration = 3;
-    public float AbilitiesInterval = 0.67f;
+
     public float ActionAhead = 0.08f;
     public float ActionAheadForLast0GCD = 0.06f;
 

RotationSolver.Basic/DataCenter.cs

@@ -129,9 +129,26 @@ public static unsafe ushort FateId
 
     public static float WeaponElapsed { get; set; }
 
-    public static byte AbilityRemainCount { get; set; }
+    /// <summary>
+    /// Time to the next action
+    /// </summary>
+    public static float ActionRemain => (float)(NextActionTime - DateTime.Now).TotalSeconds;
 
-    public static float AbilityRemain { get; set; }
+    public static float AbilityRemain
+    {
+        get
+        {
+            var gcdRemain = WeaponRemain;
+            var remain = (float)(NextActionTime - DateTime.Now).TotalSeconds;
+            if ((gcdRemain - 0.6f - Ping).IsLessThan(remain))
+            {
+                return gcdRemain + 0.6f + Ping;
+            }
+            return remain;
+        }
+    }
+
+    public static float NextAbilityToNextGCD => WeaponRemain - ActionRemain;
 
     public static float CastingTotal { get; set; }
     #endregion

RotationSolver.Basic/Helpers/CooldownHelper.cs

@@ -2,20 +2,19 @@
 
 public static class CooldownHelper
 {
-    private static float WeaponRemain(uint gcdCount = 0, int abilityCount = 0)
-        => WeaponTime(gcdCount, abilityCount) + DataCenter.WeaponRemain;
+    private static float WeaponRemain(uint gcdCount = 0, float offset = 0)
+        => WeaponTime(gcdCount, offset) + DataCenter.WeaponRemain;
 
-    private static float WeaponElapsed(uint gcdCount = 0, int abilityCount = 0)
-        => WeaponTime(gcdCount, abilityCount) + DataCenter.WeaponElapsed;
+    private static float WeaponElapsed(uint gcdCount = 0, float offset = 0)
+        => WeaponTime(gcdCount, offset) + DataCenter.WeaponElapsed;
 
 
-    private static float WeaponTime(uint gcdCount = 0, int abilityCount = 0)
-        => DataCenter.WeaponTotal * gcdCount
-        + Service.Config.AbilitiesInterval * abilityCount;
+    private static float WeaponTime(uint gcdCount = 0, float offset = 0)
+        => DataCenter.WeaponTotal * gcdCount + offset;
 
-    internal static bool ElapsedAfterGCD(float elapsed, uint gcdCount = 0, int abilityCount = 0)
+    internal static bool ElapsedAfterGCD(float elapsed, uint gcdCount = 0, float offset = 0)
     {
-        var gcdElapsed = WeaponElapsed(gcdCount, abilityCount);
+        var gcdElapsed = WeaponElapsed(gcdCount, offset);
 
         return gcdElapsed.IsLessThan(elapsed);
     }
@@ -26,9 +25,9 @@ internal static bool ElapsedAfter(float elapsed, float gcdElapsed)
         return gcdElapsed.IsLessThan(elapsed);
     }
 
-    public static bool RecastAfterGCD(float recast, uint gcdCount = 0, int abilityCount = 0)
+    public static bool RecastAfterGCD(float recast, uint gcdCount = 0, float offset = 0)
     {
-        var remain = WeaponRemain(gcdCount, abilityCount);
+        var remain = WeaponRemain(gcdCount, offset);
 
         return recast.IsLessThan(remain);
     }

RotationSolver.Basic/Helpers/StatusHelper.cs

@@ -45,20 +45,20 @@ internal record Burst2MinsInfo( StatusID status, bool isOnHostile, byte level, p
     public static bool NeedHealing(this BattleChara p) => p.WillStatusEndGCD(2, 0, false, NoNeedHealingStatus);
 
     /// <summary>
-    /// Will any of <paramref name="statusIDs"/> be end after <paramref name="gcdCount"/> gcds and <paramref name="abilityCount"/> abilities?
+    /// Will any of <paramref name="statusIDs"/> be end after <paramref name="gcdCount"/> gcds add <paramref name="offset" times/> ?
     /// </summary>
     /// <param name="obj"></param>
     /// <param name="gcdCount"></param>
-    /// <param name="abilityCount"></param>
+    /// <param name="offset"></param>
     /// <param name="isFromSelf"></param>
     /// <param name="statusIDs"></param>
     /// <returns></returns>
-    public static bool WillStatusEndGCD(this BattleChara obj, uint gcdCount = 0, int abilityCount = 0, bool isFromSelf = true, params StatusID[] statusIDs)
+    public static bool WillStatusEndGCD(this BattleChara obj, uint gcdCount = 0, float offset = 0, bool isFromSelf = true, params StatusID[] statusIDs)
     {
         var remain = obj.StatusTime(isFromSelf, statusIDs);
         //as infinite
         if (remain < 0 && obj.HasStatus(isFromSelf, statusIDs)) return false;
-        return CooldownHelper.RecastAfterGCD(remain, gcdCount, abilityCount);
+        return CooldownHelper.RecastAfterGCD(remain, gcdCount, offset);
     }
 
 

RotationSolver.Basic/Rotations/Basic/BLM_Base.cs

@@ -91,7 +91,7 @@ public override bool CanUse(out IAction act, CanUseOption option = CanUseOption.
 
     public static IBaseAction Thunder2 { get; } = new ThunderAction(ActionID.Thunder2);
 
-    public static IBaseAction Transpose { get; } = new BaseAction(ActionID.Transpose) { ActionCheck = b => DataCenter.AbilityRemain.IsLessThan(JobGauge.ElementTimeRemaining / 1000f) };
+    public static IBaseAction Transpose { get; } = new BaseAction(ActionID.Transpose) { ActionCheck = b => DataCenter.ActionRemain.IsLessThan(JobGauge.ElementTimeRemaining / 1000f) };
 
     public static IBaseAction UmbralSoul { get; } = new BaseAction(ActionID.UmbralSoul) { ActionCheck = b => JobGauge.InUmbralIce && Transpose.ActionCheck(b) };
 
@@ -190,7 +190,7 @@ protected sealed override bool DefenseSingleGCD(out IAction act)
     }
 
     [RotationDesc(ActionID.Addle)]
-    protected override bool DefenseAreaAbility(byte abilitiesRemaining, out IAction act)
+    protected override bool DefenseAreaAbility(float nextAbilityToNextGCD, out IAction act)
     {
         if (Addle.CanUse(out act)) return true;
         return false;

RotationSolver.Basic/Rotations/Basic/BRD_Base.cs

@@ -114,25 +114,25 @@ protected static bool SongEndAfterGCD(uint gctCount = 0, int abilityCount = 0)
             StatusID.ShieldSamba),
     };
 
-    protected override bool EmergencyAbility(byte abilityRemain, IAction nextGCD, out IAction act)
+    protected override bool EmergencyAbility(float nextAbilityToNextGCD, IAction nextGCD, out IAction act)
     {
         //Esuna
         if (DataCenter.SpecialType == SpecialCommandType.EsunaStanceNorth && DataCenter.WeakenPeople.Any() || DataCenter.DyingPeople.Any())
         {
             if (WardensPaean.CanUse(out act, CanUseOption.MustUse)) return true;
         }
-        return base.EmergencyAbility(abilityRemain, nextGCD, out act);
+        return base.EmergencyAbility(nextAbilityToNextGCD, nextGCD, out act);
     }
 
     [RotationDesc(ActionID.Troubadour)]
-    protected sealed override bool DefenseAreaAbility(byte abilitiesRemaining, out IAction act)
+    protected sealed override bool DefenseAreaAbility(float nextAbilityToNextGCD, out IAction act)
     {
         if (Troubadour.CanUse(out act)) return true;
         return false;
     }
 
     [RotationDesc(ActionID.NaturesMinne)]
-    protected sealed override bool HealSingleAbility(byte abilitiesRemaining, out IAction act)
+    protected sealed override bool HealSingleAbility(float nextAbilityToNextGCD, out IAction act)
     {
         if (NaturesMinne.CanUse(out act)) return true;
         return false;

RotationSolver.Basic/Rotations/Basic/DNC_Base.cs

@@ -201,22 +201,22 @@ protected static bool ExecuteStepGCD(out IAction act)
     }
 
     [RotationDesc(ActionID.EnAvant)]
-    protected sealed override bool MoveForwardAbility(byte abilitiesRemaining, out IAction act, CanUseOption option = CanUseOption.None)
+    protected sealed override bool MoveForwardAbility(float nextAbilityToNextGCD, out IAction act, CanUseOption option = CanUseOption.None)
     {
         if (EnAvant.CanUse(out act, CanUseOption.EmptyOrSkipCombo | option)) return true;
         return false;
     }
 
     [RotationDesc(ActionID.CuringWaltz, ActionID.Improvisation)]
-    protected sealed override bool HealAreaAbility(byte abilitiesRemaining, out IAction act)
+    protected sealed override bool HealAreaAbility(float nextAbilityToNextGCD, out IAction act)
     {
         if (CuringWaltz.CanUse(out act, CanUseOption.EmptyOrSkipCombo)) return true;
         if (Improvisation.CanUse(out act, CanUseOption.EmptyOrSkipCombo)) return true;
         return false;
     }
 
     [RotationDesc(ActionID.ShieldSamba)]
-    protected sealed override bool DefenseAreaAbility(byte abilitiesRemaining, out IAction act)
+    protected sealed override bool DefenseAreaAbility(float nextAbilityToNextGCD, out IAction act)
     {
         if (ShieldSamba.CanUse(out act, CanUseOption.EmptyOrSkipCombo)) return true;
         return false;

RotationSolver.Basic/Rotations/Basic/DRG_Base.cs

@@ -114,7 +114,7 @@ public abstract class DRG_Base : CustomRotation
     public static IBaseAction BattleLitany { get; } = new BaseAction(ActionID.BattleLitany, ActionOption.Buff);
 
     [RotationDesc(ActionID.Feint)]
-    protected sealed override bool DefenseAreaAbility(byte abilitiesRemaining, out IAction act)
+    protected sealed override bool DefenseAreaAbility(float nextAbilityToNextGCD, out IAction act)
     {
         if (Feint.CanUse(out act)) return true;
         return false;

RotationSolver.Basic/Rotations/Basic/DRK_Base.cs

@@ -113,14 +113,14 @@ protected static bool DarkSideEndAfterGCD(uint gctCount = 0, int abilityCount =
         StatusNeed = new[] { StatusID.SaltedEarth },
     };
 
-    protected override bool EmergencyAbility(byte abilitiesRemaining, IAction nextGCD, out IAction act)
+    protected override bool EmergencyAbility(float nextAbilityToNextGCD, IAction nextGCD, out IAction act)
     {
         if (LivingDead.CanUse(out act) && BaseAction.TankBreakOtherCheck(JobIDs[0])) return true;
-        return base.EmergencyAbility(abilitiesRemaining, nextGCD, out act);
+        return base.EmergencyAbility(nextAbilityToNextGCD, nextGCD, out act);
     }
 
     [RotationDesc(ActionID.Plunge)]
-    protected sealed override bool MoveForwardAbility(byte abilitiesRemaining, out IAction act, CanUseOption option = CanUseOption.None)
+    protected sealed override bool MoveForwardAbility(float nextAbilityToNextGCD, out IAction act, CanUseOption option = CanUseOption.None)
     {
         if (Plunge.CanUse(out act, CanUseOption.EmptyOrSkipCombo | option)) return true;
 

RotationSolver.Basic/Rotations/Basic/GNB_Base.cs

@@ -136,14 +136,14 @@ public abstract class GNB_Base : CustomRotation
         == ActionID.Hypervelocity,
     };
 
-    protected override bool EmergencyAbility(byte abilitiesRemaining, IAction nextGCD, out IAction act)
+    protected override bool EmergencyAbility(float nextAbilityToNextGCD, IAction nextGCD, out IAction act)
     {
         if (SuperBolide.CanUse(out act) && BaseAction.TankBreakOtherCheck(JobIDs[0])) return true;
-        return base.EmergencyAbility(abilitiesRemaining, nextGCD, out act);
+        return base.EmergencyAbility(nextAbilityToNextGCD, nextGCD, out act);
     }
 
     [RotationDesc(ActionID.RoughDivide)]
-    protected sealed override bool MoveForwardAbility(byte abilitiesRemaining, out IAction act, CanUseOption option = CanUseOption.None)
+    protected sealed override bool MoveForwardAbility(float nextAbilityToNextGCD, out IAction act, CanUseOption option = CanUseOption.None)
     {
         if (RoughDivide.CanUse(out act, CanUseOption.EmptyOrSkipCombo | option)) return true;
         return false;

RotationSolver.Basic/Rotations/Basic/MCH_Base.cs

@@ -96,7 +96,7 @@ protected static bool OverheatedEndAfterGCD(uint gctCount = 0, int abilityCount
     public static IBaseAction Dismantle { get; } = new BaseAction(ActionID.Dismantle, ActionOption.Defense);
 
     [RotationDesc(ActionID.Tactician, ActionID.Dismantle)]
-    protected sealed override bool DefenseAreaAbility(byte abilitiesRemaining, out IAction act)
+    protected sealed override bool DefenseAreaAbility(float nextAbilityToNextGCD, out IAction act)
     {
         if (Tactician.CanUse(out act, CanUseOption.MustUse)) return true;
         if (Dismantle.CanUse(out act, CanUseOption.MustUse)) return true;

RotationSolver.Basic/Rotations/Basic/MNK_Base.cs

@@ -94,28 +94,28 @@ public abstract class MNK_Base : CustomRotation
     public static IBaseAction RiddleOfWind { get; } = new BaseAction(ActionID.RiddleOfWind, ActionOption.Buff);
 
     [RotationDesc(ActionID.Thunderclap)]
-    protected sealed override bool MoveForwardAbility(byte abilitiesRemaining, out IAction act, CanUseOption option = CanUseOption.None)
+    protected sealed override bool MoveForwardAbility(float nextAbilityToNextGCD, out IAction act, CanUseOption option = CanUseOption.None)
     {
         if (Thunderclap.CanUse(out act, CanUseOption.EmptyOrSkipCombo | option)) return true;
         return false;
     }
 
     [RotationDesc(ActionID.Feint)]
-    protected sealed override bool DefenseAreaAbility(byte abilitiesRemaining, out IAction act)
+    protected sealed override bool DefenseAreaAbility(float nextAbilityToNextGCD, out IAction act)
     {
         if (Feint.CanUse(out act)) return true;
         return false;
     }
 
     [RotationDesc(ActionID.Mantra)]
-    protected sealed override bool HealAreaAbility(byte abilitiesRemaining, out IAction act)
+    protected sealed override bool HealAreaAbility(float nextAbilityToNextGCD, out IAction act)
     {
         if (Mantra.CanUse(out act)) return true;
         return false;
     }
 
     [RotationDesc(ActionID.RiddleOfEarth)]
-    protected sealed override bool DefenseSingleAbility(byte abilitiesRemaining, out IAction act)
+    protected sealed override bool DefenseSingleAbility(float nextAbilityToNextGCD, out IAction act)
     {
         if (RiddleOfEarth.CanUse(out act, CanUseOption.EmptyOrSkipCombo)) return true;
         return false;

RotationSolver.Basic/Rotations/Basic/NIN_Base.cs

@@ -168,22 +168,22 @@ internal NinAction(ActionID actionID, params IBaseAction[] ninjutsu)
     public static INinAction HyoshoRanryu { get; } = new NinAction(ActionID.HyoshoRanryu, Ten, Jin);
 
     [RotationDesc(ActionID.Shukuchi)]
-    protected sealed override bool MoveForwardAbility(byte abilitiesRemaining, out IAction act, CanUseOption option = CanUseOption.None)
+    protected sealed override bool MoveForwardAbility(float nextAbilityToNextGCD, out IAction act, CanUseOption option = CanUseOption.None)
     {
         if (Shukuchi.CanUse(out act, CanUseOption.EmptyOrSkipCombo | option)) return true;
 
         return false;
     }
 
     [RotationDesc(ActionID.Feint)]
-    protected sealed override bool DefenseAreaAbility(byte abilitiesRemaining, out IAction act)
+    protected sealed override bool DefenseAreaAbility(float nextAbilityToNextGCD, out IAction act)
     {
         if (Feint.CanUse(out act)) return true;
         return false;
     }
 
     [RotationDesc(ActionID.ShadeShift)]
-    protected override bool DefenseSingleAbility(byte abilitiesRemaining, out IAction act)
+    protected override bool DefenseSingleAbility(float nextAbilityToNextGCD, out IAction act)
     {
         if (ShadeShift.CanUse(out act)) return true;