XiuXianGame/Assets/Scripts/GameLogic/Combat/CombatTool/CombatHeroController.cs

using System;
using System.Collections.Generic;
using Common.Utility.CombatEvent;
using Core.Utility;
using Excel2Json;
using Fort23.Core;
using Fort23.UTool;
using GameLogic.Combat.Hero;
using UnityEngine;
using UTool.CustomizeTimeLogic.FxLogic.TimeLineEventinterface;

namespace GameLogic.Combat.CombatTool
{
    public class CombatHeroController : IDisposable
    {
        private BetterList<CombatHeroEntity> myHero = new BetterList<CombatHeroEntity>();
        private BetterList<CombatHeroEntity> enemyHero = new BetterList<CombatHeroEntity>();

        private BetterList<ILifetCycleHitPoint> myHeroHitPoint = new BetterList<ILifetCycleHitPoint>();
        private BetterList<ILifetCycleHitPoint> enemyHeroHitPoint = new BetterList<ILifetCycleHitPoint>();
        protected CombatController combatController;

        private BetterList<CombatHeroEntity> heroDie = new BetterList<CombatHeroEntity>();
        private BetterList<CombatHeroEntity> heroDispose = new BetterList<CombatHeroEntity>();
        public CombatHeroEntity playerHeroEntity;

        public Vector3[] followMovePos = new Vector3[]
        {
            new Vector3(0, 0, 0),
            new Vector3(-1.5f, 0, -1f),
            new Vector3(1.5f, 0, -1f),
            new Vector3(0, 0, -2.5f),
        };

        public CombatHeroEntity followTarget;


        public async CTask Init(CombatController combatController)
        {
            this.combatController = combatController;
            CombatEventManager.Instance.AddEventListener(CombatEventType.UseSkill, CombatUseSkillEventData);
            EventManager.Instance.AddEventListener(CustomEventType.HeroPowerUp, HeroPowerUp);

            CombatHeroInfo combatHeroInfo = new CombatHeroInfo();
            combatHeroInfo.attack = (EncryptionLong)10;
        }

        private void HeroPowerUp(IEventData eventData)
        {
            HeroPowerUpEventData heroPowerUpEventData = eventData as HeroPowerUpEventData;

            // if (heroPowerUpEventData.upType == HeroUpType.BasicEquip)
            // {
            //     return;
            // }

            int id = heroPowerUpEventData.heroModelID;
            CombatHeroEntity combatHeroEntity = null;
            for (int i = 0; i < myHero.Count; i++)
            {
                if (myHero[i].CurrCombatHeroInfo.modelID == id)
                {
                    combatHeroEntity = myHero[i];
                    break;
                }
            }

            if (combatHeroEntity == null)
            {
                for (int i = 0; i < heroDie.Count; i++)
                {
                    if (heroDie[i].CurrCombatHeroInfo.modelID == id)
                    {
                        combatHeroEntity = heroDie[i];
                        break;
                    }
                }
            }

            CombatHeroInfo combatHeroInfo = PlayerManager.Instance.heroController.GetHeroInfo(id);


            UpLevelHero(heroPowerUpEventData.isSkillUp, combatHeroEntity, combatHeroInfo);
        }


