NLDClient-yudde/ProjectNLD/Assets/Code/Scripts/Gameplay/Buff/BuffManager.cs

using System.Collections.Generic;
using Gameplay.Level;
using Gameplay.Pool;
using Gameplay.Vehicle.Impl;
using UnityEngine;

namespace Gameplay.Buff
{
    using cfg.BuffCfg;
    using Framework;
    using Bullet;
    using Character;
    using Skill;
    using Common;

    public class BuffManager
    {

        private static BuffManager _instance;

        public static BuffManager instance
        {
            get
            {
                // if (_instance == null)
                // {
                //     DebugUtil.LogError("Buff尚未初始化,请先初始化");
                //     return null;
                // }
                return _instance;
            }
        }

        public static BuffManager CreateInstance()
        {
            if (_instance != null)
            {
                DebugUtil.LogError("请勿重复创建BuffManager");
                return _instance;
            }
            _instance = new BuffManager();
            return _instance;
        }

        private readonly Dictionary<GameUnit, UnitBuffManager> _unitDict;
        private readonly List<UnitBuffManager> _unitList;

        private readonly Dictionary<int, SideBuffManager> _sideBuffManagerDict;

        private BuffManager()
        {
            _unitDict = new Dictionary<GameUnit, UnitBuffManager>();
            _unitList = new List<UnitBuffManager>();
            _sideBuffManagerDict = new Dictionary<int, SideBuffManager>();
        }

        public void Init()
        {
            DebugUtil.Log("[Init]------BuffManager");
        }
        
        public void Dispose()
        {
            DebugUtil.Log("[Dispose]------BuffManager");
            _instance = null;
        }

        public static DataBuff GetBuffConfigById(int id)
        {
            return TableManager.Instance.Tables.BuffConfig.Get(id);
        }

        public BaseBuff CreateBuffById(GameUnit creator,
            int id)
        {
            var buffConfig = GetBuffConfigById(id);
            BaseBuff buff = null;
            switch (buffConfig.BuffType)
            {
                case EBuffType.NormalDamage:
                    buff = ObjPoolManager.instance.Get<NormalDamageBuff>();
                    break;
                case EBuffType.MoraleDamage:
                    buff = ObjPoolManager.instance.Get<MoraleDamageBuff>();
                    break;
                case EBuffType.AutoRecoverMorale:
                    buff = ObjPoolManager.instance.Get<AutoRecoverMoraleBuff>();
                    break;
                case EBuffType.AddMorale:
                    buff = ObjPoolManager.instance.Get<AddMoraleBuff>();
                    break;
                case EBuffType.AddShield:
                    buff = ObjPoolManager.instance.Get<AddShieldBuff>();
                    break;
                case EBuffType.BulletDamage1:
                    buff = ObjPoolManager.instance.Get<BulletDamage1Buff>();
                    break;
                case EBuffType.BulletDamage2:
                    buff = ObjPoolManager.instance.Get<BuffBulletDamage2>();
                    break;
                case EBuffType.BulletDamage3:
                    buff = ObjPoolManager.instance.Get<BuffBulletDamage3>();
                    break;
                case EBuffType.ShowEffect:
                    buff = ObjPoolManager.instance.Get<CreateEffectBuff>();
                    break;
                case EBuffType.ChangeProp:
                    buff = ObjPoolManager.instance.Get<BuffChangeProp>();
                    break;
                case EBuffType.LoopRecoverMorale:
                    buff = ObjPoolManager.instance.Get<BuffLoopAddMorale>();
                    break;
                case EBuffType.Chaos:
                    buff = ObjPoolManager.instance.Get<StatusBuffChaos>();
                    break;
                case EBuffType.Stun:
                    buff = ObjPoolManager.instance.Get<StatusBuffStun>();
                    break;
                case EBuffType.LockPos:
                    buff = ObjPoolManager.instance.Get<StatusBuffLockPos>();
                    break;
                case EBuffType.Retreat:
                    buff = ObjPoolManager.instance.Get<StatusBuffRetreat>();
                    break;
                case EBuffType.NoRetreat:
                    buff = ObjPoolManager.instance.Get<StatusBuffNoRetreat>();
                    break;
                case EBuffType.FillBullet:
                    buff = ObjPoolManager.instance.Get<BuffFillBullet>();
                    break;
                case EBuffType.ClearDBuff:
                    buff = ObjPoolManager.instance.Get<BuffClearDBuff>();
                    break;
                case EBuffType.ClearPBuff:
                    buff = ObjPoolManager.instance.Get<BuffClearPBuff>();
                    break;
                case EBuffType.ClearSBuff:
                    buff = ObjPoolManager.instance.Get<BuffClearSBuff>();
                    break;
                case EBuffType.StandTriggerBuff:
                    buff = ObjPoolManager.instance.Get<BuffStandTrigger>();
                    break;
                case EBuffType.LoopRecoverShiled:
                    buff = ObjPoolManager.instance.Get<BuffLoopAddShiled>();
                    break;
                case EBuffType.AddMoreleFromSkill:
                    buff = ObjPoolManager.instance.Get<SkillBuffAddMorale>();
                    break;
                default:
                    DebugUtil.LogError("CreateBuffById: UnHandle buffType:{0}", buffConfig.BuffType);
                    break;
            }
            if (buff != null)
            {
                buff.Ctor(creator, buffConfig);
            }
            return buff;
        }

