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
using Core.Input;
using TowerDefense.Level;
using TowerDefense.Towers;
using TowerDefense.UI.HUD;
using UnityEngine;
using UnityInput = UnityEngine.Input;
using State = TowerDefense.UI.HUD.EndlessGameUI.State;
 
namespace TowerDefense.Input
{
    [RequireComponent(typeof(EndlessGameUI))]
    public class EndlessTowerDefenseKeyboardMouseInput : KeyboardMouseInput
    {
        /// <summary>
        /// Cached eference to gameUI
        /// </summary>
        EndlessGameUI m_GameUI;
 
        /// <summary>
        /// 是否处于拖动状态。
        /// </summary>
        protected bool isInDragState = false;
 
        /// <summary>
        /// Register input events
        /// </summary>
        protected override void OnEnable()
        {
            base.OnEnable();
 
            m_GameUI = GetComponent<EndlessGameUI>();
 
            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 (EndlessLevelManager.instanceExists)
            {
                int towerLibraryCount = EndlessLevelManager.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 = EndlessLevelManager.instance.TowerLibrary[key - KeyCode.Alpha1];
                        if (EndlessLevelManager.instance.Currency.CanAfford(controller.purchaseCost))
                        {
                            if (m_GameUI.isBuilding)
                            {
                                m_GameUI.CancelGhostPlacement();
                            }
                            EndlessGameUI.instance.SetToBuildMode(controller);
                            EndlessGameUI.instance.TryMoveGhost(InputController.instance.basicMouseInfo);
                        }
                        break;
                    }
                }
 
                // special case for 0 mapping to index 9
                if (count < 10 && UnityInput.GetKeyDown(KeyCode.Alpha0))
                {
                    Tower controller = EndlessLevelManager.instance.TowerLibrary[9];
                    EndlessGameUI.instance.SetToBuildMode(controller);
                    EndlessGameUI.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);
 
            this.isInDragState = false;
        }
 
        /// <summary>
        /// Select towers or position ghosts
        /// </summary>
        void OnTap(PointerActionInfo pointer)
        {
            // 不允许点击放置,只能拖拽
        }
    }
}