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

using System;
using Common.Utility.CombatEvent;
using Fort23.Core;
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 Vector3[] followMovePos = new Vector3[]
        {
            new Vector3(0, 0, 0),
            new Vector3(-1f, 0, -0.5f),
            new Vector3(1f, 0, -0.5f),
            new Vector3(0, 0, -2f),
        };

        public CombatHeroEntity followTarget;

        public void Init(CombatController combatController)
        {
            this.combatController = combatController;
            CombatEventManager.Instance.AddEventListener(CombatEventType.UseSkill, CombatUseSkillEventData);
            EventManager.Instance.AddEventListener(CustomEventType.HeroUpgrade, HeroUpgrade);
        }

        private void HeroUpgrade(IEventData eventData)
        {
            HeroLvUpgradeEventData heroLvUpgradeEventData = eventData as HeroLvUpgradeEventData;
            int id = heroLvUpgradeEventData.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.GetHeroInfo(id);
            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.CurrCombatHeroInfo.defense = combatHeroInfo.defense;
            combatHeroEntity.CurrCombatHeroInfo.attack = combatHeroInfo.attack;
            if (!combatHeroEntity.isDie)
            {
                if (addHp > 0)
                {
                    combatHeroEntity.CurrCombatHeroInfo.hp += addHp;
                }
                else
                {
                    
                }
            }
        }

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

        /// <summary>
        /// 复活死亡的英雄
        /// </summary>
        public void ResurrectionDieHero(CombatHeroEntity combatHeroEntity)
        {
            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);
            }

            for (int i = 0; i < heroDispose.Count; i++)
            {
                heroDispose[i].Dispose();
            }

            heroDispose.Clear();
        }

        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);
                }
            }
        }

        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);
        }

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

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

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