        public static void ReturnBuff<T>(T buff) where T : BaseBuff
        {
            ObjPoolManager.instance.Return(buff);
        }

        public void AddBuff(GameUnit unit,
            BaseBuff buff)
        {
            switch (unit.gameunitType)
            {
                case EGameUnitType.Character:
                case EGameUnitType.Vehicle:
                    var unitManager = _unitDict[unit];
                    unitManager.AddBuff(buff);
                    break;
                case EGameUnitType.Summon:
                    // TODO: 召唤物暂时不吃buff
                    break;
                default:
                    DebugUtil.LogError("暂未实现");
                    break;
            }
        }

        public void InitVehicle(NormalVehicle vehicle)
        {
            if (_unitDict.ContainsKey(vehicle))
            {
                DebugUtil.LogError("FATA ERROR: 不应该出现两个相同的vehicle");
                return;
            }
            var unitManager = new UnitBuffManager(vehicle);
            _unitDict.Add(vehicle, unitManager);
            _unitList.Add(unitManager);

            // 双向绑定
            vehicle.buffManager = unitManager;
        }

        public void InitCharacter(Character c)
        {
            if (_unitDict.ContainsKey(c))
            {
                DebugUtil.LogError("FATA ERROR: 不应该出现两个相同的character");
                return;
            }
            var unitManager = new UnitBuffManager(c);
            _unitDict.Add(c, unitManager);
            _unitList.Add(unitManager);

            // 默认全局buff
            var autoRecoverMoraleBuff = CreateBuffById(c, InnerBuffID.AUTO_RECOVER_MORALE);
            unitManager.AddBuff(autoRecoverMoraleBuff);

            // 双向绑定
            c.buffManager = unitManager;
        }

        public void RemoveCharacter(Character c)
        {
            if (!_unitDict.ContainsKey(c))
            {
                DebugUtil.LogError("FATA ERROR: 不应该出现不存在的character");
                return;
            }
            var unitManager = _unitDict[c];
            _unitDict.Remove(c);
            _unitList.Remove(unitManager);
        }



        public void LogicUpdate(float dt)
        {
            if (SkillManager.instance.needSkillPaused)
            {
                return;
            }

            for (var i = 0; i < _unitList.Count; ++i)
            {
                var unit = _unitList[i];
                unit.LogicUpdate(dt);
            }
        }

    }
}