weixudong
2020-11-19 69e0fea6c92fd4e153d45e5f26ef89baecf0405a
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
using Core.Utilities;
using System.Collections.Generic;
using UnityEngine;
 
namespace KTGMGemClient
{
    /// <summary>
    /// 无尽模式buff管理器
    /// </summary>
    public class EndlessBuffManager : Singleton<EndlessBuffManager>
    {
        /// <summary>
        /// 玩家拥有的buff列表
        /// </summary>
        public List<EndlessBuffConfig> BuffList;
 
        /// <summary>
        /// buff处理类实例列表
        /// </summary>
        private List<EndlessBuff> instanceList;
 
        private void Start()
        {
            BuffList = new List<EndlessBuffConfig>();
            // 新增buff,需要把实例添加进来
            instanceList = new List<EndlessBuff>()
            {
                // 攻击力增加的buff没有什么需要处理的,如果需要新写个类继承EndlessBuff即可
                new EndlessBuff(),
                new GoldAdd(),
                new ObtainTower(),
                new DecreaseTowerAttackCD(),
                new CritProbabilityAdd(),
                new CritDamageAdd(),
                new CritBulletAdd(),
                new SlowDown(),
                new FireRateAdd()
            };
        }
 
        /// <summary>
        /// 玩家获得一个buff
        /// </summary>
        public void AddBuff(EndlessBuffConfig buff)
        {
            Debug.Log($"--- 获得buff:id {buff.Config.id}, name:{buff.Config.name} description:{buff.Config.brief} ---");
            ++buff.SelectCount;
 
            // 0表示只要被选择过,以后就不再出现了
            if (buff.Config.is_repeated == 0)
                EndlessBuffData.RemoveFromBuffPool(buff.Config.id);
 
            BuffList.Add(buff);
            EndlessBuff endlessBuff = GetBuffInstanceByType((EndlessBuffEffectType)buff.Config.buff_effect[0]);
 
            endlessBuff.BuffList.Add(buff);
            endlessBuff.Handle();
 
            // 如果是一次性生效的buff,直接移除掉
            if (buff.LifeCycleType == EndlessBuffLifeCycleType.Once)
            {
                endlessBuff.BuffList.Remove(buff);
                RemoveBuff(buff);
            }
        }
 
        /// <summary>
        /// 直接从buff列表中移除某一个buff
        /// </summary>
        /// <param name="buff"></param>
        public void RemoveBuff(EndlessBuffConfig buff)
        {
            BuffList.Remove(buff);
            EndlessBuff endlessBuff = GetBuffInstanceByType((EndlessBuffEffectType)buff.Config.buff_effect[0]);
            endlessBuff.LoseEffect();
        }
 
        /// <summary>
        /// 更新buff列表,以波为单位,一个波次结束后调用此方法去更新buff列表
        /// 这个方法主要是处理buff的生命周期,把无效的移除掉
        /// </summary>
        /// <param name="waves">一次更新的波数,默认以一波为一个节点去更新</param>
        public void UpdateBuffList(int waves = 1)
        {
            int len = BuffList.Count;
 
            for (int i = 0; i < len; ++i)
            {
                if (BuffList[i].LifeCycleType == EndlessBuffLifeCycleType.LimitedWave)
                {
                    BuffList[i].TackEffectWaves += waves;
 
                    if (BuffList[i].TackEffectWaves >= BuffList[i].TotalEffectWaves)
                    {
                        // 超过波次数量限制,移除掉
                        RemoveBuff(BuffList[i]);
                        len = BuffList.Count;
                    }
                }
            }
 
            EventCenter.Ins.BroadCast((int)KTGMGemClient.EventType.EndlessBuffRefresh);
        }
 
        /// <summary>
        /// 根据buff效果类型获得buff列表数据
        /// </summary>
        /// <param name="type">buff效果类型</param>
        /// <param name="id">宝石技能id</param>
        public List<EndlessBuffConfig> GetBuffListByEffectType(EndlessBuffEffectType type, int id)
        {
            List<EndlessBuffConfig> ret = new List<EndlessBuffConfig>();
            // 暂且先这么处理吧 如果1:火 2:水 3:木
            int attributeId = (int)Mathf.Floor(id / 10000f);
 
            for (int i = 0; i < BuffList.Count; ++i)
            {
                if (BuffList[i].EffectType == type)
                {
                    bool isWork = false;
 
                    switch (BuffList[i].UseTarget)
                    {
                        case EndlessBuffUseTarget.All:
                            isWork = true;
                            break;
                        case EndlessBuffUseTarget.Element:
                            isWork = attributeId == BuffList[i].Config.target_type[1];
                            break;
                        case EndlessBuffUseTarget.Designated:
                            isWork = id == BuffList[i].Config.target_type[1];
                            break;
                    }
 
                    if (isWork)
                        ret.Add(BuffList[i]);
                }
            }
 
            return ret;
        }
 
        /// <summary>
        /// 根据buff类型获得buff处理类实例
        /// </summary>
        /// <param name="type"></param>
        /// <returns></returns>
        public EndlessBuff GetBuffInstanceByType(EndlessBuffEffectType type)
        {
            return instanceList[(int)type - 1];
        }
    }
}