v1.0.3.0: Alliance frames fixes, PvP support, shared hotbar persistence, config save on teleport

Co-authored-by: Cursor <cursoragent@cursor.com>

Config/ConfigurationManager.cs

@@ -154,6 +154,7 @@ namespace HSUI.Config
             CheckVersion();
 
             Plugin.ClientState.Logout += OnLogout;
+            Plugin.ClientState.TerritoryChanged += OnTerritoryChanged;
             Plugin.JobChangedEvent += OnJobChanged;
 
             _configBaseNode.CreateNodesIfNeeded();
@@ -179,6 +180,7 @@ namespace HSUI.Config
 
             ConfigBaseNode.ConfigObjectResetEvent -= OnConfigObjectReset;
             Plugin.ClientState.Logout -= OnLogout;
+            Plugin.ClientState.TerritoryChanged -= OnTerritoryChanged;
             Plugin.JobChangedEvent -= OnJobChanged;
 
             Instance = null!;
@@ -197,6 +199,13 @@ namespace HSUI.Config
             ProfilesManager.Instance?.SaveCurrentProfile();
         }
 
+        private void OnTerritoryChanged(ushort territoryId)
+        {
+            // Persist config on teleport/zone change so changes aren't lost during loading screens
+            if (ConfigBaseNode.NeedsSave)
+                SaveConfigurations();
+        }
+
         private void OnJobChanged(uint jobId)
         {
             UpdateCurrentProfile();
@@ -602,6 +611,16 @@ namespace HSUI.Config
 
             // Party Frames
             typeof(PartyFramesConfig),
+            typeof(AllianceFramesHealthBarsConfig),
+            typeof(AllianceFramesManaBarConfig),
+            typeof(AllianceFramesCastbarConfig),
+            typeof(AllianceFramesIconsConfig),
+            typeof(AllianceFramesBuffsConfig),
+            typeof(AllianceFramesDebuffsConfig),
+            typeof(AllianceFramesTrackersConfig),
+            typeof(AllianceFramesCooldownListConfig),
+            typeof(AllianceFrames1Config),
+            typeof(AllianceFrames2Config),
             typeof(PartyFramesHealthBarsConfig),
             typeof(PartyFramesManaBarConfig),
             typeof(PartyFramesCastbarConfig),

Config/Tree/ConfigPageNode.cs

@@ -290,16 +290,26 @@ namespace HSUI.Config.Tree
             Type type = ConfigObject.GetType();
             ImportData? importData = ProfilesManager.Instance?.DefaultImportData(type);
 
-            if (importData == null)
+            PluginConfigObject? config = null;
+            if (importData != null)
             {
-                Plugin.Logger.Error("Error finding default import data for type " + type.ToString());
-                return;
+                config = importData.GetObject();
             }
 
-            PluginConfigObject? config = importData.GetObject();
             if (config == null)
             {
-                Plugin.Logger.Error("Error importing default import data for type " + type.ToString());
+                // Fallback: invoke static DefaultConfig() when no import data (e.g. new config types not yet in Default.HSUI)
+                MethodInfo? defaultConfigMethod = type.GetMethod("DefaultConfig", BindingFlags.Public | BindingFlags.Static);
+                if (defaultConfigMethod != null && defaultConfigMethod.ReturnType != typeof(void))
+                {
+                    object? result = defaultConfigMethod.Invoke(null, null);
+                    config = result as PluginConfigObject;
+                }
+            }
+
+            if (config == null)
+            {
+                Plugin.Logger.Error("Error resetting config for type " + type.ToString() + " (no import data and no DefaultConfig)");
                 return;
             }
 

HSUI.csproj

@@ -9,9 +9,9 @@
 
 	<PropertyGroup>
 		<AssemblyName>HSUI</AssemblyName>
-		<AssemblyVersion>1.0.2.9</AssemblyVersion>
-		<FileVersion>1.0.2.9</FileVersion>
-		<InformationalVersion>1.0.2.9</InformationalVersion>
+		<AssemblyVersion>1.0.3.0</AssemblyVersion>
+		<FileVersion>1.0.3.0</FileVersion>
+		<InformationalVersion>1.0.3.0</InformationalVersion>
 	</PropertyGroup>
 
 	<PropertyGroup>

HSUI.json

@@ -2,7 +2,7 @@
   "Author": "Knack117",
   "Name": "HSUI",
   "InternalName": "HSUI",
-  "AssemblyVersion": "1.0.2.9",
+  "AssemblyVersion": "1.0.3.0",
   "Description": "HSUI provides a highly configurable HUD replacement for FFXIV, recreated from DelvUI using KamiToolKit, FFXIVClientStructs, and Dalamud. Features unit frames, castbars, job gauges, nameplates, party frames, status effects, enemy list, configurable hotbars with drag-and-drop, and profiles.",
   "ApplicableVersion": "any",
   "RepoUrl": "https://github.com/Knack117/HSUI",

Helpers/ActionBarsManager.cs

@@ -274,8 +274,8 @@ namespace HSUI.Helpers
             slotPtrB->LoadIconId();
             if (typeA == RaptureHotbarModule.HotbarSlotType.Item)
                 slotPtrB->LoadCostDataForSlot(true);
-            module->SetAndSaveSlot((uint)(barA - 1), (uint)a, typeB, idB);
-            module->SetAndSaveSlot((uint)(barB - 1), (uint)b, typeA, idA);
+            SetAndSaveSlotInternal(module, (uint)(barA - 1), (uint)a, typeB, idB, slotPtrA);
+            SetAndSaveSlotInternal(module, (uint)(barB - 1), (uint)b, typeA, idA, slotPtrB);
 
             // Read back to verify
             slotPtrA = module->GetSlotById((uint)(barA - 1), (uint)a);
@@ -509,8 +509,21 @@ namespace HSUI.Helpers
                 slotPtr->Set(RaptureHotbarModule.HotbarSlotType.Empty, 0);
                 slotPtr->LoadIconId();
             }
-            module->SetAndSaveSlot((uint)barIdx, (uint)slot, RaptureHotbarModule.HotbarSlotType.Empty, 0);
+            SetAndSaveSlotInternal(module, (uint)barIdx, (uint)slot, RaptureHotbarModule.HotbarSlotType.Empty, 0, slotPtr);
             return true;
         }
+
+        /// <summary>Sets a slot and persists to disk. For shared hotbars, explicitly writes to classJobId 0 to ensure persistence across job changes and teleports.</summary>
+        public static unsafe void SetAndSaveSlotInternal(RaptureHotbarModule* module, uint barId, uint slotId, RaptureHotbarModule.HotbarSlotType slotType, uint commandId, RaptureHotbarModule.HotbarSlot* slotPtr = null)
+        {
+            var ptr = slotPtr != null ? slotPtr : module->GetSlotById(barId, slotId);
+            if (module->IsHotbarShared(barId) && ptr != null)
+            {
+                // Shared hotbars: explicitly write to classJobId 0 (shared storage) for correct persistence across teleports/job changes
+                module->WriteSavedSlot(0, barId, slotId, ptr, false, false);
+            }
+            // SetAndSaveSlot triggers file save; for shared bars also ensures save is queued (WriteSavedSlot may only update _savedHotbars)
+            module->SetAndSaveSlot(barId, slotId, slotType, commandId, ignoreSharedHotbars: false, allowSaveToPvP: true);
+        }
     }
 }

Interface/GeneralElements/ActionBarsHud.cs

@@ -725,7 +725,7 @@ namespace HSUI.Interface.GeneralElements
                                     displaySlot->Set(slotType, id);
                                     displaySlot->LoadIconId();
                                 }