        private void UpLevelHero(bool isSkillUp, CombatHeroEntity combatHeroEntity, CombatHeroInfo combatHeroInfo)
        {
            // int id = heroPowerUpEventData.heroModelID;


            long addHp = combatHeroInfo.hp.Value - combatHeroEntity.MaxCombatHeroInfo.hp.Value;
            combatHeroEntity.MaxCombatHeroInfo.hp = combatHeroInfo.hp;
            combatHeroEntity.MaxCombatHeroInfo.defense = combatHeroInfo.defense;
            combatHeroEntity.MaxCombatHeroInfo.attack = combatHeroInfo.attack;
            combatHeroEntity.MaxCombatHeroInfo.defK = combatHeroInfo.defK;
            combatHeroEntity.CurrCombatHeroInfo.defense = combatHeroInfo.defense;
            combatHeroEntity.CurrCombatHeroInfo.defK = combatHeroInfo.defK;
            combatHeroEntity.CurrCombatHeroInfo.attack = combatHeroInfo.attack;
            combatHeroEntity.CurrCombatHeroInfo.unLockSkills = combatHeroInfo.unLockSkills;
            combatHeroEntity.MaxCombatHeroInfo.unLockSkills = combatHeroInfo.unLockSkills;
            if (!combatHeroEntity.isDie)
            {
                if (addHp > 0)
                {
                    combatHeroEntity.CurrCombatHeroInfo.hp += addHp;
                }
                else
                {
                }
            }

            if (isSkillUp)
            {
                // List<SkillConfig> skillConfigs = combatHeroInfo.skillConfigs;
                combatHeroEntity.CombatHeroSkillControl.UpdateSkill(combatHeroInfo.unLockSkills);
            }
        }

        public void RemoveDieHero(CombatHeroEntity combatHeroEntity)
        {
            heroDie.Remove(combatHeroEntity);
            if (!heroDispose.Contains(combatHeroEntity))
            {
                combatHeroEntity.DisTime = 0;
                heroDispose.Add(combatHeroEntity);
            }
        }

        /// <summary>
        /// 复活死亡的英雄
        /// </summary>
        public void ResurrectionDieHero(CombatHeroEntity combatHeroEntity)
        {
            if (!combatHeroEntity.isDie)
            {
                return;
            }


            if (combatHeroEntity.heroDieNodeId !=
                CombatController.currActiveCombat.CombatTypeBasic.allWinNodeCount)
            {
                Vector3 pos = CombatController.currActiveCombat.CombatTypeBasic.currBannerHero.dotPos;
                if (CombatController.currActiveCombat.CombatHeroController.followTarget != null)
                {
                    pos = CombatController.currActiveCombat.CombatHeroController.followTarget.dotPos +
                          new Vector3(1, 0, 0);
                }

                combatHeroEntity.combatHeroGameObject.SetPosition(pos);
            }


            heroDie.Remove(combatHeroEntity);
            combatHeroEntity.CurrCombatHeroInfo.hp = combatHeroEntity.MaxCombatHeroInfo.hp;
            AddHero(combatHeroEntity);
            combatHeroEntity.HeroResurrection();
        }

        public void Update(float t)
        {
            for (int i = 0; i < myHero.Count; i++)
            {
                myHero[i].Update(t);
            }

            for (int i = 0; i < enemyHero.Count; i++)
            {
                enemyHero[i].Update(t);
            }

            for (int i = 0; i < heroDie.Count; i++)
            {
                heroDie[i].Update(t);
            }
        }

        public void LateUpdate(float t)
        {
            for (int i = 0; i < heroDispose.Count; i++)
            {
                CombatHeroEntity combatHeroEntity = heroDispose[i];
                combatHeroEntity.Dispose();
                combatHeroEntity.DisTime += t;
                if (combatHeroEntity.DisTime > 10)
                {
                    CObjectPool.Instance.Recycle(combatHeroEntity);
                    heroDispose.RemoveAt(i);
                    i--;
                }
            }
        }

        public void AddHeroDie(CombatHeroEntity hero)
        {
            heroDie.Add(hero);
        }

        public void AddHero(CombatHeroEntity hero)
        {
            if (hero.IsEnemy)
            {
                enemyHero.Add(hero);
            }
            else
            {
                myHero.Add(hero);
            }
        }

        public void FindNumberMinHero()
        {
            int min = 9999;
            followTarget = null;
            for (int i = 0; i < myHero.Count; i++)
            {
                CombatHeroEntity c = myHero[i];
                if (c.number < min)
                {
                    min = c.number;
                    followTarget = c;
                }
            }
        }

