修改bug

Assets/Scripts/GameLogic/Combat/Hero/CombatHeroSkillControl.cs

@@ -21,6 +21,11 @@ namespace GameLogic.Combat.Hero
         /// </summary>
         private BetterList<SkillBasic> SkillCommands = new BetterList<SkillBasic>();
 
+        public SkillBasic[] GetSkillQueue()
+        {
+            return SkillCommands.ToArray(true);
+        }
+
         public int useSkillCount
         {
             get { return SkillCommands.size; }

Assets/Scripts/GameLogic/Combat/Hero/MagicWeaponControl.cs

@@ -17,6 +17,14 @@ namespace GameLogic.Combat.Hero
         public bool isAutoUse;
         private BetterList<CombatMagicWeaponEntity> _allMagicWeapon = new BetterList<CombatMagicWeaponEntity>();
 
+        public CombatMagicWeaponEntity[] AllMagicWeapon
+        {
+            get { return _allMagicWeapon.ToArray(true); }
+        }
+        public int MagicWeaponCount
+        {
+            get { return _allMagicWeapon.Count; }
+        }
         // private CombatMagicWeaponEntity _currUserMagicWeapon;
 
         public CombatHeroEntity combatHeroEntity;

Assets/Scripts/GameLogic/Combat/Hero/Turntable/SkillSlots.cs

@@ -109,12 +109,35 @@ namespace GameLogic.Combat.Hero.Turntable
             }
             else
             {
-                finishAngle =  (jd - targetAngle);
+                finishAngle = (jd - targetAngle);
             }
 
             return finishAngle / 360f;
         }
 