-                                module->SetAndSaveSlot(barId, (uint)idx, slotType, id);
+                                ActionBarsManager.SetAndSaveSlotInternal(module, barId, (uint)idx, slotType, id, displaySlot);
                                 try { dm->CancelDragDrop(true, true); }
                                 catch (Exception ex2) { Plugin.Logger.Warning($"[HSUI DragDrop] CancelDragDrop: {ex2.Message}"); }
 

Interface/HudHelper.cs

@@ -244,6 +244,11 @@ namespace HSUI.Interface
             if (partyFrames?.Enabled == true)
                 AddElements(ElementKind.PartyList);
 
+            var alliance1 = ConfigurationManager.Instance?.GetConfigObject<AllianceFrames1Config>();
+            var alliance2 = ConfigurationManager.Instance?.GetConfigObject<AllianceFrames2Config>();
+            if ((alliance1?.Enabled == true || alliance2?.Enabled == true))
+                AddElements(ElementKind.AllianceList1, ElementKind.AllianceList2);
+
             var enemyList = ConfigurationManager.Instance?.GetConfigObject<EnemyListConfig>();
             if (enemyList?.Enabled == true)
                 AddElements(ElementKind.EnemyList);

Interface/HudManager.cs

@@ -247,6 +247,16 @@ namespace HSUI.Interface
             _hudElements.Add(partyFramesConfig, partyFramesHud);
             _hudElementsWithPreview.Add(partyFramesHud);
 
+            var allianceFrames1Config = ConfigurationManager.Instance.GetConfigObject<AllianceFrames1Config>();
+            var allianceFrames1Hud = new AllianceFramesHud(allianceFrames1Config, "Alliance Frames 1");
+            _hudElements.Add(allianceFrames1Config, allianceFrames1Hud);
+            _hudElementsWithPreview.Add(allianceFrames1Hud);
+
+            var allianceFrames2Config = ConfigurationManager.Instance.GetConfigObject<AllianceFrames2Config>();
+            var allianceFrames2Hud = new AllianceFramesHud(allianceFrames2Config, "Alliance Frames 2");
+            _hudElements.Add(allianceFrames2Config, allianceFrames2Hud);
+            _hudElementsWithPreview.Add(allianceFrames2Hud);
+
             var enemyListConfig = ConfigurationManager.Instance.GetConfigObject<EnemyListConfig>();
             var enemyListHud = new EnemyListHud(enemyListConfig, "Enemy List");
             _hudElements.Add(enemyListConfig, enemyListHud);

Interface/Party/AllianceFramesConfig.cs

