Merge pull request #968 from FFXIV-CombatReborn/DTRfixes

LTS-FFXIV · web-flow · commit 6b43d6f8bb52 · 2025-08-23T00:13:03.000-05:00
Refactor DTR handling and added new /rotation Cycle command
diff --git a/RotationSolver.Basic/Configuration/Configs.cs b/RotationSolver.Basic/Configuration/Configs.cs
@@ -125,6 +125,9 @@ public const string
     Filter = UiInformation)]
     private static readonly bool _showInfoOnDtr = true;
 
+    [UI("DTR Behaviour", Filter = UiInformation, Parent = nameof(ShowInfoOnDtr))]
+    public DTRType DTRType { get; set; } = DTRType.DTRNormal;
+
     [ConditionBool, UI("Display plugin status in toast popup",
     Description = "Show a toast notification with the combat state when changed.",
     Filter = UiInformation)]
@@ -872,14 +875,11 @@ public const string
         Filter = TargetConfig)]
     private static readonly bool _bigHP = false;
 
-    [ConditionBool, UI("Change clicking the DTR bar behaviour to cycle between Off and Manual (Overrides below option).",
-        Filter = TargetConfig)]
-    private static readonly bool _dtrManual = false;
-
-    [ConditionBool, UI("Change clicking the DTR bar behaviour to cycle through each Target Type selected.",
-        Filter = TargetConfig)]
-    private static readonly bool _dtrCycle = false;
+    [UI("/rotation Cycle behaviour", Filter = TargetConfig)]
+    public CycleType CycleType { get; set; } = CycleType.CycleNormal;
 
+    [JobConfig, UI("Engage settings", Filter = TargetConfig, PvPFilter = JobFilterType.NoJob)]
+    private readonly TargetHostileType _hostileType = TargetHostileType.AllTargetsWhenSoloInDuty;
     #endregion
 
     #region Integer
@@ -1014,9 +1014,6 @@ public const string
         PvEFilter = JobFilterType.Tank)]
     private readonly float _healthForAutoDefense = 1;
 
-    [JobConfig, UI("Engage settings", Filter = TargetConfig, PvPFilter = JobFilterType.NoJob)]
-    private readonly TargetHostileType _hostileType = TargetHostileType.AllTargetsWhenSoloInDuty;
-
     [JobConfig]
     private readonly string _PvPRotationChoice = string.Empty;
 
diff --git a/RotationSolver.Basic/Data/CycleType.cs b/RotationSolver.Basic/Data/CycleType.cs
@@ -0,0 +1,31 @@
+﻿namespace RotationSolver.Basic.Data;
+
+/// <summary>
+/// Hostile target.
+/// </summary>
+public enum CycleType : byte
+{
+    /// <summary>
+    /// Cycle between first Auto, Manual, and Off
+    /// </summary>
+    [Description("Cycle between first Auto, Manual, and Off")]
+    CycleNormal,
+
+    /// <summary>
+    /// Cycle between each Auto, Manual, and Off
+    /// </summary>
+    [Description("Cycle between each Auto, Manual, and Off")]
+    CycleAllAuto,
+
+    /// <summary>
+    /// Cycle between Manual and Off
+    /// </summary>
+    [Description("Cycle between Manual and Off")]
+    CycleManual,
+
+    /// <summary>
+    /// Cycle between Manual and Auto
+    /// </summary>
+    [Description("Cycle between Manual and Auto")]
+    CycleManualAuto,
+}
diff --git a/RotationSolver.Basic/Data/DTRType.cs b/RotationSolver.Basic/Data/DTRType.cs
@@ -0,0 +1,31 @@
+﻿namespace RotationSolver.Basic.Data;
+
+/// <summary>
+/// Hostile target.
+/// </summary>
+public enum DTRType : byte
+{
+    /// <summary>
+    /// Cycle between first Auto, Manual, and Off
+    /// </summary>
+    [Description("Cycle between first Auto, Manual, and Off")]
+    DTRNormal,
+
+    /// <summary>
+    /// Cycle between each Auto, Manual, and Off
+    /// </summary>
+    [Description("Cycle between each Auto, Manual, and Off")]
+    DTRAllAuto,
+
+    /// <summary>
+    /// Cycle between Manual and Off
+    /// </summary>
+    [Description("Cycle between Manual and Off")]
+    DTRManual,
+
+    /// <summary>
+    /// Cycle between Manual and Auto
+    /// </summary>
+    [Description("Cycle between Manual and Auto")]
+    DTRManualAuto,
+}
diff --git a/RotationSolver.Basic/Data/RSCommandType.cs b/RotationSolver.Basic/Data/RSCommandType.cs
@@ -161,4 +161,10 @@ public enum OtherCommandType : byte
     /// </summary>
     [Description("Do the next action.")]
     NextAction,
+
+    /// <summary>
+    /// Cycles between states following settings in Target > Configuration.
+    /// </summary>
+    [Description("Cycles between states following settings in Target > Configuration.")]
+    Cycle,
 }