+        public float GetFinishAngle()
+        {
+            float v = angle % 360;
+            int targetAngle = triggerAngle[currTriggerTypeIndex];
+            float jd = v;
+            if (targetAngle == 0)
+            {
+                targetAngle = 360;
+            }
+
+            float finishAngle = 0;
+            if (jd < targetAngle)
+            {
+                finishAngle = 360 - (targetAngle - jd);
+            }
+            else
+            {
+                finishAngle = (jd - targetAngle);
+            }
+
+            return 360f - finishAngle;
+        }
+
         private void Angle(float addAngle)
         {
             angle += addAngle;

Assets/Scripts/GameUI/UI/CombatPanel/BossHpWidget.cs

@@ -0,0 +1,153 @@
+using System.Collections.Generic;
+using Common.Utility.CombatEvent;
+using Fort23.Core;
+using GameLogic.Combat.CombatTool;
+using GameLogic.Combat.Hero;
+using GameLogic.Combat.Hero.Turntable;
+using GameLogic.Combat.Skill;
+
+namespace Fort23.Mono
+{
+    [UIBinding(prefab = "BossHpWidget")]
+    public partial class BossHpWidget : UIComponent
+    {
+        private CombatHeroEntity combatHeroEntity;
+
+        private CombatHeroSkillControl combatHeroSkillControl;
+
+        protected BetterList<gf_widget> currShowGfWidget = new BetterList<gf_widget>();
+
+        private void Init()
+        {
+        }
+
+        public override void AddEvent()
+        {
+            CombatEventManager.Instance.AddEventListener(CombatEventType.UseSkill, UseSkill);
+        }
+
+        public override void DelEvent()
+        {
+            CombatEventManager.Instance.RemoveEventListener(CombatEventType.UseSkill, UseSkill);
+        }
+
+        public override void AddButtonEvent()
+        {
+        }
+
+        private void UseSkill(IEventData iEventData)
+        {
+        }
+
+        private async CTask ReshSkill()
+        {
+            currShowGfWidget.Clear();
+            UIManager.Instance.DormancyAllGComponent<gf_widget>("bossWidget");
+            if (combatHeroSkillControl.currUseSkill != null)
+            {
+                // gf_widget gfWidget = await UIManager.Instance.CreateGComponentForObject<gf_widget>(this.gf_widget, null,
+                //     SkillRoot,poolName:"bossWidget", isInstance: true);
+                // gfWidget.InitWidget();
+            }
+
+            int maxCount = 2;
+            int queueCount = combatHeroSkillControl.useSkillCount;
+            if (queueCount > 0)
+            {
+                SkillBasic[] allSkill = combatHeroSkillControl.GetSkillQueue();
+                for (int i = 0; i < allSkill.Length; i++)
+                {
+                    if (maxCount <= 0)
+                    {
+                        break;
+                    }
+
+                    maxCount--;
+                    SkillBasic skillBasic = allSkill[i];
+                    gf_widget gfWidget = await UIManager.Instance.CreateGComponentForObject<gf_widget>(this.gf_widget,
+                        null,
+                        SkillRoot, poolName: "bossWidget", isInstance: true);
+                    gfWidget.InitSkillWidget(skillBasic);
+                    gfWidget.transform.SetAsLastSibling();
+                }
+            }
+
+            if (maxCount > 0)
+            {
+                float minA = float.MaxValue;
+                SkillSlots minSlots = null;
+                List<SkillSlots> showSkillSlots = new List<SkillSlots>();
+                for (int j = 0; j < maxCount; j++)
+                {
+                    minSlots = null;
+                    minA = float.MaxValue;
+                    for (int i = 0; i < combatHeroSkillControl.SkillTurntable.allSkillSlots.Count; i++)
+                    {
+                        SkillSlots skillSlots = combatHeroSkillControl.SkillTurntable.allSkillSlots[i];
+                        float angle = skillSlots.GetFinishAngle();
+                        if (angle <= minA && !showSkillSlots.Contains(skillSlots))
+                        {
+                            minA = angle;
+                            minSlots = skillSlots;
+                        }
+                    }
+
+                    if (minSlots != null)
+                    {
+                        showSkillSlots.Add(minSlots);
+                        gf_widget gfWidget = await UIManager.Instance.CreateGComponentForObject<gf_widget>(
+                            this.gf_widget,
+                            null,
+                            SkillRoot, poolName: "bossWidget", isInstance: true);
+                        gfWidget.InitWidget(minSlots);
+                        gfWidget.transform.SetAsLastSibling();
+                        currShowGfWidget.Add(gfWidget);
+                    }
+                }
+            }
+        }
+
+        public async CTask ShowWidget(CombatHeroEntity combatHeroEntity)
+        {
+            this.combatHeroEntity = combatHeroEntity;
+            combatHeroSkillControl =
+                combatHeroEntity.CombatHeroSkillControl as CombatHeroSkillControl;
+            HeroHpWidget heroHpWidget =
+                await UIManager.Instance.CreateGComponentForObject<HeroHpWidget>(HeroHpWidget, null);
+            heroHpWidget.size = 250;
+            heroHpWidget.shieldSize = 100;
+            heroHpWidget.isFollowTarget = false;
+            heroHpWidget.Init(combatHeroEntity);
+            ReshSkill();
+            InitMagicWeapon();
+        }
+
+        private async CTask InitMagicWeapon()
+        {
+            int c = combatHeroEntity.MagicWeaponControl.MagicWeaponCount;
+            CombatMagicWeaponEntity[] combatMagicWeaponEntities = combatHeroEntity.MagicWeaponControl.AllMagicWeapon;
+            for (int i = 0; i < c; i++)
+            {
+                CombatMagicWeaponEntity combatMagicWeaponEntity = combatMagicWeaponEntities[i];
+                MagicWeaponWidget shengShiEventWidget =
+                    await UIManager.Instance.CreateGComponentForObject<MagicWeaponWidget>(MagicWeaponWidget, null,
+                        FaBaoRoot,
+                        isInstance: true, poolName: "bossFaBao");
+                shengShiEventWidget.InitWidget(combatMagicWeaponEntity);
+            }
+        }
+
+        public void Update()
+        {
+            if (combatHeroEntity == null)
+            {
+                return;
+            }
+
+            for (int i = 0; i < currShowGfWidget.Count; i++)
+            {
+                currShowGfWidget[i].Update();
+            }
+        }
+    }
+}

Assets/Scripts/GameUI/UI/CombatPanel/BossHpWidget.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: Wn5J5HyvVn8hiJMmTop0nB3KpI88+KcQtzg1mu1UBrfOXNVw7Mgw7JuNwVGx
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/GameUI/UI/CombatPanel/BossHpWidgetData.cs

@@ -0,0 +1,73 @@
+using Fort23.Core;
+using Fort23.UTool;
+using UnityEngine.UI;
+using UnityEngine;
+using System.Collections.Generic;
+namespace Fort23.Mono
+{
+	public partial class BossHpWidget 
+	{
+	  #region 自定义数据 
+	  private GameObject _HeroHpWidget;
+	  public GameObject HeroHpWidget
+	   {
+	   get{
+	      if (_HeroHpWidget == null)
+	       {
+	         _HeroHpWidget  = GetUIUnit<GameObject>("HeroHpWidget"); 
+	       }
+	      return _HeroHpWidget;
+	     }
+	   }
+	  private GameObject _gf_widget;
+	  public GameObject gf_widget
+	   {
+	   get{
+	      if (_gf_widget == null)
+	       {
+	         _gf_widget  = GetUIUnit<GameObject>("gf_widget"); 
+	       }
+	      return _gf_widget;
+	     }
+	   }
+	  private RectTransform _SkillRoot;
+	  public RectTransform SkillRoot
+	   {
+	   get{
+	      if (_SkillRoot == null)
+	       {
+	         _SkillRoot  = GetUIUnit<RectTransform>("SkillRoot"); 
+	       }
+	      return _SkillRoot;
+	     }
+	   }
+	  private GameObject _MagicWeaponWidget;
+	  public GameObject MagicWeaponWidget
+	   {
+	   get{
+	      if (_MagicWeaponWidget == null)
+	       {
+	         _MagicWeaponWidget  = GetUIUnit<GameObject>("MagicWeaponWidget"); 
+	       }
+	      return _MagicWeaponWidget;
+	     }
+	   }
+	  private RectTransform _FaBaoRoot;
+	  public RectTransform FaBaoRoot
+	   {
+	   get{
+	      if (_FaBaoRoot == null)
+	       {
+	         _FaBaoRoot  = GetUIUnit<RectTransform>("FaBaoRoot"); 
+	       }
+	      return _FaBaoRoot;
+	     }
+	   }
+	  #endregion 自定义数据结束 
+	 public override async CTask SetUIGameObject(GameObject gObjectPoolInterface)
+	{
+	 await base.SetUIGameObject(gObjectPoolInterface);
+	 Init();
+	}
+	}
+}

Assets/Scripts/GameUI/UI/CombatPanel/BossHpWidgetData.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: CXtOsCyuUn9jQdeYS1E0SPO4hGO1SSwPgYIeh7/DAoQLabA9iuBVIW5UTCRW
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/GameUI/UI/CombatPanel/CombatPanel.cs

@@ -18,11 +18,6 @@ namespace Fort23.Mono
         public static void OpenCombatPanel(CTaskAwaitBuffer cTaskAwaitBuffer)
         {
             cTaskAwaitBuffer.AddTask(UIManager.Instance.LoadAndOpenPanel<CombatPanel>(null, UILayer.Middle));
-            // cTaskAwaitBuffer.AddTask(AssetBundleLoadManager.Instance.LoadAssetAsyncTask<Font>("hd_0.fontsettings",
-            //     delegate(AssetHandle handle) { huiFuFont = handle.AssetObject<Font>(); }));
-            //
-            // cTaskAwaitBuffer.AddTask(AssetBundleLoadManager.Instance.LoadAssetAsyncTask<Font>("Zhanli_0.fontsettings",
-            //     delegate(AssetHandle handle) { shangHai = handle.AssetObject<Font>(); }));
         }
 
         protected override async CTask ProOpen()
@@ -62,7 +57,6 @@ namespace Fort23.Mono
                     UseQuqueSkillRoot, isInstance: true);
             useQuqueSkill.ShowWidget(skillBasic);
             useQuqueSkill.transform.SetAsLastSibling();