@@ -0,0 +1,253 @@
+using HSUI.Config;
+using HSUI.Config.Attributes;
+using HSUI.Enums;
+using HSUI.Helpers;
+using HSUI.Interface.Bars;
+using HSUI.Interface.GeneralElements;
+using HSUI.Interface.StatusEffects;
+using Dalamud.Bindings.ImGui;
+using System.Numerics;
+
+namespace HSUI.Interface.Party
+{
+    [Exportable(false)]
+    [Disableable(false)]
+    [DisableParentSettings("Position", "Anchor", "BackgroundColor", "FillColor", "HideWhenInactive", "DrawBorder", "BorderColor", "BorderThickness")]
+    [Section("Alliance Frames", true)]
+    [SubSection("Health Bar", 0)]
+    public class AllianceFramesHealthBarsConfig : PartyFramesHealthBarsConfig
+    {
+        public new static AllianceFramesHealthBarsConfig DefaultConfig()
+        {
+            var config = new AllianceFramesHealthBarsConfig(Vector2.Zero, new(100, 22), PluginConfigColor.Empty);
+            config.MouseoverAreaConfig.Enabled = false;
+            config.Padding = new Vector2(2, 1);
+            config.ShowLabels = false;
+            config.NameLabelConfig.Enabled = false;
+            config.HealthLabelConfig.Enabled = false;
+            config.OrderNumberConfig.Enabled = false;
+            return config;
+        }
+
+        public AllianceFramesHealthBarsConfig(Vector2 position, Vector2 size, PluginConfigColor fillColor, BarDirection fillDirection = BarDirection.Right)
+            : base(position, size, fillColor, fillDirection)
+        {
+        }
+    }
+
+    [Exportable(false)]
+    [Section("Alliance Frames", true)]
+    [SubSection("Mana Bar", 0)]
+    public class AllianceFramesManaBarConfig : PartyFramesManaBarConfig
+    {
+        public new static AllianceFramesManaBarConfig DefaultConfig()
+        {
+            var config = new AllianceFramesManaBarConfig(new Vector2(0, 0), new Vector2(100, 6));
+            config.Enabled = false;
+            return config;
+        }
+        public AllianceFramesManaBarConfig(Vector2 position, Vector2 size) : base(position, size) { }
+    }
+
+    [Exportable(false)]
+    [Section("Alliance Frames", true)]
+    [SubSection("Castbar", 0)]
+    public class AllianceFramesCastbarConfig : PartyFramesCastbarConfig
+    {
+        public new static AllianceFramesCastbarConfig DefaultConfig()
+        {
+            var size = new Vector2(102, 10);
+            var pos = new Vector2(-1, 0);
+            var castNameConfig = new LabelConfig(new Vector2(5, 0), "", DrawAnchor.Left, DrawAnchor.Left);
+            var castTimeConfig = new NumericLabelConfig(new Vector2(-5, 0), "", DrawAnchor.Right, DrawAnchor.Right);
+            castTimeConfig.Enabled = false;
+            castTimeConfig.NumberFormat = 1;
+            var config = new AllianceFramesCastbarConfig(pos, size, castNameConfig, castTimeConfig);
+            config.Enabled = false;
+            return config;
+        }
+        public AllianceFramesCastbarConfig(Vector2 position, Vector2 size, LabelConfig castNameConfig, NumericLabelConfig castTimeConfig)
+            : base(position, size, castNameConfig, castTimeConfig) { }
+    }
+
+    [Disableable(false)]
+    [Exportable(false)]
+    [Section("Alliance Frames", true)]
+    [SubSection("Icons", 0)]
+    public class AllianceFramesIconsConfig : PartyFramesIconsConfig
+    {
+        public new static AllianceFramesIconsConfig DefaultConfig()
+        {
+            var config = new AllianceFramesIconsConfig();
+            config.Role.Enabled = false;
+            config.Sign.Enabled = false;
+            config.Leader.Enabled = false;
+            config.PlayerStatus.Enabled = false;
+            config.ReadyCheckStatus.Icon.Enabled = false;
+            config.WhosTalking.Enabled = false;
+            return config;
+        }
+    }
+
+    [Exportable(false)]
+    [Section("Alliance Frames", true)]
+    [SubSection("Buffs", 0)]
+    public class AllianceFramesBuffsConfig : PartyFramesBuffsConfig
+    {
+        public new static AllianceFramesBuffsConfig DefaultConfig()
+        {
+            var durationConfig = new LabelConfig(new Vector2(0, -4), "", DrawAnchor.Bottom, DrawAnchor.Center);
+            var stacksConfig = new LabelConfig(new Vector2(-3, 4), "", DrawAnchor.TopRight, DrawAnchor.Center);
+            stacksConfig.Color = new(Vector4.UnitW);
+            stacksConfig.OutlineColor = new(Vector4.One);
+            var iconConfig = new StatusEffectIconConfig(durationConfig, stacksConfig);
+            iconConfig.DispellableBorderConfig.Enabled = false;
+            iconConfig.Size = new Vector2(24, 24);
+            var pos = new Vector2(-2, 2);
+            var size = new Vector2(iconConfig.Size.X * 4 + 6, iconConfig.Size.Y);
+            var config = new AllianceFramesBuffsConfig(DrawAnchor.TopRight, pos, size, true, false, false, GrowthDirections.Left | GrowthDirections.Down, iconConfig);
+            config.Limit = 4;
+            config.Enabled = false;
+            return config;
+        }
+        public AllianceFramesBuffsConfig(DrawAnchor anchor, Vector2 position, Vector2 size, bool showBuffs, bool showDebuffs, bool showPermanentEffects,
+            GrowthDirections growthDirections, StatusEffectIconConfig iconConfig)
+            : base(anchor, position, size, showBuffs, showDebuffs, showPermanentEffects, growthDirections, iconConfig) { }
+    }
+
+    [Exportable(false)]
+    [Section("Alliance Frames", true)]
+    [SubSection("Debuffs", 0)]
+    public class AllianceFramesDebuffsConfig : PartyFramesDebuffsConfig
+    {
+        public new static AllianceFramesDebuffsConfig DefaultConfig()
+        {
+            var durationConfig = new LabelConfig(new Vector2(0, -4), "", DrawAnchor.Bottom, DrawAnchor.Center);
+            var stacksConfig = new LabelConfig(new Vector2(-3, 4), "", DrawAnchor.TopRight, DrawAnchor.Center);
+            stacksConfig.Color = new(Vector4.UnitW);
+            stacksConfig.OutlineColor = new(Vector4.One);
+            var iconConfig = new StatusEffectIconConfig(durationConfig, stacksConfig);
+            iconConfig.Size = new Vector2(20, 20);
+            iconConfig.DurationLabelConfig.Enabled = false;
+            iconConfig.StacksLabelConfig.Enabled = false;
+            var pos = new Vector2(-2, -2);
+            var size = new Vector2(iconConfig.Size.X * 4 + 4, iconConfig.Size.Y);
+            var config = new AllianceFramesDebuffsConfig(DrawAnchor.BottomRight, pos, size, false, true, false, GrowthDirections.Left | GrowthDirections.Up, iconConfig);
+            config.Limit = 4;
+            return config;
+        }
+        public AllianceFramesDebuffsConfig(DrawAnchor anchor, Vector2 position, Vector2 size, bool showBuffs, bool showDebuffs, bool showPermanentEffects,
+            GrowthDirections growthDirections, StatusEffectIconConfig iconConfig)
+            : base(anchor, position, size, showBuffs, showDebuffs, showPermanentEffects, growthDirections, iconConfig) { }
+    }
+
+    [Disableable(false)]
+    [Exportable(false)]
+    [Section("Alliance Frames", true)]
+    [SubSection("Trackers", 0)]
+    public class AllianceFramesTrackersConfig : PartyFramesTrackersConfig
+    {
+        public new static AllianceFramesTrackersConfig DefaultConfig()
+        {
+            var config = new AllianceFramesTrackersConfig();
+            config.Raise.Enabled = false;
+            config.Raise.Icon.Enabled = false;
+            config.Invuln.Enabled = false;
+            config.Invuln.Icon.Enabled = false;
+            config.Cleanse.Enabled = false;
+            return config;
+        }
+    }
+
+    [Exportable(false)]
+    [Section("Alliance Frames", true)]
+    [SubSection("Cooldowns", 0)]
+    public class AllianceFramesCooldownListConfig : PartyFramesCooldownListConfig
+    {
+        public new static AllianceFramesCooldownListConfig DefaultConfig()
+        {
+            var config = new AllianceFramesCooldownListConfig();
+            config.Position = new Vector2(-2, 0);
+            config.Size = new Vector2(40 * 8 + 6, 40);
+            config.Enabled = false;
+            return config;
+        }
+    }
+
+    /// <summary>Base config for alliance frames. Slot 0 and 1 = the two alliances the player is NOT in.</summary>
+    public abstract class AllianceFramesConfigBase : MovablePluginConfigObject
+    {
+        public abstract int SlotIndex { get; }
+        public abstract string FramesLabel { get; }
+
+        [Checkbox("Preview", isMonitored = true)]
+        [Order(4)]
+        public bool Preview = false;
+
+        [DragInt("Rows", spacing = true, isMonitored = true, min = 1, max = 8, velocity = 0.2f)]
+        [Order(10)]
+        public int Rows = 4;
+
+        [DragInt("Columns", isMonitored = true, min = 1, max = 8, velocity = 0.2f)]
+        [Order(11)]
+        public int Columns = 2;
+
+        [Anchor("Bars Anchor", isMonitored = true, spacing = true)]
+        [Order(15)]
+        public DrawAnchor BarsAnchor = DrawAnchor.TopLeft;
+
+        [Checkbox("Fill Rows First", isMonitored = true)]
+        [Order(20)]
+        public bool FillRowsFirst = true;
+
+        [Checkbox("Show when not in alliance raid", help = "When enabled, shows a placeholder frame outside raids so you can position it. Disable to hide frames entirely when not in a 24-player alliance raid.")]
+        [Order(25)]
+        public bool ShowWhenNotInRaid = false;
+
+        [NestedConfig("Title Label", 60)]
+        public AllianceFramesTitleLabel TitleLabelConfig = new AllianceFramesTitleLabel(Vector2.Zero, "", DrawAnchor.Left, DrawAnchor.Left);
+
+        [NestedConfig("Visibility", 200)]
+        public VisibilityConfig VisibilityConfig = new VisibilityConfig();
+    }
+
+    [Exportable(false)]
+    [DisableParentSettings("FrameAnchor", "UseJobColor", "UseRoleColor")]
+    public class AllianceFramesTitleLabel : LabelConfig
+    {
+        public AllianceFramesTitleLabel(Vector2 position, string text, DrawAnchor frameAnchor, DrawAnchor textAnchor)
+            : base(position, text, frameAnchor, textAnchor) { }
+    }
+
+    [Exportable(false)]
+    [Section("Alliance Frames", true)]
+    [SubSection("Alliance Frames 1", 0)]
+    public class AllianceFrames1Config : AllianceFramesConfigBase
+    {
+        public override int SlotIndex => 0;
+        public override string FramesLabel => "Alliance Frames 1";
+
+        public new static AllianceFrames1Config DefaultConfig()
+        {
+            var config = new AllianceFrames1Config();
+            config.Position = new Vector2(-ImGui.GetMainViewport().Size.X / 3 - 180, -350);
+            return config;
+        }
+    }
+
+    [Exportable(false)]
+    [Section("Alliance Frames", true)]
+    [SubSection("Alliance Frames 2", 0)]
+    public class AllianceFrames2Config : AllianceFramesConfigBase
+    {
+        public override int SlotIndex => 1;
+        public override string FramesLabel => "Alliance Frames 2";
+
+        public new static AllianceFrames2Config DefaultConfig()
+        {
+            var config = new AllianceFrames2Config();
+            config.Position = new Vector2(-ImGui.GetMainViewport().Size.X / 3 - 180, -230);
+            return config;
+        }
+    }
+}

Interface/Party/AllianceFramesHud.cs

