River Jiang
2020-10-21 9ecea6fd1dc5c53d670f7e0400210522bda5586d
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
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
using System.Collections.Generic;
using ActionGameFramework.Health;
using Core.Health;
using TowerDefense.Affectors;
using TowerDefense.Towers.Data;
using TowerDefense.UI.HUD;
using UnityEngine;
 
namespace TowerDefense.Towers
{
    /// <summary>
    /// An individual level of a tower
    /// </summary>
    [DisallowMultipleComponent]
    public class TowerLevel : MonoBehaviour, ISerializationCallbackReceiver
    {
        /// <summary>
        /// The prefab for communicating placement in the scene
        /// </summary>
        public TowerPlacementGhost towerGhostPrefab;
 
        /// <summary>
        /// Build effect gameObject to instantiate on start
        /// </summary>
        public GameObject buildEffectPrefab;
 
 
        /// <summary>
        /// 当前的Level对应的DamagerData.
        /// </summary>
        public Damager levelDamager;
 
        /// <summary>
        /// Reference to scriptable object with level data on it
        /// </summary>
        public  TowerLevelData levelData;
 
        /// <summary>
        /// The parent tower controller of this tower
        /// </summary>
        protected Tower m_ParentTower;
 
        /// <summary>
        /// The list of effects attached to the tower
        /// </summary>
        Affector[] m_Affectors;
 
        /// <summary>
        /// TEST CODE: 是否已经缩放.
        /// </summary>
        protected bool bScaleForCombat = false;
 
        /// <summary>
        /// Gets the list of effects attached to the tower
        /// </summary>
        protected Affector[] Affectors
        {
            get
            {
                if (m_Affectors == null)
                {
                    m_Affectors = GetComponentsInChildren<Affector>();
                }
                return m_Affectors;
            }
        }
 
        /// <summary>
        /// The physics layer mask that the tower searches on
        /// </summary>
        public LayerMask mask { get; protected set; }
 
        /// <summary>
        /// Gets the cost value
        /// </summary>
        public int cost
        {
            get { return levelData.cost; }
        }
 
        /// <summary>
        /// Gets the sell value
        /// </summary>
        public int sell
        {
            get { return levelData.sell; }
        }
 
        /// <summary>
        /// Gets the max health
        /// </summary>
        public int maxHealth
        {
            get { return levelData.maxHealth; }
        }
 
        /// <summary>
        /// Gets the starting health
        /// </summary>
        public int startingHealth
        {
            get { return levelData.startingHealth; }
        }
 
        /// <summary>
        /// Gets the tower description
        /// </summary>
        public string description
        {
            get { return levelData.description; }
        }
 
        /// <summary>
        /// Gets the tower description
        /// </summary>
        public string upgradeDescription
        {
            get { return levelData.upgradeDescription; }
        }
 
        /// <summary>
        /// Initialises the Effects attached to this object
        /// </summary>
        public virtual void Initialize(Tower tower, LayerMask enemyMask, IAlignmentProvider alignment)
        {
            mask = enemyMask;
            
            foreach (Affector effect in Affectors)
            {
                effect.Initialize(alignment, mask);
                effect.towerPtr = tower;
            }
            m_ParentTower = tower;
        }
 
        /// <summary>
        /// 当前的TowerLevel设置为对应怪物的材质显示
        /// </summary>
        /// <param name="mat"></param>
        public void SetTowerMonsterMat( Material mat)
        {
            if (mat == null) return;
            // 查找子结点:
            foreach (Transform t in transform.GetComponentsInChildren<Transform>())
            {
                if (t.name == "Cube")
                {
                    t.GetComponent<MeshRenderer>().material = mat;
                    Vector3 scale = t.localScale;
                    
                    if( !this.bScaleForCombat)
                    {
                        scale.z *= 1.267f;
                        t.localScale = scale;
                        Vector3 pos = t.localPosition;
                        pos.z -= 0.2f;
                        t.localPosition = pos;
                        bScaleForCombat = true;
                    }
                }
            }
        }
 
        /// <summary>
        /// A method for activating or deactivating the attached <see cref="Affectors"/>
        /// </summary>
        public void SetAffectorState(bool state,int waveline )
        {
            foreach (Affector affector in Affectors)
            {
                if (affector != null)
                {
                    affector.enabled = state;
                    affector.waveLineID = waveline;
                }
            }
        }
 
 
        /// <summary>
        /// Returns a list of affectors that implement ITowerRadiusVisualizer
        /// </summary>
        /// <returns>ITowerRadiusVisualizers of tower</returns>
        public List<ITowerRadiusProvider> GetRadiusVisualizers()
        {
            List<ITowerRadiusProvider> visualizers = new List<ITowerRadiusProvider>();
            foreach (Affector affector in Affectors)
            {
                var visualizer = affector as ITowerRadiusProvider;
                if (visualizer != null)
                {
                    visualizers.Add(visualizer);
                }
            }
            return visualizers;
        }
 
        /// <summary>
        /// Returns the dps of the tower
        /// </summary>
        /// <returns>The dps of the tower</returns>
        public float GetTowerDps()
        {
            float dps = 0;
            foreach (Affector affector in Affectors)
            {
                var attack = affector as AttackAffector;
                if (attack != null && attack.damagerProjectile != null)
                {
                    dps += attack.GetProjectileDamage() * attack.fireRate;
                }
            }
            return dps;
        }
 
        public void Kill()
        {
            m_ParentTower.KillTower();
        }
 
        public void OnBeforeSerialize()
        {
        }
 
 
        /// <summary>
        /// 获取当前TowerLevel对应的AttackRise.
        /// </summary>
        public float attackRise { get { return m_ParentTower.attackRise; } }
 
        public void OnAfterDeserialize()
        {
            // Setting this member to null is required because we are setting this value on a prefab which will 
            // persists post run in editor, so we null this member to ensure it is repopulated every run
            m_Affectors = null;
        }
 
        /// <summary>
        /// Insntiate the build particle effect object
        /// </summary>
        void Start()
        {
            if (buildEffectPrefab != null)
            {
                Instantiate(buildEffectPrefab, transform);
            }
        }
 
        /// <summary>
        /// 播放升级特效
        /// </summary>
        public void PlayUpGradeEffect()
        {
            if (buildEffectPrefab != null)
            {
                Instantiate(buildEffectPrefab, transform);
            }
        }
    }
}