Added a tail mean calculation in full parties for healing thresholds.

Added heal GCD spell interruption if going over thresholds.

Author: TheDeadCode

RotationSolver.Basic/Configuration/Configs.cs

@@ -315,6 +315,12 @@ public const string
     [ConditionBool, UI("Automatic Healing Thresholds", Filter = HealingActionCondition, Section = 1, Order = 1)]
     private static readonly bool _autoHeal = true;
 
+    /// <markdown file="Auto" name="Stop Healing Cast After Reaching Threshold" section="Healing Usage and Control" isSubsection="1">
+    /// When enabled, you can customize the healing thresholds for when healing will be cast occur on target(s).
+    /// </markdown>
+    [ConditionBool, UI("Stop healing after reaching threshold. (Experimental)", Filter = HealingActionCondition, Section = 1, Order = 2, Description = "If you have another healer on the team, their healing might put the target player(s) above the healing threshold and you'll waste MP. This interrupts the cast if it happens.")]
+    private static readonly bool _stopHealingAfterThresholdExperimental = false;
+
     /// <markdown file="Auto" name="Auto-use oGCD abilities" section="Action Usage and Control" isSubsection="1">
     /// Whether to use oGCD abilities or not at all.
     /// </markdown>

RotationSolver.Basic/DataCenter.cs

@@ -715,6 +715,8 @@ private static float GetPartyMemberHPRatio(IBattleChara member)
     private static float _partyAvgHp = 0;
     private static float _partyStdDevHp = 0;
     private static int _partyHpCount = 0;
+    private static float _lowestPartyAvgHp = 0;
+    private static float _lowestPartyStdDevHp = 0;
 
     private static readonly float[] _hpBuffer = new float[8];
     private static void UpdatePartyHpCache()
@@ -746,28 +748,47 @@ private static void UpdatePartyHpCache()
             _partyMinHp = 0;
             _partyAvgHp = 0;
             _partyStdDevHp = 0;
+            _lowestPartyAvgHp = 0;
+            _lowestPartyStdDevHp = 0;
             return;
         }
 
+        // If there are more than 4 players, we order the array
+        if (hpCount > 4)
+        {
+            Array.Sort(_hpBuffer);
+        }
+
         float sum = 0;
+        float lowestHpMembersSum = 0;
         float min = float.MaxValue;
         for (int i = 0; i < hpCount; i++)
         {
             sum += _hpBuffer[i];
+            if (i < 4) lowestHpMembersSum += _hpBuffer[i];
             if (_hpBuffer[i] < min) min = _hpBuffer[i];
         }
 
         float avg = sum / hpCount;
+        float lowestHpMembersAvg = lowestHpMembersSum / (hpCount > 4 ? 4 : hpCount);
         float variance = 0;
+        float lowestHpMembersVariance = 0;
         for (int i = 0; i < hpCount; i++)
         {
             float diff = _hpBuffer[i] - avg;
             variance += diff * diff;
+            if (i < 4)
+            {
+                float lowestHpMembersDiff = _hpBuffer[i] - lowestHpMembersAvg;
+                lowestHpMembersVariance += lowestHpMembersDiff * lowestHpMembersDiff;
+            }
         }
 
         _partyMinHp = min;
         _partyAvgHp = avg;
         _partyStdDevHp = (float)Math.Sqrt(variance / hpCount);
+        _lowestPartyAvgHp = lowestHpMembersAvg;
+        _lowestPartyStdDevHp = (float)Math.Sqrt(lowestHpMembersVariance / (hpCount > 4 ? 4 : hpCount));
         _partyHpCacheFrame = currentFrame;
     }
 
@@ -786,6 +807,16 @@ public static float PartyMembersDifferHP
         get { UpdatePartyHpCache(); return _partyStdDevHp; }
     }
 
+    public static float LowestPartyMembersAverHP
+    {
+        get { UpdatePartyHpCache(); return _lowestPartyAvgHp; }
+    }
+
+    public static float LowestPartyMembersDifferHP
+    {
+        get { UpdatePartyHpCache(); return _lowestPartyStdDevHp; }
+    }
+
     public static IEnumerable<float> PartyMembersHP
     {
         get

RotationSolver.Basic/Helpers/IActionHelper.cs

@@ -21,6 +21,43 @@ public static class IActionHelper
         //ActionID.SpineshatterDivePvE,
         ActionID.DragonfireDivePvE,
     };