@@ -0,0 +1,285 @@
+using Dalamud.Game.ClientState.Objects.Types;
+using Dalamud.Bindings.ImGui;
+using HSUI.Config;
+using HSUI.Enums;
+using HSUI.Helpers;
+using HSUI.Interface.GeneralElements;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Numerics;
+
+namespace HSUI.Interface.Party
+{
+    public class AllianceFramesHud : DraggableHudElement, IHudElementWithMouseOver, IHudElementWithPreview, IHudElementWithVisibilityConfig
+    {
+        private AllianceFramesConfigBase Config => (AllianceFramesConfigBase)_config;
+        public VisibilityConfig VisibilityConfig => Config.VisibilityConfig;
+        private PartyFramesConfigs Configs;
+
+        private Vector2 _contentMargin = new Vector2(2, 2);
+        private static readonly int MaxMemberCount = 8;
+
+        private Vector2 _origin;
+        private LayoutInfo _layoutInfo;
+        private uint _memberCount = 0;
+        private bool _layoutDirty = true;
+
+        private readonly List<PartyFramesBar> bars;
+        private LabelHud _titleLabelHud;
+
+        public AllianceFramesHud(AllianceFramesConfigBase config, string displayName) : base(config, displayName)
+        {
+            Configs = PartyFramesConfigs.GetAllianceConfigs();
+
+            config.ValueChangeEvent += OnLayoutPropertyChanged;
+            Configs.HealthBar.ValueChangeEvent += OnLayoutPropertyChanged;
+            Configs.HealthBar.ColorsConfig.ValueChangeEvent += OnLayoutPropertyChanged;
+
+            bars = new List<PartyFramesBar>(MaxMemberCount);
+            for (int i = 0; i < bars.Capacity; i++)
+            {
+                var bar = new PartyFramesBar("HSUI_allianceFramesBar_" + Config.SlotIndex + "_" + i, Configs);
+                bars.Add(bar);
+            }
+
+            _titleLabelHud = new LabelHud(Config.TitleLabelConfig);
+
+            AllianceManager.Instance.MembersChangedEvent += OnMembersChanged;
+        }
+
+        protected override void InternalDispose()
+        {
+            foreach (var bar in bars)
+            {
+                try { bar.Dispose(); }
+                catch (Exception ex) { Plugin.Logger.Error($"Error disposing AllianceFramesBar: {ex.Message}"); }
+            }
+            bars.Clear();
+
+            _config.ValueChangeEvent -= OnLayoutPropertyChanged;
+            Configs.HealthBar.ValueChangeEvent -= OnLayoutPropertyChanged;
+            Configs.HealthBar.ColorsConfig.ValueChangeEvent -= OnLayoutPropertyChanged;
+            AllianceManager.Instance.MembersChangedEvent -= OnMembersChanged;
+        }
+
+        private void OnLayoutPropertyChanged(object sender, OnChangeBaseArgs args)
+        {
+            if (args.PropertyName == "Size" || args.PropertyName == "FillRowsFirst" ||
+                args.PropertyName == "BarsAnchor" || args.PropertyName == "Padding" ||
+                args.PropertyName == "Rows" || args.PropertyName == "Columns")
+            {
+                _layoutDirty = true;
+            }
+        }
+
+        private void OnMembersChanged(AllianceManager sender)
+        {
+            _layoutDirty = true;
+        }
+
+        private void UpdateBars(Vector2 contentStartPos)
+        {
+            var members = AllianceManager.Instance.GetMembersForOtherAlliance(Config.SlotIndex);
+            uint memberCount = (uint)members.Count;
+            uint row = 0, col = 0;
+
+            CalculateBarPosition(contentStartPos, Size, out float x, out float y);
+
+            for (int i = 0; i < bars.Count; i++)
+            {
+                var bar = bars[i];
+                if (i >= memberCount)
+                {
+                    bar.Visible = false;
+                    continue;
+                }
+
+                bar.Member = members[i];
+                bar.Visible = true;
+
+                bar.Position = new Vector2(
+                    x + Configs.HealthBar.Size.X * col + (Configs.HealthBar.Padding.X - 1) * col,
+                    y + Configs.HealthBar.Size.Y * row + (Configs.HealthBar.Padding.Y - 1) * row
+                );
+
+                if (Config.FillRowsFirst)
+                {
+                    col++;
+                    if (col >= _layoutInfo.TotalColCount) { col = 0; row++; }
+                }
+                else
+                {
+                    row++;
+                    if (row >= _layoutInfo.TotalRowCount) { row = 0; col++; }
+                }
+            }
+        }
+
+        private void UpdateBarsPosition(Vector2 delta)
+        {
+            foreach (var bar in bars)
+                bar.Position = bar.Position + delta;
+        }
+
+        private void CalculateBarPosition(Vector2 position, Vector2 spaceSize, out float x, out float y)
+        {
+            x = position.X;
+            y = position.Y;
+            if (Config.BarsAnchor == DrawAnchor.Top || Config.BarsAnchor == DrawAnchor.Center || Config.BarsAnchor == DrawAnchor.Bottom)
+                x += (spaceSize.X - _layoutInfo.ContentSize.X) / 2f;
+            else if (Config.BarsAnchor == DrawAnchor.TopRight || Config.BarsAnchor == DrawAnchor.Right || Config.BarsAnchor == DrawAnchor.BottomRight)
+                x += spaceSize.X - _layoutInfo.ContentSize.X;
+            if (Config.BarsAnchor == DrawAnchor.Left || Config.BarsAnchor == DrawAnchor.Center || Config.BarsAnchor == DrawAnchor.Right)
+                y += (spaceSize.Y - _layoutInfo.ContentSize.Y) / 2f;
+            else if (Config.BarsAnchor == DrawAnchor.BottomLeft || Config.BarsAnchor == DrawAnchor.Bottom || Config.BarsAnchor == DrawAnchor.BottomRight)
+                y += spaceSize.Y - _layoutInfo.ContentSize.Y;
+        }
+
+        private Vector2 Size => new Vector2(
+            Config.Columns * Configs.HealthBar.Size.X + (Config.Columns - 1) * Configs.HealthBar.Padding.X,
+            Config.Rows * Configs.HealthBar.Size.Y + (Config.Rows - 1) * Configs.HealthBar.Padding.Y
+        );
+
+        private void UpdateLayout(Vector2 origin)
+        {
+            var members = AllianceManager.Instance.GetMembersForOtherAlliance(Config.SlotIndex);
+            uint count = (uint)members.Count;
+            Vector2 contentStartPos = origin + Config.Position;
+
+            if (_layoutDirty || _memberCount != count)
+            {
+                _layoutInfo = LayoutHelper.CalculateLayout(
+                    Size, Configs.HealthBar.Size, count, Configs.HealthBar.Padding, Config.FillRowsFirst
+                );
+                UpdateBars(contentStartPos);
+            }
+            else if (_origin != contentStartPos)
+            {
+                UpdateBarsPosition(contentStartPos - _origin);
+            }
+
+            _layoutDirty = false;
+            _origin = contentStartPos;
+            _memberCount = count;
+        }
+
+        public void StopPreview()
+        {
+            Config.Preview = false;
+            foreach (var bar in bars)
+                bar.StopPreview();
+        }
+
+        protected override (List<Vector2>, List<Vector2>) ChildrenPositionsAndSizes()
+        {
+            return (new List<Vector2>() { Config.Position + Size / 2f }, new List<Vector2>() { Size });
+        }
+
+        public void StopMouseover()
+        {
+            foreach (var bar in bars)
+                bar.StopMouseover();
+        }
+
+        public override void DrawChildren(Vector2 origin)
+        {
+            if (!_config.Enabled)
+                return;
+
+            bool inRaid = AllianceManager.Instance.IsInAllianceRaid;
+            var members = AllianceManager.Instance.GetMembersForOtherAlliance(Config.SlotIndex);
+
+            if (!inRaid && !Config.Preview && !Config.ShowWhenNotInRaid)
+                return;
+
+            if (members.Count < 1 && !Config.Preview && !Config.ShowWhenNotInRaid)
+                return;
+
+            // Show placeholder when not in raid (for positioning) or when Preview is on
+            if ((Config.Preview || Config.ShowWhenNotInRaid) && members.Count < 1)
+            {
+                _layoutInfo = LayoutHelper.CalculateLayout(Size, Configs.HealthBar.Size, 8, Configs.HealthBar.Padding, Config.FillRowsFirst);
+                for (int i = 0; i < 8; i++)
+                {
+                    bars[i].Member = new FakePartyFramesMember(i);
+                    bars[i].Visible = true;
+                }
+                for (int i = 8; i < bars.Count; i++)
+                    bars[i].Visible = false;
+                CalculateBarPosition(origin + Config.Position, Size, out float px, out float py);
+                uint row = 0, col = 0;
+                for (int i = 0; i < 8; i++)
+                {
+                    bars[i].Position = new Vector2(
+                        px + Configs.HealthBar.Size.X * col + (Configs.HealthBar.Padding.X - 1) * col,
+                        py + Configs.HealthBar.Size.Y * row + (Configs.HealthBar.Padding.Y - 1) * row
+                    );
+                    if (Config.FillRowsFirst) { col++; if (col >= _layoutInfo.TotalColCount) { col = 0; row++; } }
+                    else { row++; if (row >= _layoutInfo.TotalRowCount) { row = 0; col++; } }
+                }
+                AddDrawAction(StrataLevel.LOWEST, () =>
+                {
+                    var drawList = ImGui.GetWindowDrawList();
+                    Vector2 bgPos = origin + Config.Position - _contentMargin;
+                    Vector2 bgSize = Size + _contentMargin * 2;
+                    drawList.AddRectFilled(bgPos, bgPos + bgSize, 0x66000000);
+                    drawList.AddRect(bgPos, bgPos + bgSize, 0x66FFFFFF);
+                });
+                for (int i = 0; i < 8; i++)
+                    AddDrawActions(bars[i].GetBarDrawActions(origin));
+                foreach (var bar in bars)
+                    AddDrawActions(bar.GetElementsDrawActions(origin));
+                Config.TitleLabelConfig.SetText(Config.FramesLabel + " (Preview)");
+                AddDrawAction(Config.TitleLabelConfig.StrataLevel, () => _titleLabelHud.Draw(origin + Config.Position));
+                return;
+            }
+
+            if (Config.Preview)
+            {
+                AddDrawAction(StrataLevel.LOWEST, () =>
+                {
+                    var drawList = ImGui.GetWindowDrawList();
+                    Vector2 bgPos = origin + Config.Position - _contentMargin;
+                    Vector2 bgSize = Size + _contentMargin * 2;
+                    drawList.AddRectFilled(bgPos, bgPos + bgSize, 0x66000000);
+                    drawList.AddRect(bgPos, bgPos + bgSize, 0x66FFFFFF);
+                });
+            }
+
+            UpdateLayout(origin);
+
+            IGameObject? target = Plugin.TargetManager.SoftTarget ?? Plugin.TargetManager.Target;
+            int targetIndex = -1;
+
+            for (int i = 0; i < members.Count; i++)
+            {
+                var member = bars[i].Member;
+                if (member != null && target != null && member.ObjectId == target.GameObjectId)
+                {
+                    targetIndex = i;
+                    continue;
+                }
+                AddDrawActions(bars[i].GetBarDrawActions(origin));
+            }
+
+            if (targetIndex >= 0)
+                AddDrawActions(bars[targetIndex].GetBarDrawActions(origin, Configs.HealthBar.ColorsConfig.TargetBordercolor));
+
+            foreach (var bar in bars)
+                AddDrawActions(bar.GetElementsDrawActions(origin));
+
+            string titleText = Config.FramesLabel;
+            if (inRaid && AllianceManager.Instance.TryGetAllianceIndexForSlot(Config.SlotIndex, out int allianceIdx)
+                && AllianceManager.Instance.TryGetAllianceLetter(allianceIdx, out string letter))
+            {
+                titleText = $"Alliance {letter}";
+            }
+            Config.TitleLabelConfig.SetText(titleText);
+            AddDrawAction(Config.TitleLabelConfig.StrataLevel, () =>
+            {
+                _titleLabelHud.Draw(origin + Config.Position);
+            });
+        }
+    }
+}

