River Jiang
2020-10-27 24f59b89e9eabcfe948fc0ba304a8dbec2deda14
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
using Core.Input;
using TowerDefense.Level;
using TowerDefense.Towers;
using TowerDefense.UI.HUD;
using UnityEngine;
using UnityInput = UnityEngine.Input;
using State = TowerDefense.UI.HUD.GameUI.State;
 
namespace TowerDefense.Input
{
    [RequireComponent(typeof(GameUI))]
    public class TowerDefenseKeyboardMouseInput : KeyboardMouseInput
    {
        /// <summary>
        /// Cached eference to gameUI
        /// </summary>
        GameUI m_GameUI;
 
        /// <summary>
        /// 是否处于拖动状态。
        /// </summary>
        protected bool isInDragState = false;
 
        /// <summary>
        /// Register input events
        /// </summary>
        protected override void OnEnable()
        {
            base.OnEnable();
            
            m_GameUI = GetComponent<GameUI>();
 
            if (InputController.instanceExists)
            {
                InputController controller = InputController.instance;
 
                controller.tapped += OnTap;
                controller.mouseMoved += OnMouseMoved;
 
                // River Add for Mouse Start Drag & Draged.
                controller.startedDrag += OnStartDrag;
                controller.dragged += this.OnDrag;
                controller.released += this.OnEndDrag;
            }
        }        
 
 
        /// <summary>
        /// Deregister input events
        /// </summary>
        protected override void OnDisable()
        {
            if (!InputController.instanceExists)
            {
                return;
            }
 
            InputController controller = InputController.instance;
 
            controller.tapped -= OnTap;
            controller.mouseMoved -= OnMouseMoved;
 
            controller.startedDrag -= this.OnStartDrag;
            controller.dragged -= this.OnDrag;
            controller.released -= this.OnEndDrag;
        }
 
        /// <summary>
        /// Handle camera panning behaviour
        /// </summary>
        protected override void Update()
        {
            base.Update();
            
            // Escape handling
            if (UnityInput.GetKeyDown(KeyCode.Escape))
            {
                switch (m_GameUI.state)
                {
                    case State.Normal:
                        if (m_GameUI.isTowerSelected)
                        {
                            m_GameUI.DeselectTower();
                        }
                        else
                        {
                            m_GameUI.Pause();
                        }
                        break;
                    case State.BuildingWithDrag:
                    case State.Building:
                        m_GameUI.CancelGhostPlacement();
                        break;
                }
            }
            
            // place towers with keyboard numbers
            if (LevelManager.instanceExists)
            {
                int towerLibraryCount = LevelManager.instance.towerLibrary.Count;
 
                // find the lowest value between 9 (keyboard numbers)
                // and the amount of towers in the library
                int count = Mathf.Min(9, towerLibraryCount);
                KeyCode highestKey = KeyCode.Alpha1 + count;
 
                for (var key = KeyCode.Alpha1; key < highestKey; key++)
                {
                    // add offset for the KeyCode Alpha 1 index to find correct keycodes
                    if (UnityInput.GetKeyDown(key))
                    {
                        Tower controller = LevelManager.instance.towerLibrary[key - KeyCode.Alpha1];
                        if (LevelManager.instance.currency.CanAfford(controller.purchaseCost))
                        {
                            if (m_GameUI.isBuilding)
                            {
                                m_GameUI.CancelGhostPlacement();
                            }
                            GameUI.instance.SetToBuildMode(controller);
                            GameUI.instance.TryMoveGhost(InputController.instance.basicMouseInfo);
                        }
                        break;
                    }
                }
 
                // special case for 0 mapping to index 9
                if (count < 10 && UnityInput.GetKeyDown(KeyCode.Alpha0))
                {
                    Tower controller = LevelManager.instance.towerLibrary[9];
                    GameUI.instance.SetToBuildMode(controller);
                    GameUI.instance.TryMoveGhost(InputController.instance.basicMouseInfo);
                }
            }
        }
 
        /// <summary>
        /// Ghost follows pointer
        /// </summary>
        void OnMouseMoved(PointerInfo pointer)
        {
            // We only respond to mouse info
            var mouseInfo = pointer as MouseCursorInfo;
 
            if ((mouseInfo != null) && (m_GameUI.isBuilding))
            {
                m_GameUI.TryMoveGhost(pointer, false);
            }
        }
 
        protected virtual void OnStartDrag(PointerActionInfo pointer)
        {
            // select towers
            m_GameUI.TrySelectTower(pointer);
            // River: 为了开始拖动后可以直接显示GhostTower
            m_GameUI.TryMoveGhost(pointer, false);
 
            this.isInDragState = true;
        }
 
        protected override void OnDrag(PointerActionInfo pointer)
        {
            if ((pointer != null) && (m_GameUI.isBuilding))
            {
                m_GameUI.TryMoveGhost(pointer, false);
            }
        }
 
        protected void OnEndDrag(PointerActionInfo pointer)
        {
            // EndDrag 只能放置相关的GhostTower.
            if (this.isInDragState)
                m_GameUI.onEndTowerDrag(pointer);
                //m_GameUI.TryPlaceTower(pointer);
 
            this.isInDragState = false;
        }
 
 
        /// <summary>
        /// Select towers or position ghosts
        /// </summary>
        void OnTap(PointerActionInfo pointer)
        {
            // We only respond to mouse info
            var mouseInfo = pointer as MouseButtonInfo;
 
            if (mouseInfo != null && !mouseInfo.startedOverUI)
            {
                if (m_GameUI.isBuilding)
                {
                    if (mouseInfo.mouseButtonId == 0) // LMB confirms
                    {
                        if( m_GameUI.TryPlaceTower(pointer))
                        {
                            // 开启相应的兵线:
                            Tower tw = m_GameUI.FindTowerWithGridIdx(m_GameUI.currentGrid.x, m_GameUI.currentGrid.y);
                            if ((tw != null) && (tw.bInAttackMode ))
                                LevelManager.instance.startWaveLine(m_GameUI.currentGrid.x, false, tw.attributeId);
                        }
                    }
                    else // RMB cancels
                    {
                        m_GameUI.CancelGhostPlacement();
                    }
                }
                else
                {
                    if (mouseInfo.mouseButtonId == 0)
                    {
                        // select towers
                        m_GameUI.TrySelectTower(pointer);
                        // River: 为了TAP后立刻显示出来相关的Ghost.
                        m_GameUI.TryMoveGhost(pointer, false);
 
                    }
                }
            }
        }
    }
}