(client) feat:做了初始化加载动画。 fix:修复定义加载列表和加载枚举时的错误识别

Client/Assets/Scripts/Managers/AffiliationManager.cs

@@ -0,0 +1,157 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Data;
+
+namespace Managers
+{
+    public class AffiliationManager:Utils.Singleton<AffiliationManager>
+    {
+        //定义名，阵营定义
+        private readonly Dictionary<string, AffiliationDef> _affiliations = new();
+        
+        public void Init()
+        {
+            var affiliationList = Managers.DefineManager.Instance.QueryDefinesByType<AffiliationDef>();
+            if (affiliationList == null ||affiliationList.Length==0)
+                return;
+            foreach (var affiliation in affiliationList)
+            {
+                _affiliations.Add(affiliation.defName, affiliation);
+            }
+            ValidateAndFixRelationships();
+        }
+
+        public string GetAffiliationName(string defName)
+        {
+            return _affiliations[defName].defName;
+        }
+
+        public Relation GetRelation(string factionName1, string factionName2)
+        {
+            // 如果查询的是同一个派系，默认是友好关系
+            if (factionName1 == factionName2)
+            {
+                return Relation.Friendly;
+            }
+
+            // 尝试获取两个派系的定义
+            if (!_affiliations.TryGetValue(factionName1, out var faction1) ||
+                !_affiliations.TryGetValue(factionName2, out _))
+            {
+                if (faction1 != null) return faction1.defaultRelation;
+                return Relation.Neutral;
+            }
+
+            // 检查faction1是否明确将faction2列为敌对
+            if (faction1.hostileFactions != null && faction1.hostileFactions.Contains(factionName2))
+            {
+                return Relation.Hostile;
+            }
+
+            // 检查faction1是否明确将faction2列为友好
+            if (faction1.friendlyFactions != null && faction1.friendlyFactions.Contains(factionName2))
+            {
+                return Relation.Friendly;
+            }
+
+            // 检查faction1是否明确将faction2列为中立
+            if (faction1.neutralFactions != null && faction1.neutralFactions.Contains(factionName2))
+            {
+                return Relation.Neutral;
+            }
+
+            // 如果faction1没有明确设置与faction2的关系，则使用faction1的默认关系
+            return faction1.defaultRelation;
+        }
+        
+        /// <summary>
+        /// 设置两个阵营之间的关系
+        /// </summary>
+        /// <param name="factionName1">第一个阵营名称</param>
+        /// <param name="factionName2">第二个阵营名称</param>
+        /// <param name="relation">要设置的关系</param>
+        public void SetRelation(string factionName1, string factionName2, Relation relation)
+        {
+            // 不能设置自己与自己的关系
+            if (factionName1 == factionName2)
+            {
+                throw new ArgumentException("Cannot set relation between the same faction");
+            }
+
+            // 确保两个阵营都存在
+            if (!_affiliations.TryGetValue(factionName1, out var faction1) ||
+                !_affiliations.TryGetValue(factionName2, out _))
+            {
+                throw new ArgumentException("One or both factions do not exist");
+            }
+
+            // 确保关系列表已初始化
+            faction1.hostileFactions ??= new List<string>();
+            faction1.friendlyFactions ??= new List<string>();
+            faction1.neutralFactions ??= new List<string>();
+
+            // 先移除所有现有关系
+            faction1.hostileFactions.Remove(factionName2);
+            faction1.friendlyFactions.Remove(factionName2);
+            faction1.neutralFactions.Remove(factionName2);
+
+            // 添加新关系
+            switch (relation)
+            {
+                case Relation.Hostile:
+                    faction1.hostileFactions.Add(factionName2);
+                    break;
+                case Relation.Friendly:
+                    faction1.friendlyFactions.Add(factionName2);
+                    break;
+                case Relation.Neutral:
+                    faction1.neutralFactions.Add(factionName2);
+                    break;
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(relation), relation, null);
+            }
+        }
+        
+        /// <summary>
+        /// 检查并修复派系关系，确保没有冲突（按友好 > 敌对 > 中立 的优先级）
+        /// </summary>
+        private void ValidateAndFixRelationships()
+        {
+            foreach (var faction in _affiliations.Values)
+            {
+                // 确保所有关系列表已初始化
+                faction.hostileFactions ??= new List<string>();
+                faction.friendlyFactions ??= new List<string>();
+                faction.neutralFactions ??= new List<string>();
+
+                // 检查所有敌对派系
+                foreach (var hostileFaction in faction.hostileFactions.ToList())
+                {
+                    // 如果敌对派系同时存在于友好列表中，移除敌对关系（友好优先）
+                    if (faction.friendlyFactions.Contains(hostileFaction))
+                    {
+                        faction.hostileFactions.Remove(hostileFaction);
+                        continue;
+                    }
+
+                    // 如果敌对派系同时存在于中立列表中，移除中立关系（敌对优先）
+                    if (faction.neutralFactions.Contains(hostileFaction))
+                    {
+                        faction.neutralFactions.Remove(hostileFaction);
+                    }
+                }
+
+                // 检查所有中立派系
+                foreach (var neutralFaction in faction.neutralFactions.ToList())
+                {
+                    // 如果中立派系同时存在于友好列表中，移除中立关系（友好优先）
+                    if (faction.friendlyFactions.Contains(neutralFaction))
+                    {
+                        faction.neutralFactions.Remove(neutralFaction);
+                    }
+                }
+            }
+        }
+    }
+}