Interface/Party/AllianceManager.cs

@@ -0,0 +1,422 @@
+using Dalamud.Game.ClientState.Objects.Types;
+using HSUI.Helpers;
+using FFXIVClientStructs.FFXIV.Client.Game.Group;
+using FFXIVClientStructs.FFXIV.Client.UI.Info;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace HSUI.Interface.Party
+{
+    public delegate void AllianceMembersChangedEventHandler(AllianceManager sender);
+
+    /// <summary>
+    /// Provides member lists for Alliance A, B, and C when in 24-player raid content.
+    /// Only populated when CrossRealm has 3 groups (alliance raid).
+    /// </summary>
+    public unsafe class AllianceManager : IDisposable
+    {
+        public static AllianceManager Instance { get; private set; } = null!;
+
+        private readonly List<IPartyFramesMember>[] _allianceMembers = new List<IPartyFramesMember>[3];
+        private int[] _lastMemberCounts = new int[3];
+        private bool _wasInAllianceRaid = false;
+
+        private AllianceManager()
+        {
+            for (int i = 0; i < 3; i++)
+                _allianceMembers[i] = new List<IPartyFramesMember>();
+        }
+
+        public static void Initialize()
+        {
+            Instance = new AllianceManager();
+        }
+
+        public void Dispose()
+        {
+            for (int i = 0; i < 3; i++)
+                _allianceMembers[i].Clear();
+            Instance = null!;
+        }
+
+        /// <summary>Internal alliance index (0, 1, or 2) containing the local player, or -1 if not in alliance raid / unknown.</summary>
+        public int PlayerAllianceIndex
+        {
+            get
+            {
+                var player = Plugin.ObjectTable?.LocalPlayer;
+                if (player == null) return -1;
+                uint playerEntityId = player.EntityId;
+                ulong playerObjectId = (ulong)player.GameObjectId;
+
+                // Primary: Check our populated member lists first - most reliable (GroupManager/CrossRealm ordering may differ)
+                for (int i = 0; i < 3; i++)
+                {
+                    foreach (var m in _allianceMembers[i])
+                    {
+                        if (m.ObjectId == playerEntityId || (ulong)m.ObjectId == playerObjectId) return i;
+                        if (m.Character != null && m.Character.Address == player.Address) return i;
+                    }
+                }
+
+                // Fallback: InfoProxyCrossRealm.LocalPlayerGroupIndex (when in duty finder / cross-world before instance)
+                var info = InfoProxyCrossRealm.Instance();
+                if (info != null && info->IsInAllianceRaid && info->GroupCount >= 3)
+                {
+                    byte localIdx = info->LocalPlayerGroupIndex;
+                    if (localIdx < 3) return localIdx;
+                }
+
+                // Fallback: CrossRealm iteration
+                if (info != null && info->IsInAllianceRaid && info->GroupCount >= 3)
+                {
+                    for (int i = 0; i < 3; i++)
+                    {
+                        var group = info->CrossRealmGroups[i];
+                        for (int j = 0; j < group.GroupMemberCount; j++)
+                        {
+                            var member = group.GroupMembers[j];
+                            if (member.EntityId == playerEntityId) return i;
+                        }
+                    }
+                }
+
+                // Fallback 3: Match any of our party members - we're in the same alliance as them
+                var partyList = Plugin.PartyList;
+                if (partyList != null)
+                {
+                    for (int i = 0; i < 3; i++)
+                    {
+                        foreach (var m in _allianceMembers[i])
+                        {
+                            foreach (var pm in partyList)
+                            {
+                                if (pm != null && pm.EntityId == m.ObjectId)
+                                {
+                                    return i;
+                                }
+                            }
+                        }
+                    }
+                }
+
+                // Fallback: GroupManager - player is in MainGroup._partyMembers (their 8-man).
+                // Group layout: 0,1 = other alliances from _allianceMembers; 2 = main party from _partyMembers.
+                var gm = GroupManager.Instance();
+                if (gm != null && gm->MainGroup.IsAlliance)
+                {
+                    ref var mainGroup = ref gm->MainGroup;
+                    if (mainGroup.GetPartyMemberByEntityId(playerEntityId) != null)
+                    {
+                        return 2; // Player in main party = group 2 (our alliance)
+                    }
+                }
+
+                return -1;
+            }
+        }
+
+        /// <summary>Slot 0 = first other alliance, slot 1 = second. Excludes the player's alliance.</summary>
+        public IReadOnlyList<IPartyFramesMember> GetMembersForOtherAlliance(int slotIndex)
+        {
+            if (slotIndex < 0 || slotIndex > 1) return Array.Empty<IPartyFramesMember>();
+            if (!TryGetAllianceIndexForSlot(slotIndex, out int allianceIdx)) return Array.Empty<IPartyFramesMember>();
+            return _allianceMembers[allianceIdx].AsReadOnly();
+        }
+
+        /// <summary>Gets the alliance index (0=A, 1=B, 2=C) for the given slot. Returns false when not in raid.</summary>
+        public bool TryGetAllianceIndexForSlot(int slotIndex, out int allianceIndex)
+        {
+            allianceIndex = -1;
+            if (slotIndex < 0 || slotIndex > 1) return false;
+            int playerIdx = PlayerAllianceIndex;
+            int idx = 0;
+            for (int i = 0; i < 3; i++)
+            {
+                if (i == playerIdx) continue;
+                if (idx == slotIndex)
+                {
+                    allianceIndex = i;
+                    return true;
+                }
+                idx++;
+            }
+            return false;
+        }
+
+        /// <summary>Gets the alliance letter (A/B/C) for an internal group index. Uses member EntityId matching to CrossRealm when GroupManager/CrossRealm use different orderings.</summary>
+        public bool TryGetAllianceLetter(int allianceIndex, out string letter)
+        {
+            letter = "";
+            if (allianceIndex < 0 || allianceIndex > 2) return false;
+
+            var info = InfoProxyCrossRealm.Instance();
+            if (info != null && info->GroupCount >= 3)
+            {
+                // Get first member EntityId from our group (works for both GroupManager and CrossRealm data)
+                uint matchEntityId = 0;
+                if (_allianceMembers[allianceIndex].Count > 0)
+                    matchEntityId = _allianceMembers[allianceIndex][0].ObjectId;
+
+                // Find which CrossRealm group contains this member - they may use different ordering than GroupManager
+                for (int crIdx = 0; crIdx < 3 && matchEntityId != 0; crIdx++)
+                {
+                    var crGroup = info->CrossRealmGroups[crIdx];
+                    for (int j = 0; j < crGroup.GroupMemberCount; j++)
+                    {
+                        if (crGroup.GroupMembers[j].EntityId == matchEntityId)
+                        {
+                            byte displayIdx = crGroup.GroupMembers[j].GroupIndex;
+                            if (displayIdx < 3)
+                            {
+                                letter = ((char)('A' + displayIdx)).ToString();
+                                return true;
+                            }
+                        }
+                    }
+                }
+
+                // Direct lookup when CrossRealm index matches ours (e.g. both use same ordering)
+                var group = info->CrossRealmGroups[allianceIndex];
+                if (group.GroupMemberCount > 0)
+                {
+                    byte displayIdx = group.GroupMembers[0].GroupIndex;
+                    if (displayIdx < 3)
+                    {
+                        letter = ((char)('A' + displayIdx)).ToString();
+                        return true;
+                    }
+                }
+
+                // GetGroupIndex(displayLetter) returns internal index - find which letter maps to our index
+                for (byte d = 0; d < 3; d++)
+                {
+                    if (InfoProxyCrossRealm.GetGroupIndex(d) == allianceIndex)
+                    {
+                        letter = ((char)('A' + d)).ToString();
+                        return true;
+                    }
+                }
+            }
+
+            // Fallback when no CrossRealm data (PvP, in-instance)
+            letter = ((char)('A' + allianceIndex)).ToString();
+            return true;
+        }
+
+        /// <summary>True when in 24-player content with 3 alliances (PvE) or PvP Frontlines/Rival Wings.</summary>
+        public bool IsInAllianceRaid
+        {
+            get
+            {
+                var gm = GroupManager.Instance();
+                if (gm != null)
+                {
+                    // GroupManager: IsAlliance = 3x8 (alliance raids, Frontlines), IsSmallGroupAlliance = 6x4 (Rival Wings)
+                    if (gm->MainGroup.IsAlliance || gm->MainGroup.IsSmallGroupAlliance)
+                        return true;
+                }
+                var info = InfoProxyCrossRealm.Instance();
+                if (info == null) return false;
+                if (info->IsInAllianceRaid) return true;
+                return info->IsCrossRealm && info->GroupCount >= 3;
+            }
+        }
+
+        public event AllianceMembersChangedEventHandler? MembersChangedEvent;
+
+        public void Update()
+        {
+            var gm = GroupManager.Instance();
+            // Use GroupManager for PvE alliance raids and PvP (Frontlines, Rival Wings) - CrossRealm is not populated in PvP
+            bool useGroupManager = gm != null && (gm->MainGroup.IsAlliance || gm->MainGroup.IsSmallGroupAlliance);
+
+            if (useGroupManager)
+            {
+                UpdateFromGroupManager(gm);
+                return;
+            }
+
+            var info = InfoProxyCrossRealm.Instance();
+            if (info == null || !info->IsInAllianceRaid || info->GroupCount < 3)
+            {
+                if (_wasInAllianceRaid)
+                {
+                    _wasInAllianceRaid = false;
+                    for (int i = 0; i < 3; i++)
+                        _allianceMembers[i].Clear();
+                    MembersChangedEvent?.Invoke(this);
+                }
+                return;
+            }
+
+            _wasInAllianceRaid = true;
+            UpdateFromCrossRealm(info);
+        }
+
+        private void UpdateFromGroupManager(GroupManager* gm)
+        {
+            _wasInAllianceRaid = true;
+            bool anyChanged = false;
+            ref var mainGroup = ref gm->MainGroup;
+
+            for (int allianceIdx = 0; allianceIdx < 3; allianceIdx++)
+            {
+                int count = 0;
+                var list = new List<IPartyFramesMember>();
+                for (int slot = 0; slot < 8; slot++)
+                {
+                    var pm = mainGroup.GetAllianceMemberByGroupAndIndex(allianceIdx, slot);
+                    if (pm == null || pm->EntityId == 0) continue;
+                    var pfMember = new PartyFramesMember(
+                        pm->EntityId,
+                        count,
+                        count,
+                        EnmityLevel.Last,
+                        PartyMemberStatus.None,
+                        ReadyCheckStatus.None,
+                        false,
+                        false
+                    );
+                    pfMember.Update(EnmityLevel.Last, PartyMemberStatus.None, ReadyCheckStatus.None, false, pm->ClassJob);
+                    list.Add(pfMember);
+                    count++;
+                }
+                if (count != _lastMemberCounts[allianceIdx])
+                {
+                    _allianceMembers[allianceIdx].Clear();
+                    _allianceMembers[allianceIdx].AddRange(list);
+                    _lastMemberCounts[allianceIdx] = count;
+                    anyChanged = true;
+                }
+                else
+                {
+                    int ourIdx = 0;
+                    for (int slot = 0; slot < 8 && ourIdx < _allianceMembers[allianceIdx].Count; slot++)
+                    {
+                        var pm = mainGroup.GetAllianceMemberByGroupAndIndex(allianceIdx, slot);
+                        if (pm == null || pm->EntityId == 0) continue;
+                        if (_allianceMembers[allianceIdx][ourIdx] is PartyFramesMember pfMember)
+                            pfMember.Update(EnmityLevel.Last, PartyMemberStatus.None, ReadyCheckStatus.None, false, pm->ClassJob);
+                        ourIdx++;
+                    }
+                }
+            }
+            if (anyChanged)
+                MembersChangedEvent?.Invoke(this);
+        }
+
+        /// <summary>Dumps alliance detection and letter-mapping debug info to the log. Run /hsui debug alliance while in an alliance raid.</summary>
+        public static void DumpAllianceDebugToLog()
+        {
+            var inst = Instance;
+            if (inst == null) { Plugin.Logger.Information("[HSUI Alliance DBG] AllianceManager not initialized."); return; }
+
+            var player = Plugin.ObjectTable?.LocalPlayer;
+            uint playerEntityId = player?.EntityId ?? 0;
+            string playerName = player?.Name.ToString() ?? "(null)";
+
+            Plugin.Logger.Information("=== HSUI Alliance Debug ===");
+            Plugin.Logger.Information($"[Alliance] IsInAllianceRaid={inst.IsInAllianceRaid}");
+            Plugin.Logger.Information($"[Alliance] Player: EntityId={playerEntityId} Name={playerName}");
+
+            var gm = GroupManager.Instance();
+            bool useGM = gm != null && (gm->MainGroup.IsAlliance || gm->MainGroup.IsSmallGroupAlliance);
+            Plugin.Logger.Information($"[Alliance] Data source: GroupManager={useGM} (IsAlliance={gm != null && gm->MainGroup.IsAlliance}, IsSmallGroupAlliance={gm != null && gm->MainGroup.IsSmallGroupAlliance})");
+
+            var info = InfoProxyCrossRealm.Instance();
+            if (info != null)
+            {
+                Plugin.Logger.Information($"[Alliance] InfoProxyCrossRealm: GroupCount={info->GroupCount} IsInAllianceRaid={info->IsInAllianceRaid} LocalPlayerGroupIndex={info->LocalPlayerGroupIndex}");
+                if (info->GroupCount >= 3)
+                {
+                    for (byte d = 0; d < 3; d++)
+                        Plugin.Logger.Information($"[Alliance] GetGroupIndex({d}) => internal index {InfoProxyCrossRealm.GetGroupIndex(d)}");
+                }
+            }
+            else
+                Plugin.Logger.Information("[Alliance] InfoProxyCrossRealm: null");
+
+            int playerIdx = inst.PlayerAllianceIndex;
+            Plugin.Logger.Information($"[Alliance] PlayerAllianceIndex={playerIdx} (internal index we treat as 'our' alliance, will exclude from display)");
+
+            for (int i = 0; i < 3; i++)
+            {
+                int count = inst._allianceMembers[i].Count;
+                string firstEntityId = count > 0 ? inst._allianceMembers[i][0].ObjectId.ToString() : "none";
+                string firstName = count > 0 ? inst._allianceMembers[i][0].Name : "";
+                bool hasPlayer = playerEntityId != 0 && inst._allianceMembers[i].Any(m => m.ObjectId == playerEntityId);
+                string letter = inst.TryGetAllianceLetter(i, out string l) ? l : "?";
+                Plugin.Logger.Information($"[Alliance] _allianceMembers[{i}]: count={count} firstEntityId={firstEntityId} firstName={firstName} hasPlayer={hasPlayer} resolvedLetter={letter}");
+            }
+
+            if (info != null && info->GroupCount >= 3)
+            {
+                for (int crIdx = 0; crIdx < 3; crIdx++)
+                {
+                    var grp = info->CrossRealmGroups[crIdx];
+                    int gc = grp.GroupMemberCount;
+                    string crFirstEntity = gc > 0 ? grp.GroupMembers[0].EntityId.ToString() : "none";
+                    string crFirstName = gc > 0 ? grp.GroupMembers[0].NameString : "";
+                    byte crGroupIndex = gc > 0 ? grp.GroupMembers[0].GroupIndex : (byte)255;
+                    char crLetter = crGroupIndex < 3 ? (char)('A' + crGroupIndex) : '?';
+                    Plugin.Logger.Information($"[Alliance] CrossRealmGroups[{crIdx}]: count={gc} firstEntityId={crFirstEntity} firstName={crFirstName} GroupIndex={crGroupIndex} => letter '{crLetter}'");
+                }
+            }
+
+            for (int slot = 0; slot <= 1; slot++)
+            {
+                if (inst.TryGetAllianceIndexForSlot(slot, out int aidx) && inst.TryGetAllianceLetter(aidx, out string let))
+                    Plugin.Logger.Information($"[Alliance] Display slot {slot}: allianceIndex={aidx} letter={let}");
+                else
+                    Plugin.Logger.Information($"[Alliance] Display slot {slot}: no data");
+            }
+            Plugin.Logger.Information("=== End Alliance Debug ===");
+        }
+
+        private void UpdateFromCrossRealm(InfoProxyCrossRealm* info)
+        {
+            bool anyChanged = false;
+            for (int allianceIdx = 0; allianceIdx < 3; allianceIdx++)
+            {
+                var group = info->CrossRealmGroups[allianceIdx];
+                int count = group.GroupMemberCount;
+
+                if (count != _lastMemberCounts[allianceIdx])
+                {
+                    _allianceMembers[allianceIdx].Clear();
+                    _lastMemberCounts[allianceIdx] = count;
+
+                    for (int i = 0; i < count; i++)
+                    {
+                        CrossRealmMember member = group.GroupMembers[i];
+                        var partyMember = new PartyFramesMember(
+                            member,
+                            i,
+                            i,
+                            PartyMemberStatus.None,
+                            ReadyCheckStatus.None,
+                            member.IsPartyLeader,
+                            false
+                        );
+                        _allianceMembers[allianceIdx].Add(partyMember);
+                    }
+                    anyChanged = true;
+                }
+                else
+                {
+                    for (int i = 0; i < _allianceMembers[allianceIdx].Count; i++)
+                    {
+                        if (_allianceMembers[allianceIdx][i] is PartyFramesMember pfMember)
+                        {
+                            pfMember.Update(EnmityLevel.Last, PartyMemberStatus.None, ReadyCheckStatus.None, pfMember.IsPartyLeader, pfMember.JobId);
+                        }
+                    }
+                }
+            }
+            if (anyChanged)
+                MembersChangedEvent?.Invoke(this);
+        }
+    }
+}