diff --git a/RotationSolver/Commands/RSCommands_BasicInfo.cs b/RotationSolver/Commands/RSCommands_BasicInfo.cs
@@ -28,12 +28,21 @@ internal static void Disable()
 
         private static void OnCommand(string command, string arguments)
         {
-            DoOneCommand(arguments);
+            DoOneCommand(arguments ?? string.Empty);
         }
 
         private static void DoOneCommand(string command)
         {
-            if (command.Equals("cancel", StringComparison.OrdinalIgnoreCase))
+            command = (command ?? string.Empty).Trim();
+
+            // No args => open config
+            if (command.Length == 0)
+            {
+                RotationSolverPlugin.OpenConfigWindow();
+                return;
+            }
+
+            if (string.Equals(command, "cancel", StringComparison.OrdinalIgnoreCase))
             {
                 command = "off";
             }
@@ -90,9 +99,19 @@ private static void DoOneCommand(string command)
         private static bool TryGetOneEnum<T>(string command, out T type) where T : struct, Enum
         {
             type = default;
+
+            if (string.IsNullOrWhiteSpace(command))
+            {
+                return false;
+            }
+
+            // Match only the first token exactly (case-insensitive).
+            int spaceIdx = command.IndexOf(' ');
+            string token = spaceIdx >= 0 ? command[..spaceIdx] : command;
+
             foreach (T c in Enum.GetValues<T>())
             {
-                if (command.StartsWith(c.ToString(), StringComparison.OrdinalIgnoreCase))
+                if (string.Equals(token, c.ToString(), StringComparison.OrdinalIgnoreCase))
                 {
                     type = c;
                     return true;
diff --git a/RotationSolver/Commands/RSCommands_OtherCommand.cs b/RotationSolver/Commands/RSCommands_OtherCommand.cs
@@ -13,6 +13,10 @@ public static void DoOtherCommand(OtherCommandType otherType, string str)
     {
         switch (otherType)
         {
+            case OtherCommandType.Cycle:
+                ExecuteCycleCommand();
+                break;
+
             case OtherCommandType.Rotations:
                 ExecuteRotationCommand(str);
                 break;
@@ -39,6 +43,26 @@ public static void DoOtherCommand(OtherCommandType otherType, string str)
         }
     }
 
+    private static void ExecuteCycleCommand()
+    {
+        if (Service.Config.CycleType == CycleType.CycleNormal)
+        {
+            CycleStateWithOneTargetTypes();
+        }
+        else if (Service.Config.CycleType == CycleType.CycleAllAuto)
+        {
+            CycleStateWithAllTargetTypes();
+        }
+        else if (Service.Config.CycleType == CycleType.CycleManual)
+        {
+            CycleStateManual();
+        }
+        else if (Service.Config.CycleType == CycleType.CycleManualAuto)
+        {
+            CycleStateManualAuto();
+        }
+    }
+
     private static void ExecuteRotationCommand(string str)
     {
         ICustomRotation? customCombo = DataCenter.CurrentRotation;
diff --git a/RotationSolver/Commands/RSCommands_StateSpecialCommand.cs b/RotationSolver/Commands/RSCommands_StateSpecialCommand.cs
@@ -80,6 +80,125 @@ private static StateCommandType AdjustStateType(StateCommandType stateType, ref
             return stateType;
         }
 
+        public static void CycleStateManualAuto()
+        {
+            // If currently Off, go to Manual
+            if (!DataCenter.State)
+            {
+                DoStateCommandType(StateCommandType.Manual);
+                return;
+            }
+
+            // If currently in Manual mode, turn Off
+            if (DataCenter.IsManual)
+            {
+                DoStateCommandType(StateCommandType.Auto);
+                return;
+            }
+
+            // If currently On but not Manual, switch to Manual
+            DoStateCommandType(StateCommandType.Manual);
+        }
+
+        public static void CycleStateManual()
+        {
+            // If currently Off, go to Manual
+            if (!DataCenter.State)
+            {
+                DoStateCommandType(StateCommandType.Manual);
+                return;
+            }
+
+            // If currently in Manual mode, turn Off
+            if (DataCenter.IsManual)
+            {
+                DoStateCommandType(StateCommandType.Off);
+                return;
+            }
+
+            // If currently On but not Manual, switch to Manual
+            DoStateCommandType(StateCommandType.Manual);
+        }
+
+        public static void CycleStateWithAllTargetTypes()
+        {
+            // If currently Off, start with the first TargetType
+            if (!DataCenter.State)
+            {
+                if (Service.Config.TargetingTypes.Count > 0)
+                {
+                    Service.Config.TargetingIndex = 0;
+                    DoStateCommandType(StateCommandType.Auto, 0);
+                }
+                else
+                {
+                    // No targeting types configured, go to Manual
+                    DoStateCommandType(StateCommandType.Manual);
+                }
+                return;
+            }
+
+            // If currently in Auto mode, cycle through all TargetTypes
+            if (DataCenter.State && !DataCenter.IsManual)
+            {
+                int nextIndex = Service.Config.TargetingIndex + 1;
+
+                // If we've gone through all TargetTypes, switch to Manual
+                if (nextIndex >= Service.Config.TargetingTypes.Count)
+                {
+                    DoStateCommandType(StateCommandType.Manual);
+                }
+                else
+                {
+                    // Move to next TargetType
+                    Service.Config.TargetingIndex = nextIndex;
+                    DoStateCommandType(StateCommandType.Auto, nextIndex);
+                }
+                return;
+            }
+
+            // If currently in Manual mode, turn off
+            if (DataCenter.State && DataCenter.IsManual)
+            {
+                DoStateCommandType(StateCommandType.Off);
+                return;
+            }
+        }
+
+        public static void CycleStateWithOneTargetTypes()
+        {
+            // If currently Off, go to Auto using the highest TargetingIndex (last configured type)
+            if (!DataCenter.State)
+            {
+                if (Service.Config.TargetingTypes.Count > 0)
+                {
+                    int lastIdx = Service.Config.TargetingTypes.Count - Service.Config.TargetingTypes.Count;
+                    Service.Config.TargetingIndex = lastIdx;
+                    DoStateCommandType(StateCommandType.Auto, lastIdx);
+                }
+                else
+                {
+                    // No targeting types configured, go to Manual
+                    DoStateCommandType(StateCommandType.Manual);
+                }
+                return;
+            }
+
+            // If currently in Auto mode, switch to Manual
+            if (DataCenter.State && !DataCenter.IsManual)
+            {
+                DoStateCommandType(StateCommandType.Manual);
+                return;
+            }
+
+            // If currently in Manual mode, turn Off
+            if (DataCenter.State && DataCenter.IsManual)
+            {
+                DoStateCommandType(StateCommandType.Off);
+                return;
+            }
+        }
+
         private static void UpdateTargetingIndex(ref int index)
         {
             if (index == -1)
diff --git a/RotationSolver/UI/RotationConfigWindow.cs b/RotationSolver/UI/RotationConfigWindow.cs
@@ -1105,6 +1105,8 @@ private static void DrawAboutMacros()
         DisplayCommandHelp(StateCommandType.Auto);
         DisplayCommandHelp(StateCommandType.Manual);
         DisplayCommandHelp(StateCommandType.Off);
+        DisplayCommandHelp(OtherCommandType.Cycle);
+        ImGui.NewLine();
 
         // Display command help for other commands
         DisplayCommandHelp(OtherCommandType.NextAction);
diff --git a/RotationSolver/Updaters/MiscUpdater.cs b/RotationSolver/Updaters/MiscUpdater.cs

Original file line number	Diff line number	Diff line change
`@@ -28,12 +28,21 @@ internal static void Disable()`
`28`	`28`
`29`	`29`	`private static void OnCommand(string command, string arguments)`
`30`	`30`	`{`
`31`		`- DoOneCommand(arguments);`
	`31`	`+ DoOneCommand(arguments ?? string.Empty);`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`private static void DoOneCommand(string command)`
`35`	`35`	`{`
`36`		`- if (command.Equals("cancel", StringComparison.OrdinalIgnoreCase))`
	`36`	`+ command = (command ?? string.Empty).Trim();`
	`37`	`+`
	`38`	`+ // No args => open config`
	`39`	`+ if (command.Length == 0)`
	`40`	`+ {`
	`41`	`+ RotationSolverPlugin.OpenConfigWindow();`
	`42`	`+ return;`
	`43`	`+ }`
	`44`	`+`
	`45`	`+ if (string.Equals(command, "cancel", StringComparison.OrdinalIgnoreCase))`
`37`	`46`	`{`
`38`	`47`	`command = "off";`
`39`	`48`	`}`
`@@ -90,9 +99,19 @@ private static void DoOneCommand(string command)`
`90`	`99`	`private static bool TryGetOneEnum<T>(string command, out T type) where T : struct, Enum`
`91`	`100`	`{`
`92`	`101`	`type = default;`
	`102`	`+`
	`103`	`+ if (string.IsNullOrWhiteSpace(command))`
	`104`	`+ {`
	`105`	`+ return false;`
	`106`	`+ }`
	`107`	`+`
	`108`	`+ // Match only the first token exactly (case-insensitive).`
	`109`	`+ int spaceIdx = command.IndexOf(' ');`
	`110`	`+ string token = spaceIdx >= 0 ? command[..spaceIdx] : command;`
	`111`	`+`
`93`	`112`	`foreach (T c in Enum.GetValues<T>())`
`94`	`113`	`{`
`95`		`- if (command.StartsWith(c.ToString(), StringComparison.OrdinalIgnoreCase))`
	`114`	`+ if (string.Equals(token, c.ToString(), StringComparison.OrdinalIgnoreCase))`
`96`	`115`	`{`
`97`	`116`	`type = c;`
`98`	`117`	`return true;`