+    
+    internal static ActionID[] HealingActions { get; } =
+    {
+        // AST
+        ActionID.BeneficIiPvE,
+        ActionID.BeneficPvE,
+        ActionID.BeneficPvE_21608,
+        ActionID.HeliosConjunctionPvE,
+        ActionID.HeliosPvE,
+        ActionID.AspectedHeliosPvE,
+            
+        // SGE
+        ActionID.DiagnosisPvE,
+        ActionID.DiagnosisPvE_26224,
+        ActionID.PrognosisPvE,
+        ActionID.PrognosisPvE_27043,
+        ActionID.PneumaPvE,
+        ActionID.PneumaPvE,
+            
+        // WHM
+        ActionID.CurePvE,
+        ActionID.CureIiPvE,
+        ActionID.CureIiPvE_21886,
+        ActionID.MedicaPvE,
+        ActionID.MedicaIiPvE,
+        ActionID.MedicaIiPvE_21888,
+        ActionID.MedicaIiiPvE,
+        ActionID.CureIiiPvE,
+            
+        // SCH
+        ActionID.AdloquiumPvE,
+        ActionID.SuccorPvE,
+        ActionID.ConcitationPvE,
+        ActionID.PhysickPvE,
+        ActionID.PhysickPvE_11192,
+        ActionID.PhysickPvE_16230
+    };
 
     /// <summary>
     /// Determines if the last GCD action matches any of the provided actions.
@@ -127,6 +164,27 @@ public static bool IsTheSameTo(this IAction action, bool isAdjust, params Action
         return action != null && actions != null && IsActionID(isAdjust ? (ActionID)action.AdjustedID : (ActionID)action.ID, actions);
     }
 
+    /// <summary>
+    /// Searches the provided list of lists for an action ID.
+    /// </summary>
+    /// <param name="id">The action ID</param>
+    /// <param name="isAdjust">Whether to use the AdjustedID parameter</param>
+    /// <param name="lists">The list of lists of actions to search from.</param>
+    /// <returns></returns>
+    public static IAction? GetActionFromID(this ActionID id, bool isAdjust, params IAction[][] lists)
+    {
+        foreach (var list in lists)
+        {
+            foreach (var action in list)
+            {
+                if ((isAdjust && action.AdjustedID == (uint)id) ||
+                    (! isAdjust && action.ID == (uint)id)) return action;
+            }
+        }
+
+        return null;
+    }
+
     /// <summary>
     /// Determines if the action ID matches any of the provided action IDs.
     /// </summary>

RotationSolver/UI/RotationConfigWindow.cs

@@ -3439,6 +3439,7 @@ private static unsafe void DrawParty()
         ImGui.Text($"Number of Party Members: {DataCenter.PartyMembers.Count}");
         ImGui.Text($"Number of Alliance Members: {DataCenter.AllianceMembers.Count}");
         ImGui.Text($"Average Party HP Percent: {DataCenter.PartyMembersAverHP * 100}");