Interface/Party/PartyFramesBar.cs

@@ -576,6 +576,8 @@ namespace HSUI.Interface.Party
             }
             ));
 
+            if (_configs.HealthBar.ShowLabels)
+            {
                 // name
                 bool drawName = ShouldDrawName(character, showingRaise, showingInvuln);
                 if (drawName)
@@ -653,6 +655,7 @@ namespace HSUI.Interface.Party
                     }
                     ));
                 }
+            }
 
             return drawActions;
         }

Interface/Party/PartyFramesConfig.cs

@@ -88,6 +88,10 @@ namespace HSUI.Interface.Party
         [Order(31)]
         public Vector2 Padding = new Vector2(0, 0);
 
+        [Checkbox("Show Labels", help = "Show name, health, order number, and status text on the bar.")]
+        [Order(32)]
+        public bool ShowLabels = true;
+
         [NestedConfig("Name Label", 44)]
         public EditableLabelConfig NameLabelConfig = new EditableLabelConfig(Vector2.Zero, "[name:initials].", DrawAnchor.Center, DrawAnchor.Center);
 

Interface/Party/PartyFramesHud.cs

@@ -459,7 +459,19 @@ namespace HSUI.Interface.Party
             );
         }
 
-
+        public static PartyFramesConfigs GetAllianceConfigs()
+        {
+            return new PartyFramesConfigs(
+                ConfigurationManager.Instance.GetConfigObject<AllianceFramesHealthBarsConfig>(),
+                ConfigurationManager.Instance.GetConfigObject<AllianceFramesManaBarConfig>(),
+                ConfigurationManager.Instance.GetConfigObject<AllianceFramesCastbarConfig>(),
+                ConfigurationManager.Instance.GetConfigObject<AllianceFramesIconsConfig>(),
+                ConfigurationManager.Instance.GetConfigObject<AllianceFramesBuffsConfig>(),
+                ConfigurationManager.Instance.GetConfigObject<AllianceFramesDebuffsConfig>(),
+                ConfigurationManager.Instance.GetConfigObject<AllianceFramesTrackersConfig>(),
+                ConfigurationManager.Instance.GetConfigObject<AllianceFramesCooldownListConfig>()
+            );
+        }
     }
     #endregion
 }

