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 Utility.UITool;
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 moveDir = Vector3.forward;
        public float moveSpeed = 2f;
        public bool isFlight;
        private bool _isFlightCameraFinish;
        private float _flightTime;
        private float _flightAddTime;
        private float _flightCurrTime;
        private Vector3 _flightDir;
        private Vector3 _flightStartDir;
        private float _flightStartSpeed;
        private float _flightSpeed;
        private ParticleSystemPool _flightFx1;
        private ParticleSystemPool _flightFx2;

        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);
            CombatHeroInfo combatHeroInfo = new CombatHeroInfo();
            combatHeroInfo.attack = (EncryptionLong)10;
        }

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

        public async CTask<SummonCombatHeroEntity> SummonHero(CombatHeroInfo combatHeroInfo,
            CombatHeroEntity ownerEntity, Vector3 pos, float time, System.Action<SummonCombatHeroEntity> summonCallBack)
        {
            SummonCombatHeroEntity summonCombatHeroEntity = new SummonCombatHeroEntity();
            summonCombatHeroEntity.IsEnemy = ownerEntity.IsEnemy;
            summonCombatHeroEntity.ownerEntity = ownerEntity;
            summonCombatHeroEntity.Time = time;
            summonCombatHeroEntity.isCreateHeroHp = true;
            await summonCombatHeroEntity.Init(new CombatHeroAi(), combatHeroInfo, pos,
                delegate(CombatHeroEntity entity)
                {
                    CombatController.currActiveCombat.CombatHeroController.AddHero(entity);
                    summonCallBack?.Invoke(summonCombatHeroEntity);
                });
            return summonCombatHeroEntity;
        }

        /// <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 Vector3 GetTarget(float d)
        {
            if (CombatController.currActiveCombat.playerHeroEntity == null)
            {
                return new Vector3(0, 20, 0);
            }

            return CombatController.currActiveCombat.playerHeroEntity.dotPos + moveDir * d;
        }

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

            if (isFlight)
            {
                _flightCurrTime += t * _flightAddTime;
                moveDir = Vector3.Lerp(_flightStartDir, _flightDir, _flightCurrTime);
                float flightSpeedCur =
                    AnimationCurveManager.Instance.AnimationCurveLibrary.flightSpeedCurve.Evaluate(_flightCurrTime);
                moveSpeed = Mathf.Lerp(_flightStartSpeed, _flightSpeed, flightSpeedCur);
                if (_flightCurrTime > 0.95f&&!_isFlightCameraFinish)
                {
                    _isFlightCameraFinish= true;
                    CombatController.currActiveCombat.CombatCameraControllder.SetFieldOfView(70, 1);
                }

                if (_flightCurrTime >= 1)
                {
                    moveDir = _flightDir;
                    isFlight = false;
                    moveSpeed = 2;
                    GObjectPool.Instance.Recycle(_flightFx1);
                    GObjectPool.Instance.Recycle(_flightFx2);
                    
                    CombatController.currActiveCombat.playerHeroEntity.PlayAnim("idle", true, 0, false, 1);
                }
            }
        }

        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 async CTask Flight(float time, float jiaoDu, float speed)
        {
            _flightCurrTime = 0;
            _flightTime = time;
            _flightAddTime = 1.0f / time;
            isFlight = true;
            _isFlightCameraFinish = false;
            Quaternion quaternion = Quaternion.Euler(0, jiaoDu, 0);
            _flightDir = quaternion * moveDir;
            _flightStartDir = moveDir;
            _flightStartSpeed = moveSpeed;
            _flightSpeed = speed;
            CombatController.currActiveCombat.playerHeroEntity.PlayAnim("idle2", true, 0, false, 1);
            CombatController.currActiveCombat.CombatCameraControllder.SetFieldOfView(90, 0.5f);
            GObjectPool.Instance.Recycle(_flightFx1);
            GObjectPool.Instance.Recycle(_flightFx2);
            GObjectPool.Instance.FetchAsync<ParticleSystemPool>("fx fly qi", delegate(ParticleSystemPool pool)
            {
                _flightFx1 = pool;
                SpecialDotInfo specialDotInfo =
                    CombatController.currActiveCombat.playerHeroEntity.GetSpecialDotInfo("hitpos");
                pool.own.transform.SetParent(specialDotInfo.targetTran);
                pool.own.transform.localPosition = Vector3.zero;
            });
            GObjectPool.Instance.FetchAsync<ParticleSystemPool>("fx zq jian loop", delegate(ParticleSystemPool pool)
            {
                _flightFx2 = pool;

                pool.own.transform.SetParent(CombatController.currActiveCombat.playerHeroEntity.GameObject.transform);
                pool.own.transform.localPosition = Vector3.zero;
            });
        }

        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()
        {
            for (int i = 0; i < myHero.Count; i++)
            {
                myHero[i].DisposeForOnetCombat();
            }

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

            myHero.Clear();
            enemyHero.Clear();
            CombatEventManager.Instance.RemoveEventListener(CombatEventType.UseSkill, CombatUseSkillEventData);
        }

        public void CombatFinishDispose()
        {
            for (int i = 0; i < enemyHero.Count; i++)
            {
                enemyHero[i].Dispose();
            }

            enemyHero.Clear();
            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 BetterList<CombatHeroEntity> GetHeroList(bool isEnemy)
        {
            if (isEnemy)
            {
                return enemyHero;
            }
            else
            {
                return myHero;
            }
        }

        public CombatHeroEntity[] GetHero(bool isEnemy, out int count)
        {
            if (isEnemy)
            {
                count = enemyHero.Count;

                return enemyHero.ToArray();
            }
            else
            {
                count = myHero.Count;
                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();
            }
        }
    }
}