+        ImGui.Text($"Average Lowest Party HP Percent: {DataCenter.LowestPartyMembersAverHP * 100}");
         ImGui.Text($"Number of Party Members with Doomed To Heal status: {DataCenter.PartyMembers.Count(member => member.DoomNeedHealing())}");
         foreach (Dalamud.Game.ClientState.Party.IPartyMember p in Svc.Party)
         {

RotationSolver/Updaters/ActionQueueManager.cs

@@ -75,38 +75,16 @@ private static unsafe bool UseActionDetour(ActionManager* actionManager, uint ac
                             var dutyActions = DataCenter.CurrentDutyRotation?.AllActions ?? [];
 
                             // Find matching action by ID without creating intermediate collections
-                            IAction? matchingAction = null;
                             uint adjustedActionId = Service.GetAdjustedActionId(actionID);
 
                             PluginLog.Debug($"[ActionQueueManager] Detected player input: (ID: {actionID})");
 
-                            // Search rotation actions first
-                            foreach (var action in rotationActions)
-                            {                                
-                                if (action.ID == adjustedActionId)
-                                {
-                                    matchingAction = action;
-                                    break;
-                                }
-                            }
-
-                            // If not found, search duty actions
-                            if (matchingAction == null)
-                            {
-                                foreach (var action in dutyActions)
-                                {
-                                    if (action.ID == adjustedActionId)
-                                    {
-                                        matchingAction = action;
-                                        break;
-                                    }
-                                }
-                            }
-
-                            PluginLog.Debug($"[ActionQueueManager] Matching action decided: (ID: {matchingAction})");
+                            var matchingAction = ((ActionID)adjustedActionId).GetActionFromID(false, rotationActions, dutyActions);
 
                             if (matchingAction != null)
                             {
+                                PluginLog.Debug($"[ActionQueueManager] Matching action decided: (ID: {matchingAction})");
+                                
                                 if (matchingAction.IsIntercepted)
                                 {
                                     if (matchingAction.EnoughLevel && CanInterceptAction(matchingAction))

RotationSolver/Updaters/MiscUpdater.cs

@@ -4,7 +4,6 @@
 using ECommons.DalamudServices;
 using ECommons.ExcelServices;
 using ECommons.GameHelpers;
-using FFXIVClientStructs.FFXIV.Client.Game;
 using FFXIVClientStructs.FFXIV.Client.Game.UI;
 using FFXIVClientStructs.FFXIV.Client.System.Framework;
 using FFXIVClientStructs.FFXIV.Client.UI;
@@ -217,8 +216,13 @@ private static unsafe void UpdateCancelCast()
         }
 
         bool stopDueStatus = statusTimes.Length > 0 && minStatusTime > Player.Object.TotalCastTime - Player.Object.CurrentCastTime && minStatusTime < 5;
-
-        if (_tarStopCastDelay.Delay(tarDead) || stopDueStatus || tarHasRaise)
+        
+        bool shouldStopHealing = Service.Config.StopHealingAfterThresholdExperimental && DataCenter.InCombat &&
+                                 DataCenter.CommandNextAction?.AdjustedID != Player.Object.CastActionId &&
+                                 ((ActionID)Player.Object.CastActionId).GetActionFromID(true, RotationUpdater.CurrentRotationActions) is IBaseAction {Setting.IsFriendly: true} && 
+                                 (DataCenter.MergedStatus & (AutoStatus.HealAreaSpell | AutoStatus.HealSingleSpell)) == 0;
+        
+        if (_tarStopCastDelay.Delay(tarDead) || stopDueStatus || tarHasRaise || shouldStopHealing)
         {
             UIState* uiState = UIState.Instance();
             if (uiState != null)

RotationSolver/Updaters/StateUpdater.cs

@@ -246,8 +246,18 @@ private static bool ShouldAddHealAreaAbility()
 
             if (!canHealAreaAbility)
             {
-                canHealAreaAbility = DataCenter.PartyMembersDifferHP < Service.Config.HealthDifference
-                && DataCenter.PartyMembersAverHP < Lerp(Service.Config.HealthAreaAbility, Service.Config.HealthAreaAbilityHot, ratio);
+                // If party is larger than 4 people, we select the 4 lowest HP players
+                // in the party, and then calculate the thresholds on them instead.
+                if (DataCenter.PartyMembers.Count > 4)
+                {
+                    canHealAreaAbility = DataCenter.LowestPartyMembersDifferHP < Service.Config.HealthDifference
+                                         && DataCenter.LowestPartyMembersAverHP < Lerp(Service.Config.HealthAreaAbility, Service.Config.HealthAreaAbilityHot, ratio);
+                }
+                else
+                {
+                    canHealAreaAbility = DataCenter.PartyMembersDifferHP < Service.Config.HealthDifference
+                                         && DataCenter.PartyMembersAverHP < Lerp(Service.Config.HealthAreaAbility, Service.Config.HealthAreaAbilityHot, ratio);
+                }
             }
         }