Plugin.cs

@@ -130,6 +130,7 @@ namespace HSUI
             InputsHelper.Initialize();
             NameplatesManager.Initialize();
             PartyManager.Initialize();
+            AllianceManager.Initialize();
             PartyCooldownsManager.Initialize();
             PullTimerHelper.Initialize();
             ActionBarsManager.Initialize();
@@ -163,7 +164,21 @@ namespace HSUI
                         + "/hsui debug tooltips → Toggles debug logging for tooltips.\n"
                         + "/hsui debug hud → Dumps HudLayout addon names and hashes to the log (for HUD hiding).\n"
                         + "/hsui debug hotbarslots → Dumps all hotbar slot CommandType/CommandId to the log (for SwapSlots diagnosis).\n"
-                        + "/hsui debug macro <bar> <slot> → Dumps HotbarSlot + RaptureMacroModule.Macro memory for the slot (macro persistence).",
+                        + "/hsui debug macro <bar> <slot> → Dumps HotbarSlot + RaptureMacroModule.Macro memory for the slot (macro persistence).\n"
+                        + "/hsui_alliance_debug → Dumps alliance frame detection and letter-mapping debug info (run while in alliance raid).",
+                    ShowInHelp = true
+                }
+            );
+
+            CommandManager.AddHandler(
+                "/hsui_alliance_debug",
+                new CommandInfo((_, _) =>
+                {
+                    HSUI.Interface.Party.AllianceManager.DumpAllianceDebugToLog();
+                    Chat.Print("HSUI: Alliance debug info dumped to the log (Dalamud log window or dev plugin).");
+                })
+                {
+                    HelpMessage = "Dumps alliance frame detection and letter-mapping debug info. Run while in an alliance raid.",
                     ShowInHelp = true
                 }
             );