-            
         }
 
         private async void AddMagicWeaponHeroEntity(IEventData ieveData)
@@ -96,6 +90,16 @@ namespace Fort23.Mono
             heroHpWidget.shieldSize = 100;
             heroHpWidget.isFollowTarget = false;
             heroHpWidget.Init(CombatController.currActiveCombat.CombatHeroController.playerHeroEntity);
+
+            CombatHeroEntity[] allEnemy = CombatController.currActiveCombat.CombatHeroController.GetHero(true);
+            for (int i = 0; i < allEnemy.Length; i++)
+            {
+                CombatHeroEntity enemy = allEnemy[i];
+                BossHpWidget bossHpWidget =
+                    await UIManager.Instance.CreateGComponentForObject<BossHpWidget>(BossHpWidget, null, BossHpRoot,
+                        isInstance: true);
+                bossHpWidget.ShowWidget(enemy);
+            }
         }
 
         protected override void DelEvent()

Assets/Scripts/GameUI/UI/CombatPanel/CombatPanelData.cs

@@ -129,6 +129,28 @@ namespace Fort23.Mono
 	      return _UseQuqueSkillRoot;
 	     }
 	   }
+	  private GameObject _BossHpWidget;
+	  public GameObject BossHpWidget
+	   {
+	   get{
+	      if (_BossHpWidget == null)
+	       {
+	         _BossHpWidget  = GetUIUnit<GameObject>("BossHpWidget"); 
+	       }
+	      return _BossHpWidget;
+	     }
+	   }
+	  private RectTransform _BossHpRoot;
+	  public RectTransform BossHpRoot
+	   {
+	   get{
+	      if (_BossHpRoot == null)
+	       {
+	         _BossHpRoot  = GetUIUnit<RectTransform>("BossHpRoot"); 
+	       }
+	      return _BossHpRoot;
+	     }
+	   }
 	  #endregion 自定义数据结束 
 	 public override async CTask SetUIGameObject(GameObject gObjectPoolInterface)
 	{

Assets/Scripts/GameUI/UI/CombatPanel/MagicWeaponWidget.cs

@@ -25,6 +25,11 @@ namespace Fort23.Mono
         {
             myButton.onClick.AddListener(() =>
             {
+                if (combatMagicWeaponEntity.IsEnemy)
+                {
+                    return;
+                }
+
                 if (combatMagicWeaponEntity == null || combatMagicWeaponEntity.cd > 0)
                 {
                     return;

Assets/Scripts/GameUI/UI/CombatPanel/ZhuanPanPanel.cs

@@ -89,7 +89,7 @@ namespace Fort23.Mono
 
                 gf_widget gfWidget = await UIManager.Instance.CreateGComponentForObject<gf_widget>(this.gf_widget, null,
                     Gf_root, isInstance: true);
-                gfWidget.SkillBasic = skillBasic;
+                gfWidget.SkillSlots = skillBasic;
                 gfWidget.InitWidget(skillBasic);
                 _gfWidgets.Add(gfWidget);
             }
@@ -126,13 +126,13 @@ namespace Fort23.Mono
             {
                 gf_widget gfWidget = _gfWidgets[i];
                 gfWidget.Update();
-                double hd = gfWidget.SkillBasic.angle * Math.PI / 180f;
+                double hd = gfWidget.SkillSlots.angle * Math.PI / 180f;
                 double a = Math.Cos(hd);
                 double b = -Math.Sin(hd);
                 double c = Math.Sin(hd);
                 double d = a;
-                double x = a * 0 + b * 110;
-                double y = c * 0 + d * 110;
+                double x = a * 0 + b * 122;
+                double y = c * 0 + d * 122;
 
                 gfWidget.transform.anchoredPosition = new Vector2((float)x, (float)y);
             }

Assets/Scripts/GameUI/UI/CombatPanel/gf_widget.cs

@@ -9,7 +9,8 @@ namespace Fort23.Mono
     [UIBinding(prefab = "gf_widget")]
     public partial class gf_widget : UIComponent
     {
-        public SkillSlots SkillBasic;
+        public SkillSlots SkillSlots;
+        public SkillBasic SkillBasic;
 
 
         public float jd;
@@ -33,8 +34,9 @@ namespace Fort23.Mono
         public void SkillSlotsAlter(IEventData eventData)
         {
             SkillSlotsAlterEventData skillSlotsAlterEventData = (SkillSlotsAlterEventData)eventData;
-            if (skillSlotsAlterEventData.SkillSlots == SkillBasic)
+            if (skillSlotsAlterEventData.SkillSlots == SkillSlots)
             {
+                SkillBasic = SkillSlots.SkillBasic;
                 SetUIInfo();
             }
         }
@@ -45,7 +47,7 @@ namespace Fort23.Mono
 
         private void SetUIInfo()
         {
-            if (SkillBasic.SkillBasic == null)
+            if (SkillBasic == null)
             {
                 useSkillIcon.transform.parent.gameObject.SetActive(false);
                 quan.color = Color.white;
@@ -53,16 +55,16 @@ namespace Fort23.Mono
             }
 
             useSkillIcon.transform.parent.gameObject.SetActive(true);
-            useSkillIcon.icon_name = SkillBasic.SkillBasic.SelfSkillConfig.icon;
+            useSkillIcon.icon_name = SkillBasic.SelfSkillConfig.icon;
             cd.fillAmount = 0;
-            if (SkillBasic.SkillBasic.SelfSkillConfig.SkillType == 2)
+            if (SkillBasic.SelfSkillConfig.SkillType == 2)
             {
                 quan.color = new Color(0.81f, 0.21f, 1f);
                 return;
             }
 
             // useCount= SkillBasic.UseCount;
-            switch (SkillBasic.SkillBasic.SelfSkillConfig.attribute)
+            switch (SkillBasic.SelfSkillConfig.attribute)
             {
                 case 1:
                     quan.color = new Color(1f, 0.98f, 0.09f);
@@ -84,24 +86,32 @@ namespace Fort23.Mono
 
         public void Update()
         {
-            if (SkillBasic.SkillBasic == null)
+            if (SkillSlots == null|| SkillBasic == null)
             {
                 return;
             }
 
-            SkillBasic skillBasic = SkillBasic.SkillBasic;
+            SkillBasic skillBasic = SkillBasic;
             if (skillBasic.SelfSkillConfig.SkillType != 1)
             {
                 return;
             }
 
-            float bl = 1 - SkillBasic.GetFinishBl();
+            float bl = 1 - SkillSlots.GetFinishBl();
             cd.fillAmount = bl;
         }
 
-        public void InitWidget(SkillSlots SkillBasic)
+        public void InitSkillWidget(SkillBasic SkillBasic)
         {
             this.SkillBasic = SkillBasic;
+            this.SkillSlots = null;
+            SetUIInfo();
+        }
+
+        public void InitWidget(SkillSlots skillSlots)
+        {
+            this.SkillSlots = skillSlots;
+            SkillBasic = skillSlots.SkillBasic;
             SetUIInfo();
         }
     }