        public void SetFollowTarget()
        {
            FindNumberMinHero();
            for (int i = 0; i < myHero.Count; i++)
            {
                CombatHeroEntity c = myHero[i];
                if (c != followTarget)
                {
                    c.isFollowState = true;
                    c.CombatAIBasic.ChangeState(CombatHeroStateType.followIdle);
                }
            }
        }

        public void SetHpToMaxHp()
        {
            for (int i = 0; i < myHero.Count; i++)
            {
                CombatHeroEntity c = myHero[i];
                if (c.isDie)
                {
                    continue;
                }

                c.CurrCombatHeroInfo.hp = c.MaxCombatHeroInfo.hp;
                HeroHpUpdateEventData heroHpUpdateEventData = HeroHpUpdateEventData.Create();
                heroHpUpdateEventData.combatHeroEntity = c;
                CombatEventManager.Instance.Dispatch(CombatEventType.HeroHpUpdate, heroHpUpdateEventData);
            }
        }

        private void CombatUseSkillEventData(IEventData iEventData)
        {
            CombatUseSkillEventData combatUseSkillEventData = iEventData as CombatUseSkillEventData;
            if (combatUseSkillEventData.useSkill.SelfSkillConfig.SkillType == 1)
            {
                for (int i = 0; i < myHero.Count; i++)
                {
                    CombatHeroEntity c = myHero[i];
                    if (c.isFollowState)
                    {
                        c.isFollowState = false;
                        c.CombatAIBasic.ChangeState(CombatHeroStateType.idle);
                    }
                }
            }
        }

        public void RemoveHero(CombatHeroEntity hero)
        {
            if (hero.IsEnemy)
            {
                enemyHero.Remove(hero);
            }
            else
            {
                myHero.Remove(hero);
            }
        }

        public void AddHeroHitPoint(bool isEnemy, ILifetCycleHitPoint hitPoint)
        {
            if (isEnemy)
            {
                enemyHeroHitPoint.Add(hitPoint);
            }
            else
            {
                myHeroHitPoint.Add(hitPoint);
            }
        }

        public void RemoveHeroHitPoint(bool isEnemy, ILifetCycleHitPoint hitPoint)
        {
            if (isEnemy)
            {
                enemyHeroHitPoint.Remove(hitPoint);
            }
            else
            {
                myHeroHitPoint.Remove(hitPoint);
            }
        }

        public void Dispose()
        {
            myHero.Dispose();
            enemyHero.Dispose();
            CombatEventManager.Instance.RemoveEventListener(CombatEventType.UseSkill, CombatUseSkillEventData);
            EventManager.Instance.RemoveEventListener(CustomEventType.HeroPromote, HeroPowerUp);
        }

        public Vector3 GetFollowPos(CombatHeroEntity combatHeroEntity)
        {
            int index = combatHeroEntity.number - followTarget.number;
            return followTarget.combatHeroGameObject.transform.TransformPoint((followMovePos[index]));
            // return followMovePos[index] + .dotPos;
        }

        public BetterList<CombatHeroEntity> GetHeroList(bool isEnemy)
        {
            if (isEnemy)
            {
                return enemyHero;
            }
            else
            {
                return myHero;
            }
        }

        public CombatHeroEntity[] GetHero(bool isEnemy)
        {
            if (isEnemy)
            {
                return enemyHero.ToArray();
            }
            else
            {
                return myHero.ToArray();
            }
        }

        public CombatHeroEntity GetHeroForId(int modelID)
        {
            if (myHero == null)
            {
                return null;
            }

            for (int i = 0; i < myHero.Count; i++)
            {
                if (myHero[i].CurrCombatHeroInfo.modelID == modelID)
                {
                    return myHero[i];
                }
            }

            return null;
        }

        public CombatHeroEntity[] GetDieHero()
        {
            return heroDie.ToArray();
        }

        public ILifetCycleHitPoint[] GetHeroHitPoint(bool isEnemy)
        {
            if (isEnemy)
            {
                return enemyHeroHitPoint.ToArray();
            }
            else
            {
                return myHeroHitPoint.ToArray();
            }
        }
    }
}