@@ -338,6 +353,12 @@ namespace HSUI
                             Chat.Print("Usage: /hsui debug macro <bar> <slot>  (e.g. /hsui debug macro 1 2)");
                         break;
 
+                    case { } when string.Equals(arguments.Trim(), "debug alliance", StringComparison.OrdinalIgnoreCase)
+                        || string.Equals(arguments.Trim(), "debugalliance", StringComparison.OrdinalIgnoreCase):
+                        HSUI.Interface.Party.AllianceManager.DumpAllianceDebugToLog();
+                        Chat.Print("HSUI: Alliance debug info dumped to the log (Dalamud log window or dev plugin).");
+                        break;
+
                     default:
                         configManager.ToggleConfigWindow();
                         break;
@@ -384,6 +405,8 @@ namespace HSUI
                 catch (Exception ex) { Logger.Warning($"NameplatesManager.Update: {ex.Message}"); }
                 try { PartyManager.Instance?.Update(); }
                 catch (Exception ex) { Logger.Warning($"PartyManager.Update: {ex.Message}"); }
+                try { AllianceManager.Instance?.Update(); }
+                catch (Exception ex) { Logger.Warning($"AllianceManager.Update: {ex.Message}"); }
 
                 try
                 {
@@ -419,6 +442,7 @@ namespace HSUI
             {
                 Logger.Info("\tRemoving commands...");
                 CommandManager.RemoveHandler("/hsui");
+                CommandManager.RemoveHandler("/hsui debugalliance");
                 CommandManager.RemoveHandler("/hui");
             }
             catch (Exception e) { Logger.Error("Error removing commands: " + e.Message); }
@@ -448,6 +472,7 @@ namespace HSUI
             TryDispose("GlobalColors", () => GlobalColors.Instance?.Dispose());
             TryDispose("NameplatesManager", () => NameplatesManager.Instance?.Dispose());
             TryDispose("PartyCooldownsManager", () => PartyCooldownsManager.Instance?.Dispose());
+            TryDispose("AllianceManager", () => AllianceManager.Instance?.Dispose());
             TryDispose("PartyManager", () => PartyManager.Instance?.Dispose());
             TryDispose("PullTimerHelper", () => PullTimerHelper.Instance?.Dispose());
             TryDispose("ActionBarsManager", () => ActionBarsManager.Instance?.Dispose());

changelog.md

@@ -1,3 +1,10 @@
+# 1.0.3.0
+- **Alliance Frames**: Fixed alliance letter labels (A/B/C) — correct display when player is in any alliance (A, B, or C); EntityId matching for proper letter resolution when GroupManager and CrossRealm use different orderings; improved PlayerAllianceIndex detection.
+- **Alliance Frames**: PvP support — frames now display in Frontlines and Rival Wings.
+- **Config**: Save on territory change — config persists when teleporting or changing zones so hotbar layout and other changes aren't lost during loading screens.
+- **Hotbars**: Shared hotbar persistence — explicitly write to classJobId 0 (shared storage) so changes to shared bars persist across teleports and job changes.
+- **Debug**: Added `/hsui_alliance_debug` command — dumps alliance detection and letter-mapping info to the log when run in an alliance raid.
+
 # 1.0.2.9
 - **Hotbars**: Fixed false second cooldown — some 60s actions were showing another cooldown after the real one finished; now correctly returns ready when ActionManager says cooldown is complete.
 

pluginmaster.json

@@ -4,9 +4,9 @@
     "Name": "HSUI",
     "Punchline": "A modern HUD replacement built for customization.",
     "Description": "HSUI provides a highly configurable HUD replacement for FFXIV, recreated from DelvUI using KamiToolKit, FFXIVClientStructs, and Dalamud. Features unit frames, castbars, job gauges, nameplates, party frames, status effects, enemy list, configurable hotbars with drag-and-drop, and profiles.",
-    "Changelog": "Hotbars: Fixed false second cooldown on some actions after real cooldown completes.",
+    "Changelog": "Alliance Frames: Fixed A/B/C labels when player in any alliance; PvP support. Hotbars: Shared bar persistence. Config: Save on teleport. Debug: /hsui_alliance_debug.",
     "InternalName": "HSUI",
-    "AssemblyVersion": "1.0.2.9",
+    "AssemblyVersion": "1.0.3.0",
     "RepoUrl": "https://github.com/Knack117/HSUI",
     "ApplicableVersion": "any",
     "Tags": ["UI", "HUD", "Unit Frames", "Nameplates", "Party Frames", "Hotbars"],
@@ -14,10 +14,10 @@
     "DalamudApiLevel": 14,
     "IconUrl": "https://raw.githubusercontent.com/Knack117/HSUI/main/Media/Images/icon.png",
     "ImageUrls": [],
-    "DownloadLinkInstall": "https://github.com/Knack117/HSUI/releases/download/v1.0.2.9/latest.zip",
+    "DownloadLinkInstall": "https://github.com/Knack117/HSUI/releases/download/v1.0.3.0/latest.zip",
     "IsHide": false,
     "IsTestingExclusive": false,
-    "DownloadLinkTesting": "https://github.com/Knack117/HSUI/releases/download/v1.0.2.9/latest.zip",
-    "DownloadLinkUpdate": "https://github.com/Knack117/HSUI/releases/download/v1.0.2.9/latest.zip"
+    "DownloadLinkTesting": "https://github.com/Knack117/HSUI/releases/download/v1.0.3.0/latest.zip",
+    "DownloadLinkUpdate": "https://github.com/Knack117/HSUI/releases/download/v1.0.3.0/latest.zip"
   }
 ]