//using Boo.Lang;
using Core.Health;
using Core.Input;
using Core.Utilities;
using DG.Tweening;
using JetBrains.Annotations;
using System;
using System.Collections.Generic;
using TMPro;
using TowerDefense.Level;
using TowerDefense.Towers;
using TowerDefense.Towers.Placement;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.UI;

namespace TowerDefense.UI.HUD
{
    /// <summary>
    /// A game UI wrapper for a pointer that also contains raycast information
    /// </summary>
    public struct UIPointer
    {
        /// <summary>
        /// The pointer info
        /// </summary>
        public PointerInfo pointer;

        /// <summary>
        /// The ray for pointer
        /// </summary>
        public Ray ray;

        /// <summary>
        /// The raycast hit object into the 3D scene
        /// </summary>
        public RaycastHit? raycast;

        /// <summary>
        /// 射线击中的兵线.
        /// </summary>
        public RaycastHit? wavelineHit;

        /// <summary>
        /// True if pointer started over a UI element or anything the event system catches
        /// </summary>
        public bool overUI;

        /// <summary>
        /// 是否碰撞到相应的兵线层数据
        /// </summary>
        public bool overWaveLine;
    }

    /// <summary>
    /// An object that manages user interaction with the game. Its responsibilities deal with
    /// <list type="bullet">
    ///     <item>
    ///         <description>Building towers</description>
    ///     </item>
    ///     <item>
    ///         <description>Selecting towers and units</description>
    ///     </item>
    /// </list>
    /// </summary>
    [RequireComponent(typeof(Camera))]
    public class GameUI : Singleton<GameUI>
    {
        /// <summary>
        /// The states the UI can be in
        /// </summary>
        public enum State
        {
            /// <summary>
            /// The game is in its normal state. Here the player can pan the camera, select units and towers
            /// </summary>
            Normal,

            /// <summary>
            /// The game is in 'build mode'. Here the player can pan the camera, confirm or deny placement
            /// </summary>
            Building,

            /// <summary>
            /// The game is Paused. Here, the player can restart the level, or quit to the main menu
            /// </summary>
            Paused,

            /// <summary>
            /// The game is over and the level was failed/completed
            /// </summary>
            GameOver,

            /// <summary>
            /// The game is in 'build mode' and the player is dragging the ghost tower
            /// </summary>
            BuildingWithDrag
        }

        /// <summary>
        /// Gets the current UI state
        /// </summary>
        public State state { get; private set; }

        /// <summary>
        /// 局内塔防类型的升级数据
        /// </summary>
        public List<SceneTowerLvl> sceneTowerLvlList;

        /// <summary>
        /// The currently selected tower
        /// </summary>
        public LayerMask placementAreaMask;

        /// <summary>
        /// 兵线层对应的Mask.
        /// </summary>
        public LayerMask waveLineMask;

        /// <summary>
        /// 战场区域Mask.
        /// </summary>
        public LayerMask battleAreaMask;


        /// <summary>
        /// The layer for tower selection
        /// </summary>
        public LayerMask towerSelectionLayer;

        /// <summary>
        /// The physics layer for moving the ghost around the world
        /// when the placement is not valid
        /// </summary>
        public LayerMask ghostWorldPlacementMask;

        public readonly int MAX_TOWERNUM = 15;

        /// <summary>
        /// The radius of the sphere cast 
        /// for checking ghost placement
        /// </summary>
        public float sphereCastRadius = 1;

        /// <summary>
        /// Component that manages the radius visualizers of ghosts and towers
        /// River: 塔防范围显示数据，可以考虑去除掉. 目前已经去掉显示相关的内容
        /// </summary>
        public RadiusVisualizerController radiusVisualizerController;

        /// <summary>
        /// The UI controller for displaying individual tower data
        /// 这是点击每一个防塔需要弹出的UI，需要理清这里面的关系
        /// </summary>
        //public TowerUI towerUI;

        /// <summary>
        /// The UI controller for displaying tower information
        /// whilst placing
        /// </summary>
        public BuildInfoUI buildInfoUI;

        /// <summary>
        /// 随机购买塔防的按钮.
        /// </summary>
        public Button randomTowerBtn;

        /// <summary>
        /// 飘血数字对应的prefab.
        /// </summary>
        public TextMoveDoTween bloodText;

        /// <summary>
        /// 中毒飘字.
        /// </summary>
        public TextMoveDoTween bloodPoison;

        /// <summary>
        /// 暴击飘字.
        /// </summary>
        public TextMoveDoTween bloodCrit;

        /// <summary>
        /// 购买塔防按钮上的Text.
        /// </summary>
        protected TextMeshProUGUI towerPriceText;
        protected bool tdBuyDisable = false;

        /// <summary>
        /// 鼠标在移动一个Tower之前，要隐藏的Tower数据和指针。
        /// </summary>
        protected Tower towerToMove = null;

        /// <summary>
        /// UI界面对应的进度
        /// </summary>
        protected int uiCtlProgresss = 0;


        /// <summary>
        /// Fires when the <see cref="State"/> changes
        /// should only allow firing when TouchUI is used
        /// </summary>
        public event Action<State, State> stateChanged;

        /// <summary>
        /// Fires off when the ghost was previously not valid but now is due to currency amount change
        /// </summary>
        public event Action ghostBecameValid;

        /// <summary>
        /// Fires when a tower is selected/deselected
        /// </summary>
        public event Action<Tower> selectionChanged;

        /// <summary>
        /// 成长骰子对应的Timer.
        /// </summary>
        protected List<Timer> listTowerTimer = new List<Timer>();
        protected Dictionary<int, Tower> towerTimeDic = new Dictionary<int, Tower>();

        /// <summary>
        /// Placement area ghost tower is currently on
        /// </summary>
        IPlacementArea m_CurrentArea;

        /// <summary>
        /// 对手放置塔防的区域.
        /// </summary>
        IPlacementArea m_OpponentArea;



        /// <summary>
        /// Grid position ghost tower in on
        /// </summary>
        IntVector2 m_GridPosition;

        /// <summary>
        /// Our cached camera reference
        /// </summary>
        Camera m_Camera;

        /// <summary>
        /// Current tower placeholder. Will be null if not in the <see cref="State.Building" /> state.
        /// </summary>
        TowerPlacementGhost m_CurrentTower;

        // TowerList用于简单记录相关的数据
        protected List<Tower> m_listTower = new List<Tower>();

        /// <summary>
        /// Tracks if the ghost is in a valid location and the player can afford it
        /// </summary>
        bool m_GhostPlacementPossible;

        /// <summary>
        /// Gets the current selected tower
        /// </summary>
        public Tower currentSelectedTower { get; private set; }

        /// <summary>
        /// 拖动塔防时，原塔防的等级。
        /// </summary>
        protected int dragTowerLevel = 0;

        /// <summary>
        /// 选中Tower时候的鼠标点击坐标与Tower中心所在的屏幕坐标之间的偏移值.
        /// </summary>
        protected Vector2 selTowerOffset = new Vector2();

        // 测试屏幕显示相关的倒计时.
        protected bool bLoaded = false;

        public IntVector2 currentGrid
        {
            get { return m_GridPosition; }
        }

        /// <summary>
        /// Gets whether a tower has been selected
        /// </summary>
        public bool isTowerSelected
        {
            get { return currentSelectedTower != null; }
        }

        public IPlacementArea selfTowerPlaceArea
        {
            get
            {
                if (m_CurrentArea == null)
                {
                    GameObject placeObj = GameObject.FindGameObjectWithTag("PlaceTower");
                    if (placeObj != null)
                        m_CurrentArea = placeObj.GetComponent<IPlacementArea>();
                }
                return m_CurrentArea;
            }
        }
        /// <summary>
        /// 增加一个防塔的数据结构，测试数据
        /// </summary>
        /// <param name="t"></param>
        public void addTower(Tower t)
        {
            if (t.opponentSide)
            {
                t.bInAttackMode = true;
                OpponentMgr.instance.addTower(t);
                return;
            }

            m_listTower.Add(t);

            // 当前所在的位置是否攻击位置,随手瞎写：
            if (t.gridPosition.y == 2)
                t.bInAttackMode = true;
            else
                t.bInAttackMode = false;


            // ATTENTION TO FIX: 先写死，有一个简单的逻辑再说:
            if (m_listTower.Count >= MAX_TOWERNUM)
                disableRandomTowerBtn();
        }

        /// <summary>
        /// 根据塔位索引位置，查找位置上是否有对应的塔防数据。
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <returns></returns>
        public Tower FindTowerWithGridIdx(int x, int y)
        {
            foreach (Tower lt in m_listTower)
            {
                if ((lt.gridPosition.x == x) && (lt.gridPosition.y == y))
                    return lt;
            }
            return null;
        }

        public bool towerInList(Tower t)
        {
            return m_listTower.Contains(t);
        }

        public void delTower(Tower t)
        {
            // 删除Tower之前去掉充能条数据.
            if( t.bInAttackMode)
                t.DisableTowerUICtrl();

            // 删除Tower有可能对应的Timer.
            foreach (var tdata in towerTimeDic)
            {
                if (tdata.Value == t)
                {
                    // 先删除对应的timer数据:
                    foreach (var timer in listTowerTimer)
                    {
                        if (tdata.Key == timer.timerID)
                        {
                            listTowerTimer.Remove(timer);
                            break;
                        }
                    }

                    // 删除字典并退出:
                    towerTimeDic.Remove(tdata.Key);
                    break;
                }
            }


            if (t.opponentSide)
            {
                OpponentMgr.instance.removeTower(t);
                return;
            }
            int tcnt = m_listTower.Count;
            m_listTower.Remove(t);
            if (tcnt == MAX_TOWERNUM)
                enableRandomTowerBtn();
        }

        /// <summary>
        /// 清空缓存数据
        /// </summary>
        public void restartLevel()
        {
            m_listTower.Clear();
            listTowerTimer.Clear();
            towerTimeDic.Clear();
        }

        /// <summary>
        /// 查找相同类型，相同段位的Tower
        /// </summary>
        /// <param name="t"></param>
        public Tower findSameLvlTower(Tower t)
        {
            Tower rest = null;

            foreach (Tower lt in m_listTower)
            {
                if (lt == t) continue;
                if ((lt.currentLevel == t.currentLevel) &&
                    (lt.towerName == t.towerName))
                {
                    return lt;
                }
            }
            return rest;
        }

        /// <summary>
        /// Gets whether certain build operations are valid
        /// </summary>
        public bool isBuilding
        {
            get
            {
                return state == State.Building || state == State.BuildingWithDrag;
            }
        }

        /// <summary>
        /// Cancel placing the ghost
        /// </summary>
        public void CancelGhostPlacement()
        {
            /*
			if (!isBuilding)
			{
				throw new InvalidOperationException("Can't cancel out of ghost placement when not in the building state.");
			}*/

            if (buildInfoUI != null)
            {
                buildInfoUI.Hide();
            }
            if (m_CurrentTower)
                Destroy(m_CurrentTower.gameObject);
            m_CurrentTower = null;
            SetState(State.Normal);
            DeselectTower();
            //Debug.Log("CancelGhostPlacement called.");
        }

        /// <summary>
        /// Returns the GameUI to dragging mode with the curent tower
        /// </summary>
        /// /// <exception cref="InvalidOperationException">
        /// Throws exception when not in build mode
        /// </exception>
        public void ChangeToDragMode()
        {
            if (!isBuilding)
            {
                throw new InvalidOperationException("Trying to return to Build With Dragging Mode when not in Build Mode");
            }
            SetState(State.BuildingWithDrag);
        }

        /// <summary>
        /// Returns the GameUI to BuildMode with the current tower
        /// </summary>
        /// <exception cref="InvalidOperationException">
        /// Throws exception when not in Drag mode
        /// </exception>
        public void ReturnToBuildMode()
        {
            if (!isBuilding)
            {
                throw new InvalidOperationException("Trying to return to Build Mode when not in Drag Mode");
            }
            SetState(State.Building);
        }


        /// <summary>
        /// Changes the state and fires <see cref="stateChanged"/>
        /// </summary>
        /// <param name="newState">The state to change to</param>
        /// <exception cref="ArgumentOutOfRangeException">thrown on an invalid state</exception>
        void SetState(State newState)
        {
            if (state == newState)
            {
                return;
            }
            State oldState = state;
            if (oldState == State.Paused || oldState == State.GameOver)
            {
                Time.timeScale = 1f;
            }

            switch (newState)
            {
                case State.Normal:
                    break;
                case State.Building:
                    break;
                case State.BuildingWithDrag:
                    break;
                case State.Paused:
                case State.GameOver:
                    if (oldState == State.Building)
                    {
                        CancelGhostPlacement();
                    }
                    Time.timeScale = 0f;
                    break;
                default:
                    throw new ArgumentOutOfRangeException("newState", newState, null);
            }
            state = newState;
            if (stateChanged != null)
            {
                stateChanged(oldState, state);
            }
        }

        /// <summary>
        /// Called when the game is over
        /// </summary>
        public void GameOver()
        {
            SetState(State.GameOver);
        }

        /// <summary>
        /// Pause the game and display the pause menu
        /// </summary>
        public void Pause()
        {
            SetState(State.Paused);
        }

        /// <summary>
        /// Resume the game and close the pause menu
        /// </summary>
        public void Unpause()
        {
            SetState(State.Normal);
        }

        /// <summary>
        /// Changes the mode to drag
        /// </summary>
        /// <param name="towerToBuild">
        /// The tower to build
        /// </param>
        /// <exception cref="InvalidOperationException">
        /// Throws exception when trying to change to Drag mode when not in Normal Mode
        /// </exception>
        public void SetToDragMode([NotNull] Tower towerToBuild)
        {
            if (state != State.Normal)
            {
                throw new InvalidOperationException("Trying to enter drag mode when not in Normal mode");
            }

            if (m_CurrentTower != null)
            {
                // Destroy current ghost
                CancelGhostPlacement();
            }
            SetUpGhostTower(towerToBuild);
            SetState(State.BuildingWithDrag);
        }

        /// <summary>
        /// 点击某一个塔防之后，开启拖动塔防的模式。
        /// River: 修改为暂不删除原来的Tower，把原来的Tower隐藏掉.
        /// </summary>
        /// <param name="towerOld"></param>
        public void startDragTower(Tower towerOld)
        {
            // 
            Tower newT = null;// Instantiate(towerOld, transform);
            foreach (Tower tower in LevelManager.instance.towerLibrary)
            {
                if (tower.towerName != towerOld.towerName)
                    continue;

                newT = Instantiate(tower, transform);
                break;
            }

            //
            // 重设界面数据
            uiCtlProgresss = 0;

            // 从列表中删除Tower.并破坏Tower的外形。
            dragTowerLevel = towerOld.currentLevel;
            // 尝试不再删除原来的Tower,而是尝试在合成成功后再删除原来的Tower
            towerOld.showTower(false);
            towerToMove = towerOld;

            if( towerOld.bInAttackMode)
            {
                int pro = towerOld.GetTowerUICtrlProgress();
                uiCtlProgresss = pro;
            }

            // 先删除，再设置移动相关。
            SetToDragMode(newT);

            if (towerOld.towerFeature == EFeatureTower.Skill_Bomb)
                m_CurrentTower.SetAttackArea(dragTowerLevel, towerOld.attributeId);
        }

        /// <summary>
        /// Sets the UI into a build state for a given tower
        /// River: 当界面上某一个塔防的按钮被按下后，需要调用的这个函数进入建造模式。
        /// </summary>
        /// <param name="towerToBuild">
        /// The tower to build
        /// </param>
        /// <exception cref="InvalidOperationException">
        /// Throws exception trying to enter Build Mode when not in Normal Mode
        /// </exception>
        public void SetToBuildMode([NotNull] Tower towerToBuild)
        {
            if (state != State.Normal)
            {
                throw new InvalidOperationException("Trying to enter Build mode when not in Normal mode");
            }

            if (m_CurrentTower != null)
            {
                // Destroy current ghost
                CancelGhostPlacement();
            }
            SetUpGhostTower(towerToBuild);
            SetState(State.Building);
        }

        /// <summary>
        /// 目标位置是否是可攻击属性的空塔位
        /// </summary>
        /// <param name="pinfo"></param>
        /// <returns></returns>
        protected bool isFreeAttackGrid(PointerInfo pinfo)
        {
            // 判断格子上的塔防:
            UIPointer pointer = WrapPointer(pinfo);
            Tower sTower = PickTowerInGrid(pointer);
            if (sTower != null)
                return false;

            if ((m_GridPosition.x >= 0) && (m_GridPosition.y >= 0))
            {
                if (m_CurrentArea.isFreeAtackPos(m_GridPosition.x, m_GridPosition.y))
                    return true;
            }

            return false;
        }

        /// <summary>
        /// 是否是可开启的AttackGrid塔位.
        /// </summary>
        /// <param name="pinfo"></param>
        /// <returns></returns>
        protected bool isWaitBuyAttackGrid(PointerInfo pinfo)
        {
            // 判断格子上的塔防:
            UIPointer pointer = WrapPointer(pinfo);
            Tower sTower = PickTowerInGrid(pointer);
            if (sTower != null)
                return false;

            if ((m_GridPosition.x >= 0) && (m_GridPosition.y >= 0))
            {
                if (m_CurrentArea.isWaitBuyGrid(m_GridPosition.x, m_GridPosition.y))
                    return true;
            }

            return false;
        }

        /// <summary>
        /// 目标位置是否有同等级同类型的Tower.
        /// </summary>
        /// <param name="pinfo"></param>
        /// <returns></returns>
        protected bool isValidateCombineTarget(PointerInfo pinfo)
        {
            // 判断是否格子上重复放置塔防
            if (m_CurrentTower == null || !IsGhostAtValidPosition())
            {
                // 最大级别的Tower不能再合并了.
                if (towerToMove.isAtMaxLevel)
                    return false;

                // 判断格子上的塔防:
                UIPointer pointer = WrapPointer(pinfo);
                Tower sTower = PickTowerInGrid(pointer);
                if ((sTower != null) && (sTower != towerToMove))
                {
                    //Tower curTower = m_CurrentTower.controller;
                    int testLvl = dragTowerLevel;

                    if ((towerToMove != null) && (sTower.currentLevel == testLvl) &&
                        (sTower.towerName == towerToMove.towerName))
                    {
                        return true;
                    }
                }
            }
            return false;
        }

        /// <summary>
        /// 获取目标格子上的塔防的名字数据
        /// </summary>
        /// <param name="pinfo"></param>
        /// <returns></returns>
        protected string getTargetTowerName(PointerInfo pinfo)
        {
            if (m_CurrentTower == null || !IsGhostAtValidPosition())
            {
                // 获取目标格子上的塔防指针：
                UIPointer pointer = WrapPointer(pinfo);
                Tower sTower = PickTowerInGrid(pointer);
                if ((sTower != null) && (sTower != towerToMove))
                {
                    return sTower.towerName;
                }
            }
            return "";
        }


        /// <summary>
        /// 成长骰子升级为高一级别的随机骰子.
        /// </summary>
        /// <param name="tower"></param>
        protected void growUpTower(Tower tower)
        {
            Tower newTower = RandomTower.instance.GetRandomTower(false, false);

            // 所有的Tower不能升级成为FeatureTower.
            int maxLoop = 20;
            while (newTower.towerFeature != EFeatureTower.NULL)
            {
                newTower = RandomTower.instance.GetRandomTower(false, false);
                maxLoop--;
                if (maxLoop <= 0)
                {
                    newTower = RandomTower.instance.getRTower();
                    Debug.LogError("超级循环发生了.");
                    break;
                }
            }

            // 成长为高一级别的骰子
            DisplaceTower(newTower, tower, 1);
        }


        /// <summary>
        /// 破坏某一列的塔位数据
        /// </summary>
        /// <param name="yidx"></param>
        /// <param name="opponent"></param>
        public void DestroyTowerGrid(int xidx, bool opponent = false)
        {
            // 不管是正方还是反方，当前的兵线不再出兵.
            LevelManager.instance.stopWaveLine(xidx, true);
            LevelManager.instance.stopWaveLine(xidx, false);
            HealthHeartState.instance.killHeart(opponent);

            if (opponent)
            {
                int yidx = 0;
                Tower selTower = OpponentMgr.instance.getTower(xidx, yidx);
                //FindTowerWithGridIdx(xidx, yidx);
                if (selTower)
                {
                    delTower(selTower);
                    selTower.Sell();
                }

                // 再破坏对应的塔位数据
                if (m_OpponentArea != null)
                    m_OpponentArea.SetDestroyedGrid(xidx, yidx);
            }
            else
            {
                // 先删除当前位置的塔防数据,Y索引一定是2.
                int yidx = 2;
                Tower selTower = FindTowerWithGridIdx(xidx, yidx);
                if (selTower)
                {
                    delTower(selTower);
                    selTower.Sell();
                }

                // 再破坏对应的塔位数据
                if (m_CurrentArea != null)
                    m_CurrentArea.SetDestroyedGrid(xidx, yidx);
            }
        }

        /// <summary>
        /// 拖动一个Tower之后，松开鼠标或者EndDrag.
        /// 1: 目标点可合成，则直接合成。
        /// 2: 目标点不管是空白，还是不能放置Tower，都要让当前的Tower返回到原来的TowerPlace
        /// </summary>
        /// <param name="pointerInfo"></param>
        public void onEndTowerDrag(PointerInfo pointerInfo)
        {
            bool bSkill = false;
            if ((m_CurrentTower == null) || (m_CurrentTower.controller == null))
            {
                CancelPlaceTower(pointerInfo);
                return;
            }

            if (m_CurrentTower.controller.towerFeature != EFeatureTower.NULL)
                bSkill = true;
            // 判断目标位置是否有Tower且类型和等级一致,如果没有，则GhostTower删除，原Tower显示。
            if (isValidateCombineTarget(pointerInfo))
            {
                // 如果当前是处于攻击状态的Tower,则需要做相应的处理：
                if (towerToMove.bInAttackMode)
                    LevelManager.instance.stopWaveLine(towerToMove.gridPosition.x, true);

                TryPlaceTower(pointerInfo);
            }
            else if (isFreeAttackGrid(pointerInfo) && (!bSkill))
            {
                if (!TryPlaceTower(pointerInfo, false, true)) return;

                // 删除towerToMove，确保塔防数据不再出现多个
                if (towerToMove != null)
                {
                    // 如果当前是处于攻击状态的Tower,则需要做相应的处理：
                    if (towerToMove.bInAttackMode)
                        LevelManager.instance.stopWaveLine(towerToMove.gridPosition.x, true);

                    delTower(towerToMove);
                    towerToMove.showTower(true);
                    towerToMove.Sell();
                    towerToMove = null;

                }

                // 开启相应的兵线:
                Tower tw = FindTowerWithGridIdx(m_GridPosition.x, m_GridPosition.y);
                if (tw != null)
                {
                    LevelManager.instance.startWaveLine(m_GridPosition.x, false, tw.attributeId);
                    
                    // 顺便设置界面的进展
                    if (uiCtlProgresss > 0)
                    {
                        tw.SetTowerUICtlProcess(uiCtlProgresss);
                        Debug.Log("设置当前的进度:" + uiCtlProgresss);
                        uiCtlProgresss = 0;
                    }
                }
            }
            // 当前是Skill塔位的状态.
            else if (bSkill)
            {
                if (SkillPlayEndDrag(pointerInfo))
                {
                    // 先释放掉当前的Ghost塔防.
                    CancelGhostPlacement();

                    // 删除towerToMove，确保塔防数据不再出现多个
                    if (towerToMove != null)
                    {
                        delTower(towerToMove);
                        towerToMove.showTower(true);
                        towerToMove.Sell();
                        towerToMove = null;
                    }
                }
                else
                {
                    CancelPlaceTower(pointerInfo);
                }
            }
            else
            {
                CancelPlaceTower(pointerInfo);
            }
        }

        protected bool SkillPlayEndDrag(PointerInfo pointer)
        {
            // 我操，终于可以了！ATTENTION TO OPP:
            PointerInfo tp = new PointerActionInfo();
            tp.currentPosition = pointer.currentPosition;
            tp.previousPosition = pointer.previousPosition;
            tp.delta = pointer.delta;
            tp.startedOverUI = pointer.startedOverUI;
            // River: 调整偏移值,用于鼠标移动塔防的时候，更加平滑。
            tp.currentPosition.x += selTowerOffset.x;
            tp.currentPosition.y += selTowerOffset.y;
            UIPointer npt = new UIPointer
            {
                overUI = false,
                pointer = tp,
                overWaveLine = false,
                ray = m_Camera.ScreenPointToRay(tp.currentPosition)
            };

            int sId = towerToMove.attributeId;
            int sLevel = towerToMove.currentLevel;

            // 火是列攻击:
            if (m_CurrentTower.controller.towerFeature == EFeatureTower.Skill_Fire)
            {
                WavelineAreaRaycast(ref npt);
                if (npt.overWaveLine)
                {
                    WaveLineSelEffect selEff = npt.wavelineHit.Value.collider.GetComponent<WaveLineSelEffect>();
                    if (selEff)
                    {
                        // 播放特效，并处理伤害.
                        WaveLineSelMgr.instance.PlayWaveLineEffect(selEff.waveLineId);
                        AgentInsManager.instance.ExecWavelineAttack(selEff.waveLineId, sId, sLevel, false);
                        return true;
                    }
                }
            }
            // 炸弹是区域攻击显示:
            if (m_CurrentTower.controller.towerFeature == EFeatureTower.Skill_Bomb)
            {
                // 测试代码与战场区域碰撞,碰撞后显示攻击区域：
                BattleAreaRaycast(ref npt);
                if (npt.overWaveLine)
                {
                    WaveLineSelMgr.instance.PlayBattleAreaBombEffect(npt.wavelineHit.Value.point);
                    AgentInsManager.instance.ExecBombAttack(npt.wavelineHit.Value.point, sId, sLevel, false);
                    return true;
                }
            }

            return false;
        }

        protected void CancelPlaceTower(PointerInfo pointerInfo)
        {
            CancelGhostPlacement();

            if (towerToMove)
            {
                towerToMove.showTower(true);

                // 处理复制骰子：
                if (towerToMove.towerFeature == EFeatureTower.CopyCat)
                {
                    CopyTargetTower(pointerInfo);
                }
                else
                {
                    // 升级目标位置的塔防.
                    currentSelectedTower = towerToMove;
                }
                towerToMove = null;
            }
            SetState(State.Normal);
        }

        /// <summary>
        /// 处理复制宝石塔防
        /// </summary>
        /// <param name="pointerInfo"></param>
        protected void CopyTargetTower(PointerInfo pointerInfo)
        {
            string tstr = getTargetTowerName(pointerInfo);
            Tower targetTower = null;
            if (tstr.Length > 0)
                targetTower = RandomTower.instance.getTowerByName(tstr);

            currentSelectedTower = towerToMove;
            if (targetTower)
            {
                // 1：记录当前Tower的Level，删除当前的Tower. 
                int towerLvl = currentSelectedTower.currentLevel + 1;
                int posx = currentSelectedTower.gridPosition.x;
                int posy = currentSelectedTower.gridPosition.y;
                currentSelectedTower.Sell();
                delTower(currentSelectedTower);

                // 在目标位置放置新的Tower类型，只有零级。
                RandomPlaceTower(targetTower, posx, posy, 0);
            }

        }

        /// <summary>
        /// Attempt to position a tower at the given location
        /// </summary>
        /// <param name="pointerInfo">The pointer we're using to position the tower</param>
        public bool TryPlaceTower(PointerInfo pointerInfo, bool force = false, bool zeroCost = false)
        {
            UIPointer pointer = WrapPointer(pointerInfo);

            // Do nothing if we're over UI
            if (pointer.overUI && (!force))
            {
                Debug.Log("在UI上了，直接返回");
                return false;
            }
            BuyTower(pointer, force, zeroCost);
            return true;
        }

        /// <summary>
        /// 根据鼠标的点击信息来确认当前点击的位置是否有塔防模型。
        /// </summary>
        /// <param name="pointer"></param>
        /// <returns></returns>
        protected Tower PickTowerInGrid(UIPointer pointer)
        {
            RaycastHit output;
            bool hasHit = Physics.Raycast(pointer.ray, out output, float.MaxValue, towerSelectionLayer);
            if (!hasHit || pointer.overUI)
            {
                return null;
            }
            var controller = output.collider.GetComponent<Tower>();

            return controller;
        }

        /// <summary>
        /// Position the ghost tower at the given pointer
        /// </summary>
        /// <param name="pointerInfo">The pointer we're using to position the tower</param>
        /// <param name="hideWhenInvalid">Optional parameter for configuring if the ghost is hidden when in an invalid location</param>
        public void TryMoveGhost(PointerInfo pointerInfo, bool hideWhenInvalid = true)
        {
            if (m_CurrentTower == null)
            {
                return;
                //throw new InvalidOperationException("Trying to move the tower ghost when we don't have one");
            }

            UIPointer pointer = WrapPointer(pointerInfo);
            // Do nothing if we're over UI
            if (pointer.overUI && hideWhenInvalid)
            {
                m_CurrentTower.Hide();
                return;
            }
            MoveGhost(pointer, hideWhenInvalid);
        }

        /// <summary>
        /// Sets up the radius visualizer for a tower or ghost tower
        /// </summary>
        public void SetupRadiusVisualizer(Tower tower, Transform ghost = null)
        {
            //radiusVisualizerController.SetupRadiusVisualizers(tower, ghost);
        }

        /// <summary>
        /// Hides the radius visualizer
        /// </summary>
        public void HideRadiusVisualizer()
        {
            //radiusVisualizerController.HideRadiusVisualizers();
        }

        /// <summary>
        /// Activates the tower controller UI with the specific information
        /// </summary>
        /// <param name="tower">
        /// The tower controller information to use
        /// </param>
        /// <exception cref="InvalidOperationException">
        /// Throws exception when selecting tower when <see cref="State" /> does not equal <see cref="State.Normal" />
        /// </exception>
        public void SelectTower(Tower tower)
        {
            if (state != State.Normal)
            {
                throw new InvalidOperationException("Trying to select whilst not in a normal state");
            }
            DeselectTower();
            currentSelectedTower = tower;
            if (currentSelectedTower != null)
            {
                currentSelectedTower.removed += OnTowerDied;
            }
            // River: ATTENTION TO FIX:此处是在场景内塔防选择的代码，这是测试代码，选择塔防后，直接删除原塔防，换成Ghost
            /*			if (selectionChanged != null)
						{
							selectionChanged(tower);
						}*/
            // TowerUI的代码分支废弃，使用最新的代码分支.
            startDragTower(tower);

        }

        /// <summary>
        /// 在当前的PlaceArea内删除有相同LvL相同类型的防塔.
        /// </summary>
        /// <param name="tower"></param>
        public bool deleteSameLvlTower(Tower tower)
        {
            Tower delTower = findSameLvlTower(tower);
            if (delTower == null) return false;
            Tower backT = currentSelectedTower;
            currentSelectedTower = delTower;
            SellSelectedTower();
            currentSelectedTower = backT;
            return true;
        }


        /// <summary>
        /// Upgrades <see cref="currentSelectedTower" />, if possible
        /// </summary>
        /// <exception cref="InvalidOperationException">
        /// Throws exception when selecting tower when <see cref="State" /> does not equal <see cref="State.Normal" />
        /// or <see cref="currentSelectedTower" /> is null
        /// </exception>
        public void UpgradeSelectedTower()
        {
            if (state != State.Normal)
            {
                throw new InvalidOperationException("Trying to upgrade whilst not in Normal state");
            }
            if (currentSelectedTower == null)
            {
                throw new InvalidOperationException("Selected Tower is null");
            }
            if (currentSelectedTower.isAtMaxLevel)
            {
                return;
            }
            int upgradeCost = currentSelectedTower.GetCostForNextLevel();
            bool successfulUpgrade = LevelManager.instance.currency.TryPurchase(upgradeCost);
            if (successfulUpgrade)
            {
                currentSelectedTower.UpgradeTower();
            }
            //towerUI.Hide();
            DeselectTower();
        }

        /// <summary>
        /// 当前的塔防随机升级为另一种塔防的种类。
        /// </summary>
        protected bool randomUpgradeTower()
        {
            if (state != State.Normal)
            {
                throw new InvalidOperationException("Trying to upgrade whilst not in Normal state");
            }
            if (currentSelectedTower == null)
            {
                throw new InvalidOperationException("Selected Tower is null");
            }
            if (currentSelectedTower.isAtMaxLevel)
                return false;

            // 直接随机升级，零成本。
            // 1：记录当前Tower的Level，删除当前的Tower. 2：从TowerLib中随机找一个高一级别的Tower.
            string towerName = currentSelectedTower.towerName;
            if (currentSelectedTower.towerFeature == EFeatureTower.NULL)
                towerName = "";
            int towerLvl = currentSelectedTower.currentLevel + 1;
            int posx = currentSelectedTower.gridPosition.x;
            int posy = currentSelectedTower.gridPosition.y;
            currentSelectedTower.Sell();
            delTower(currentSelectedTower);

            // 随机放置一个新的Tower
            RandomTower.instance.randomTower(posx, posy, towerLvl, towerName);


            //towerUI.Hide();
            DeselectTower();

            return true;
        }

        /// <summary>
        /// Sells <see cref="currentSelectedTower" /> if possible
        /// </summary>
        /// <exception cref="InvalidOperationException">
        /// Throws exception when selecting tower when <see cref="State" /> does not equal <see cref="State.Normal" />
        /// or <see cref="currentSelectedTower" /> is null
        /// </exception>
        public void SellSelectedTower()
        {
            if (state != State.Normal)
            {
                throw new InvalidOperationException("Trying to sell tower whilst not in Normal state");
            }
            if (currentSelectedTower == null)
            {
                throw new InvalidOperationException("Selected Tower is null");
            }
            int sellValue = currentSelectedTower.GetSellLevel();
            if (LevelManager.instanceExists && sellValue > 0)
            {
                LevelManager.instance.currency.AddCurrency(sellValue);
                currentSelectedTower.Sell();

                // 从列表中删除Tower.
                delTower(currentSelectedTower);
            }
            DeselectTower();
        }

        /// <summary>
        /// Buys the tower and places it in the place that it currently is
        /// </summary>
        /// <exception cref="InvalidOperationException">
        /// Throws exception if trying to buy towers in Build Mode
        /// </exception>
        public void BuyTower()
        {
            if (!isBuilding)
            {
                throw new InvalidOperationException("Trying to buy towers when not in Build Mode");
            }
            if (m_CurrentTower == null || !IsGhostAtValidPosition())
            {
                return;
            }
            int cost = m_CurrentTower.controller.purchaseCost;
            bool successfulPurchase = LevelManager.instance.currency.TryPurchase(cost);
            if (successfulPurchase)
            {
                PlaceTower();
            }
        }

        /// <summary>
        /// Used to buy the tower during the build phase
        /// Checks currency and calls <see cref="PlaceGhost" />
        /// <exception cref="InvalidOperationException">
        /// Throws exception when not in a build mode or when tower is not a valid position
        /// </exception>
        /// </summary>
        public void BuyTower(UIPointer pointer, bool force = false, bool zeroCost = false)
        {
            if (!isBuilding)
            {
                return;
                //string tstate = state.ToString();
                //throw new InvalidOperationException("Trying to buy towers when not in a Build Mode:" + tstate );
            }

            // 判断是否格子上重复放置塔防
            if (m_CurrentTower == null || !IsGhostAtValidPosition())
            {
                // 判断格子上的塔防:
                Tower sTower = PickTowerInGrid(pointer);
                if (sTower != null)
                {
                    Tower curTower = m_CurrentTower.controller;
                    int testLvl = dragTowerLevel;
                    if ((sTower.currentLevel == testLvl) &&
                        (sTower.towerName == curTower.towerName))
                    {
                        // 先释放掉当前的Ghost塔防.
                        CancelGhostPlacement();

                        // 升级目标位置的塔防.
                        currentSelectedTower = sTower;
                        SetState(State.Normal);
                        //UpgradeSelectedTower();
                        // 新的代码，合并升级为随机塔防类型.
                        randomUpgradeTower();
                    }
                }
                else
                {
                    // 放置攻击塔位
                    PlacementAreaRaycast(ref pointer);
                    if (!pointer.raycast.HasValue || pointer.raycast.Value.collider == null)
                    {
                        CancelGhostPlacement();
                        return;
                    }
                    PlaceGhost(pointer);
                }
                return;
            }


            // 这是判断是否超出了格子
            PlacementAreaRaycast(ref pointer, force);
            if (!pointer.raycast.HasValue || pointer.raycast.Value.collider == null)
            {
                CancelGhostPlacement();
                return;
            }
            int cost = m_CurrentTower.controller.purchaseCost;
            if (zeroCost)
                cost = 0;
            bool successfulPurchase = LevelManager.instance.currency.TryPurchase(cost);
            if (successfulPurchase)
            {
                PlaceGhost(pointer);
            }
        }

        /// <summary>
        /// Deselect the current tower and hides the UI
        /// </summary>
        public void DeselectTower()
        {
            /* River:暂时不处理状态相关的信息。
			if (state != State.Normal)
			{
				throw new InvalidOperationException("Trying to deselect tower whilst not in Normal state");
			}*/
            if (currentSelectedTower != null)
            {
                currentSelectedTower.removed -= OnTowerDied;
            }

            currentSelectedTower = null;

            if (selectionChanged != null)
            {
                selectionChanged(null);
            }
        }

        /// <summary>
        /// Checks the position of the <see cref="m_CurrentTower"/> 
        /// on the <see cref="m_CurrentArea"/>
        /// </summary>
        /// <returns>
        /// True if the placement is valid
        /// </returns>
        /// <exception cref="InvalidOperationException">
        /// Throws exception if the check is done in <see cref="State.Normal"/> state
        /// </exception>
        public bool IsGhostAtValidPosition(bool opponent = false)
        {
            if (!isBuilding)
            {
                //throw new InvalidOperationException("Trying to check ghost position when not in a build mode");
            }
            if (m_CurrentTower == null)
            {
                return false;
            }
            if ((!opponent) && (m_CurrentArea == null))
                return false;
            if (opponent && (m_OpponentArea == null))
                return false;
            if (opponent)
            {
                TowerFitStatus fits = m_OpponentArea.Fits(m_GridPosition, m_CurrentTower.controller.dimensions);
                return fits == TowerFitStatus.Fits;
            }
            else
            {
                TowerFitStatus fits = m_CurrentArea.Fits(m_GridPosition, m_CurrentTower.controller.dimensions);
                return fits == TowerFitStatus.Fits;
            }
        }

        /// <summary>
        /// Checks if buying the ghost tower is possible
        /// </summary>
        /// <returns>
        /// True if can purchase
        /// </returns>
        /// <exception cref="InvalidOperationException">
        /// Throws exception if not in Build Mode or Build With Dragging mode
        /// </exception>
        public bool IsValidPurchase()
        {
            if (!isBuilding)
            {
                throw new InvalidOperationException("Trying to check ghost position when not in a build mode");
            }
            if (m_CurrentTower == null)
            {
                return false;
            }
            if (m_CurrentArea == null)
            {
                return false;
            }
            return LevelManager.instance.currency.CanAfford(m_CurrentTower.controller.purchaseCost);
        }

        /// <summary>
        /// Places a tower where the ghost tower is
        /// </summary>
        /// <exception cref="InvalidOperationException">
        /// Throws exception if not in Build State or <see cref="m_CurrentTower"/> is not at a valid position
        /// </exception>
        public void PlaceTower(int lvl = 0, bool opponent = false)
        {
            if (!isBuilding)
                throw new InvalidOperationException("Trying to place tower when not in a Build Mode");

            if (lvl <= 0)
            {
                if (!IsGhostAtValidPosition(opponent))
                    throw new InvalidOperationException("Trying to place tower on an invalid area");
            }

            if ((!opponent) && (m_CurrentArea == null))
                return;
            if (opponent && (m_OpponentArea == null))
                return;

            Tower createdTower = Instantiate(m_CurrentTower.controller);
            createdTower.opponentSide = opponent;
            if (opponent)
                createdTower.Initialize(m_OpponentArea, m_GridPosition, lvl);
            else
                createdTower.Initialize(m_CurrentArea, m_GridPosition, lvl);

            // River: 内部缓存数据，用于后期容易找到数据.
            addTower(createdTower);

            CancelGhostPlacement();

            // 处理成长骰子,复制骰子等等功能.
            if (lvl == 0)
            {
                ProcessFeatureTower(createdTower);
            }
        }

        /// <summary>
        /// 直接在某一个位置上放置一个Tower，为了不跟其它的Tower操作串乱.
        /// </summary>
        /// <param name="nt"></param>
        /// <param name="lvl"></param>
        /// <param name="opponent"></param>
        protected void PutOpponentTowerWithLevel(Tower nt, int x, int y, int lvl = 0)
        {
            if (m_OpponentArea == null)
                return;

            Tower createdTower = Instantiate(nt);
            createdTower.opponentSide = true;
            IntVector2 gridPos;
            gridPos.x = x;
            gridPos.y = y;
            createdTower.Initialize(m_OpponentArea, gridPos, lvl);

            m_OpponentArea.SetComboGrid(x, y);
            // River: 内部缓存数据，用于后期容易找到数据.
            addTower(createdTower);

            // 处理成长骰子,复制骰子等等功能.
            if (lvl == 0)
            {
                ProcessFeatureTower(createdTower);
            }
        }

        protected void ProcessFeatureTower(Tower ctower)
        {
            if (ctower.towerFeature == EFeatureTower.GrowUp)
            {
                Timer timer = new Timer(10.0f, () => { growUpTower(ctower); });
                listTowerTimer.Add(timer);

                towerTimeDic.Add(timer.timerID, ctower);
            }
            else if (ctower.towerFeature == EFeatureTower.CopyCat)
            {

            }
            return;
        }


        /// <summary>
        /// 成功购买塔防后，更新价格，更新按钮，更新按钮上的塔防价格等等.
        /// </summary>
        protected void OnSuccessBuyTower(bool opponent = false)
        {
            var tpMgr = TowerPrice.instance;
            if (!tpMgr) return;

            // 价格更新
            tpMgr.onTowerBuySuccess(opponent);

            // 设置新的价格显示。
            if (!opponent)
            {
                if (!towerPriceText)
                {
                    towerPriceText = randomTowerBtn.transform.Find("cashText").GetComponent<TextMeshProUGUI>();
                    if (towerPriceText)
                        towerPriceText.text = tpMgr.currentTowerPrice.ToString();
                }
                else
                {
                    towerPriceText.text = tpMgr.currentTowerPrice.ToString();
                }

                // 无法支付新的塔防价格，按钮变灰.
                if (tpMgr.currentTowerPrice > LevelManager.instance.currency.currentCurrency)
                {
                    disableRandomTowerBtn();
                }
            }
        }

        /// <summary>
        /// 随机放置Tower按钮禁止使用，灰掉.
        /// </summary>
        protected void disableRandomTowerBtn()
        {
            randomTowerBtn.interactable = false;
            if (towerPriceText)
            {
                towerPriceText.color = new Color(0.5f, 0.5f, 0.5f);
            }
            tdBuyDisable = true;
        }


        /// <summary>
        /// 随机购买Tower的按钮重设置为有效.
        /// </summary>
        protected void enableRandomTowerBtn()
        {
            // ATTENTION TO FIX: 再次判断是因为有的地方是直接调用
            if ((TowerPrice.instance.currentTowerPrice > LevelManager.instance.currency.currentCurrency) ||
                 (m_listTower.Count >= MAX_TOWERNUM))
                return;

            if (towerPriceText)
                towerPriceText.color = new Color(1.0f, 1.0f, 1.0f);

            if (randomTowerBtn)
                randomTowerBtn.interactable = true;
            tdBuyDisable = false;
        }


        /// <summary>
        /// 在对手的OpponentArea上放置一个塔防.
        /// </summary>
        /// <param name="tow"></param>
        /// <param name="posx"></param>
        /// <param name="posy"></param>
        /// <param name="lvl"></param>
        public void RandomOpponentTower(Tower tow, int posx = -1, int posy = -1, int lvl = 0)
        {
            // 获取IPlaceArea.
            if (m_OpponentArea == null)
            {
                GameObject placeObj = GameObject.FindGameObjectWithTag("PlaceTowerOpponent");
                if (placeObj == null) return;
                // 获取相应的放置区域。
                m_OpponentArea = placeObj.GetComponent<IPlacementArea>();
                if (m_OpponentArea == null) return;
            }


            bool zeroCost = false;
            int tposx = 0;
            int tposy = 0;
            if ((posx < 0) && (posy < 0))
            {
                IntVector2 tvec = m_OpponentArea.getFreePos(1, 1, true);
                if ((tvec.x < 0) && (tvec.y < 0)) return;
                tposx = tvec.x;
                tposy = tvec.y;
            }
            else
            {
                tposx = posx;
                tposy = posy;
                zeroCost = true;
            }

            // 购买成功，才会继续放置塔防:
            // River: 修改Cost为全局统一维护的数据
            int cost = TowerPrice.instance.opponentTowerPrice;
            if (zeroCost)
                cost = 0;

            // 购买成功才可以显示:
            bool successfulPurchase = OpponentMgr.instance.currency.TryPurchase(cost);
            if (successfulPurchase)
            {
                PutOpponentTowerWithLevel(tow, tposx, tposy, lvl);
                if (lvl == 0)
                {
                    Tower tw = OpponentMgr.instance.getTower(tposx, tposy);
                    LevelManager.instance.startWaveLine(tposx, true, tw.attributeId);
                }

            }

        }

        /// <summary>
        /// 游戏内向上飘血
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <param name="val"></param>
        public void generateBloodText(Vector3 wpos, float val, bool crit = false, bool doubleHit = false, bool poison = false)
        {
            Vector3 spos = m_Camera.WorldToScreenPoint(wpos);
            TextMoveDoTween tm;
            if (crit)
            {
                tm = Poolable.TryGetPoolable<TextMoveDoTween>(bloodCrit.gameObject);
            }
            else if (poison)
            {
                tm = Poolable.TryGetPoolable<TextMoveDoTween>(bloodPoison.gameObject);
            }
            else
            {
                tm = Poolable.TryGetPoolable<TextMoveDoTween>(bloodText.gameObject);
            }
            if (tm)
            {
                tm.GetComponent<Transform>().SetParent(GameObject.Find("BattleMainUI").GetComponent<Transform>(), true);
                string bloodStr = "";
                if (doubleHit)
                    bloodStr += "Dble!";
                if (crit)
                    bloodStr += "Crt!";
                bloodStr += "-";
                bloodStr += val.ToString();

                tm.moveBloodText(spos.x, spos.y, bloodStr, crit);
            }
        }

        private void Start()
        {
            // 获取相应的放置区域。
            GameObject placeObj = GameObject.FindGameObjectWithTag("PlaceTower");
            if (placeObj != null)
                m_CurrentArea = placeObj.GetComponent<IPlacementArea>();
            placeObj = GameObject.FindGameObjectWithTag("PlaceTowerOpponent");
            if (placeObj != null)
                m_OpponentArea = placeObj.GetComponent<IPlacementArea>();

        }

        /// <summary>
        /// 替换towerToMove的目标Tower，如果是使用towerToMove，则必须提前处理相应的指针。
        /// </summary>
        /// <param name="tow"></param>
        public void DisplaceTower(Tower newTower, Tower oldTower, int lvl = 0)
        {
            // 先记录oldTower的位置信息:
            int posx = oldTower.gridPosition.x;
            int posy = oldTower.gridPosition.y;
            bool opponent = oldTower.opponentSide;

            int newLvl = oldTower.currentLevel + 1;
            if (newLvl > 4) newLvl = 4;

            delTower(oldTower);
            oldTower.showTower(true);
            oldTower.Sell();

            // 减化成长塔位对应的代码，用于不再影响目前正处于建设状态的塔位.
            if ((!opponent) && (m_CurrentArea == null))
                return;
            if (opponent && (m_OpponentArea == null))
                return;

            IntVector2 ivec;
            ivec.x = posx;
            ivec.y = posy;

            Tower createdTower = Instantiate(newTower);
            createdTower.opponentSide = opponent;
            if (opponent)
                createdTower.Initialize(m_OpponentArea, ivec, newLvl);
            else
                createdTower.Initialize(m_CurrentArea, ivec, newLvl);

            // River: 内部缓存数据，用于后期容易找到数据.
            addTower(createdTower);
        }

        /// <summary>
        /// 直接在IPlaceArea上随机放置一个Tower。这是随机放置塔防的入口类。这是入口的塔防类。
        /// </summary>
        /// <param name="tow"></param>
        public void RandomPlaceTower(Tower tow, int posx = -1, int posy = -1, int lvl = 0)
        {
            // 获取IPlaceArea.
            if (m_CurrentArea == null)
            {
                GameObject placeObj = GameObject.FindGameObjectWithTag("PlaceTower");
                if (placeObj == null) return;
                // 获取相应的放置区域。
                m_CurrentArea = placeObj.GetComponent<IPlacementArea>();
                if (m_CurrentArea == null) return;
            }


            bool zeroCost = false;
            if ((posx < 0) && (posy < 0))
            {
                IntVector2 tvec = m_CurrentArea.getFreePos(1, 1);
                if ((tvec.x < 0) && (tvec.y < 0)) return;
                //Debug.Log( "放置格子数据:" + tvec.x + "," + tvec.y );
                m_GridPosition.x = tvec.x;
                m_GridPosition.y = tvec.y;
            }
            else
            {
                m_GridPosition.x = posx;
                m_GridPosition.y = posy;
                zeroCost = true;
            }

            // 购买成功，才会继续放置塔防:
            if (tow.towerGhostPrefab == null)
            {
                return;
            }
            // River: 修改Cost为全局统一维护的数据
            int cost = TowerPrice.instance.currentTowerPrice;
            if (zeroCost)
                cost = 0;

            bool successfulPurchase = LevelManager.instance.currency.TryPurchase(cost);
            if (!successfulPurchase) return;

            SetUpGhostTower(tow);
            //Debug.Log("设置影子塔防.");
            m_CurrentTower.Show();
            if (successfulPurchase)
            {
                // 删除towerToMove，确保塔防数据不再出现多个
                if (zeroCost && (towerToMove != null))
                {
                    delTower(towerToMove);
                    towerToMove.showTower(true);
                    towerToMove.Sell();
                    towerToMove = null;
                }

                // 塔防购买成功后的相关更新:
                if (!zeroCost)
                    OnSuccessBuyTower();
                SetState(State.Building);

                PlaceTower(lvl);
            }
        }

        /// <summary>
        /// Calculates whether the given pointer is over the current tower ghost
        /// </summary>
        /// <param name="pointerInfo">
        /// The information used to check against the <see cref="m_CurrentTower"/>
        /// </param>
        /// <exception cref="InvalidOperationException">
        /// Throws an exception if not in Build Mode
        /// </exception>
        public bool IsPointerOverGhost(PointerInfo pointerInfo)
        {
            if (state != State.Building)
            {
                throw new InvalidOperationException("Trying to tap on ghost tower when not in Build Mode");
            }
            UIPointer uiPointer = WrapPointer(pointerInfo);
            RaycastHit hit;
            return m_CurrentTower.ghostCollider.Raycast(uiPointer.ray, out hit, float.MaxValue);
        }

        /// <summary>
        /// Selects a tower beneath the given pointer if there is one
        /// 选择塔防
        /// </summary>
        /// <param name="info">
        /// The pointer information concerning the selector of the pointer
        /// </param>
        /// <exception cref="InvalidOperationException">
        /// Throws an exception when not in <see cref="State.Normal"/>
        /// </exception>
        public void TrySelectTower(PointerInfo info)
        {
            if (state != State.Normal)
            {
                //throw new InvalidOperationException("Trying to select towers outside of Normal state");
                return;
            }
            UIPointer uiPointer = WrapPointer(info);
            RaycastHit output;
            // River: Raycast的碰撞是游戏内物品的Collider进行碰撞检测的
            bool hasHit = Physics.Raycast(uiPointer.ray, out output, float.MaxValue, towerSelectionLayer);
            if (!hasHit)//|| uiPointer.overUI)
            {
                //Debug.Log("没有点中或者点中了UI:" + hasHit.ToString() + "," + uiPointer.overUI.ToString());
                return;
            }
            var controller = output.collider.GetComponent<Tower>();
            if (controller != null)
            {
                SelectTower(controller);
            }

            // 计算偏移值.
            CalSelTowerScreenOffset(info, controller);
        }

        /// <summary>
        /// 鼠标选中一个Tower的时候，计算当前鼠标位置与当前Tower位置在屏幕上坐标位置的偏移量。
        /// </summary>
        /// <param name="info"></param>
        /// <param name="tower"></param>
        protected void CalSelTowerScreenOffset(PointerInfo info, Tower tower)
        {
            Vector3 towerCentPos = m_Camera.WorldToScreenPoint(tower.transform.position);
            selTowerOffset.x = towerCentPos.x - info.currentPosition.x;
            selTowerOffset.y = towerCentPos.y - info.currentPosition.y;
        }

        /// <summary>
        /// Gets the world position of the ghost tower
        /// </summary>
        /// <exception cref="InvalidOperationException">
        /// Throws an exception when not in the Build Mode or
        /// When a ghost tower does not exist
        /// </exception>
        public Vector3 GetGhostPosition()
        {
            if (!isBuilding)
            {
                throw new InvalidOperationException("Trying to get ghost position when not in a Build Mode");
            }
            if (m_CurrentTower == null)
            {
                throw new InvalidOperationException("Trying to get ghost position for an object that does not exist");
            }
            return m_CurrentTower.transform.position;
        }

        /// <summary>
        /// Moves the ghost to the center of the screen
        /// </summary>
        /// <exception cref="InvalidOperationException">
        /// Throws exception when not in build mode
        /// </exception>
        public void MoveGhostToCenter()
        {
            if (state != State.Building)
            {
                throw new InvalidOperationException("Trying to move ghost when not in Build Mode");
            }
            // try to find a valid placement 
            Ray ray = m_Camera.ScreenPointToRay(new Vector2(Screen.width * 0.5f, Screen.height * 0.5f));
            RaycastHit placementHit;

            if (Physics.SphereCast(ray, sphereCastRadius, out placementHit, float.MaxValue, placementAreaMask))
            {
                MoveGhostWithRaycastHit(placementHit);
            }
            else
            {
                MoveGhostOntoWorld(ray, false);
            }
        }

        /// <summary>
        /// Set initial values, cache attached components
        /// and configure the controls
        /// </summary>
        protected override void Awake()
        {
            base.Awake();

            DOTween.Init(true, true, LogBehaviour.Verbose).SetCapacity(200, 10);

            state = State.Normal;
            m_Camera = GetComponent<Camera>();


            if (!LevelManager.instance)
                return;

        }

        /// <summary>
        /// 战场内所有的Tower实例都需要升级相关的数据.
        /// 找到相同类型的所有Tower，然后进行局内升级的修改。
        /// </summary>
        /// <param name="td"></param>
        protected void towerUpgradeInBattle(TowerLevelUp tlu)
        {
            foreach (Tower tower in m_listTower)
            {
                if (tlu.towerName != tower.towerName)
                    continue;
                tower.upGradeInSceneTL();
            }
            return;
        }

        /// <summary>
        /// Reset TimeScale if game is paused
        /// </summary>
        protected override void OnDestroy()
        {
            base.OnDestroy();
            Time.timeScale = 1f;
        }

        /// <summary>
        /// Subscribe to the level manager
        /// </summary>
        protected virtual void OnEnable()
        {
            if (LevelManager.instanceExists)
            {
                LevelManager.instance.currency.currencyChanged += OnCurrencyChanged;
            }
        }

        /// <summary>
        /// Unsubscribe from the level manager
        /// </summary>
        protected virtual void OnDisable()
        {
            if (LevelManager.instanceExists)
            {
                LevelManager.instance.currency.currencyChanged -= OnCurrencyChanged;
            }
        }

        /// <summary>
        /// Creates a new UIPointer holding data object for the given pointer position
        /// </summary>
        protected UIPointer WrapPointer(PointerInfo pointerInfo)
        {
            return new UIPointer
            {
                overUI = IsOverUI(pointerInfo),
                pointer = pointerInfo,
                overWaveLine = false,
                ray = m_Camera.ScreenPointToRay(pointerInfo.currentPosition)
            };
        }

        /// <summary>
        /// Checks whether a given pointer is over any UI
        /// </summary>
        /// <param name="pointerInfo">The pointer to test</param>
        /// <returns>True if the event system reports pointer being over UI</returns>
        protected bool IsOverUI(PointerInfo pointerInfo)
        {
            int pointerId;
            EventSystem currentEventSystem = EventSystem.current;

            // Pointer id is negative for mouse, positive for touch
            var cursorInfo = pointerInfo as MouseCursorInfo;
            var mbInfo = pointerInfo as MouseButtonInfo;
            var touchInfo = pointerInfo as TouchInfo;

            if (cursorInfo != null)
            {
                pointerId = PointerInputModule.kMouseLeftId;
            }
            else if (mbInfo != null)
            {
                // LMB is 0, but kMouseLeftID = -1;
                pointerId = -mbInfo.mouseButtonId - 1;
            }
            else if (touchInfo != null)
            {
                pointerId = touchInfo.touchId;
            }
            else
            {
                throw new ArgumentException("Passed pointerInfo is not a TouchInfo or MouseCursorInfo", "pointerInfo");
            }

            return currentEventSystem.IsPointerOverGameObject(pointerId);
        }

        /// <summary>
        /// Move the ghost to the pointer's position
        /// </summary>
        /// <param name="pointer">The pointer to place the ghost at</param>
        /// <param name="hideWhenInvalid">Optional parameter for whether the ghost should be hidden or not</param>
        /// <exception cref="InvalidOperationException">If we're not in the correct state</exception>
        protected void MoveGhost(UIPointer pointer, bool hideWhenInvalid = true)
        {
            // 我操，终于可以了！ATTENTION TO OPP:
            PointerInfo tp = new PointerActionInfo();
            tp.currentPosition = pointer.pointer.currentPosition;
            tp.previousPosition = pointer.pointer.previousPosition;
            tp.delta = pointer.pointer.delta;
            tp.startedOverUI = pointer.pointer.startedOverUI;
            // River: 调整偏移值,用于鼠标移动塔防的时候，更加平滑。
            tp.currentPosition.x += selTowerOffset.x;
            tp.currentPosition.y += selTowerOffset.y;
            UIPointer npt = new UIPointer
            {
                overUI = false,
                pointer = tp,
                overWaveLine = false,
                ray = m_Camera.ScreenPointToRay(tp.currentPosition)
            };


            m_GridPosition.x = -1;
            m_GridPosition.y = -1;

            // 
            // WORK START: 从这里开始，移动的时候与场景内的WaveSelEffect射线做碰撞。  
            // Raycast onto placement layer
            PlacementAreaRaycast(ref npt);

            if (npt.raycast != null)
            {
                MoveGhostWithRaycastHit(npt.raycast.Value);
            }
            else
            {
                // 根据技能塔的类型，来碰撞不同的数据：
                // 火是列攻击:
                if (m_CurrentTower.controller.towerFeature == EFeatureTower.Skill_Fire)
                {
                    WavelineAreaRaycast(ref npt);
                    if (npt.overWaveLine)
                    {
                        WaveLineSelEffect selEff = npt.wavelineHit.Value.collider.GetComponent<WaveLineSelEffect>();
                        if (selEff)
                            selEff.SetWaveLineSel(true);
                    }
                }
                // 炸弹是区域攻击显示:
                if (m_CurrentTower.controller.towerFeature == EFeatureTower.Skill_Bomb)
                {
                    // 测试代码与战场区域碰撞,碰撞后显示攻击区域：
                    BattleAreaRaycast(ref npt);
                    if (npt.overWaveLine)
                        m_CurrentTower.fadeOutAttackArea();
                }


                MoveGhostOntoWorld(npt.ray, hideWhenInvalid);
            }
        }


        /// <summary>
        /// Move ghost with successful raycastHit onto m_PlacementAreaMask
        /// </summary>
        protected virtual void MoveGhostWithRaycastHit(RaycastHit raycast)
        {
            // We successfully hit one of our placement areas
            // Try and get a placement area on the object we hit
            m_CurrentArea = raycast.collider.GetComponent<IPlacementArea>();
            if (m_CurrentArea == null)
            {
                Debug.LogError("There is not an IPlacementArea attached to the collider found on the m_PlacementAreaMask");
                return;
            }
            m_GridPosition = m_CurrentArea.WorldToGrid(raycast.point, m_CurrentTower.controller.dimensions);
            TowerFitStatus fits = m_CurrentArea.Fits(m_GridPosition, m_CurrentTower.controller.dimensions);

            m_CurrentTower.Show();
            m_GhostPlacementPossible = fits == TowerFitStatus.Fits && IsValidPurchase();
            m_CurrentTower.Move(raycast.point,
                                 //m_CurrentArea.GridToWorld(m_GridPosition, m_CurrentTower.controller.dimensions),
                                 m_CurrentArea.transform.rotation,
                                 m_GhostPlacementPossible);
        }


        /// <summary>
        /// Move ghost with the given ray
        /// </summary>
        protected virtual void MoveGhostOntoWorld(Ray ray, bool hideWhenInvalid)
        {
            m_CurrentArea = null;

            if (!hideWhenInvalid)
            {
                RaycastHit hit;

                // check against all layers that the ghost can be on
                Physics.SphereCast(ray, sphereCastRadius, out hit, float.MaxValue, ghostWorldPlacementMask);
                if (hit.collider == null)
                {
                    return;
                }
                m_CurrentTower.Show();

                // ATTENTION TO FIX:什么情况下会导致Y值过高，然后闪烁出现？
                Vector3 tvec3 = hit.point;
                tvec3.y = 0.0f;
                hit.point = tvec3;

                m_CurrentTower.Move(hit.point, hit.collider.transform.rotation, false);
            }
            else
            {
                m_CurrentTower.Hide();
            }
        }

        /// <summary>
        /// Place the ghost at the pointer's position
        /// </summary>
        /// <param name="pointer">The pointer to place the ghost at</param>
        /// <exception cref="InvalidOperationException">If we're not in the correct state</exception>
        protected void PlaceGhost(UIPointer pointer)
        {
            MoveGhost(pointer);

            if (m_CurrentArea != null)
            {
                TowerFitStatus fits = m_CurrentArea.Fits(m_GridPosition, m_CurrentTower.controller.dimensions);

                if (fits == TowerFitStatus.Fits)
                {
                    // Place the ghost
                    Tower controller = m_CurrentTower.controller;

                    Tower createdTower = Instantiate(controller);
                    createdTower.Initialize(m_CurrentArea, m_GridPosition);
                    createdTower.SetLevel(dragTowerLevel);

                    // ATTENTION TO FIX:是否应该加入List:
                    addTower(createdTower);
                    dragTowerLevel = 0;
                    CancelGhostPlacement();
                }
            }
        }

        /// <summary>
        /// Raycast onto tower placement areas
        /// </summary>
        /// <param name="pointer">The pointer we're testing</param>
        protected void PlacementAreaRaycast(ref UIPointer pointer, bool force = false)
        {
            pointer.raycast = null;

            if (pointer.overUI && (!force))
            {
                // Pointer is over UI, so no valid position
                return;
            }

            // Raycast onto placement area layer
            RaycastHit hit;
            if (Physics.Raycast(pointer.ray, out hit, float.MaxValue, placementAreaMask))
            {
                pointer.raycast = hit;
            }
        }

        /// <summary>
        /// 是否会跟兵线层数据有碰撞发生.
        /// </summary>
        /// <param name="point"></param>
        protected void WavelineAreaRaycast(ref UIPointer pointer)
        {
            RaycastHit hit;
            if (Physics.Raycast(pointer.ray, out hit, float.MaxValue, waveLineMask))
            {
                pointer.wavelineHit = hit;
                pointer.overWaveLine = true;
            }
            return;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="pointer"></param>
        protected void BattleAreaRaycast(ref UIPointer pointer)
        {
            RaycastHit hit;
            if (Physics.Raycast(pointer.ray, out hit, float.MaxValue, battleAreaMask))
            {
                pointer.wavelineHit = hit;
                pointer.overWaveLine = true;
            }

            return;
        }

        /// <summary>
        /// 更新每一个
        /// </summary>
        protected void updateSceneTowerUpgradeStatus()
        {
            bool zeroTower = m_listTower.Count == 0;
            int tlen = sceneTowerLvlList.Count;
            /*			for( int ti = 0;ti<tlen;ti ++)
						{
							SceneTowerLvl stl = sceneTowerLvlList[ti];
							bool cashEnable = LevelManager.instance.currency.currentCurrency >= stl.upgradeCash;
							if (zeroTower)
								cashEnable = false;
							if( cashEnable != stl.canInteract)
							{
								stl.enableSceneTower(cashEnable);
							}
						}*/
        }

        /// <summary>
        /// Modifies the valid rendering of the ghost tower once there is enough currency
        /// </summary>
        protected virtual void OnCurrencyChanged()
        {

            // 如果当前处于TowerBuy Disable的状态，根据Currency的值来判断是否应该重新开启RandomTowerBuy按钮.
            if (tdBuyDisable)
            {
                enableRandomTowerBtn();
            }


            // 无法支付新的塔防价格，按钮变灰.
            var tpMgr = TowerPrice.instance;
            if (tpMgr.currentTowerPrice > LevelManager.instance.currency.currentCurrency)
                disableRandomTowerBtn();

            // 处理场景内升级相关的内容
            updateSceneTowerUpgradeStatus();


            if (!isBuilding || m_CurrentTower == null || m_CurrentArea == null)
            {
                return;
            }
            TowerFitStatus fits = m_CurrentArea.Fits(m_GridPosition, m_CurrentTower.controller.dimensions);
            bool valid = fits == TowerFitStatus.Fits && IsValidPurchase();
            m_CurrentTower.Move(m_CurrentArea.GridToWorld(m_GridPosition, m_CurrentTower.controller.dimensions),
                                m_CurrentArea.transform.rotation,
                                valid);
            if (valid && !m_GhostPlacementPossible && ghostBecameValid != null)
            {
                m_GhostPlacementPossible = true;
                ghostBecameValid();
            }
        }

        /// <summary>
        /// Closes the Tower UI on death of tower
        /// </summary>
        protected void OnTowerDied(DamageableBehaviour targetable)
        {
            //towerUI.enabled = false;
            //radiusVisualizerController.HideRadiusVisualizers();
            DeselectTower();
        }

        /// <summary>
        /// Creates and hides the tower and shows the buildInfoUI
        /// </summary>
        /// <exception cref="ArgumentNullException">
        /// Throws exception if the <paramref name="towerToBuild"/> is null
        /// </exception>
        void SetUpGhostTower([NotNull] Tower towerToBuild)
        {
            if (towerToBuild == null)
            {
                throw new ArgumentNullException("towerToBuild");
            }

            m_CurrentTower = Instantiate(towerToBuild.towerGhostPrefab);
            m_CurrentTower.Initialize(towerToBuild);
            //m_CurrentTower.Hide();

        }

        /// <summary>
        /// 处理GameUI的Update相关内容，目前的主要工作是处理成长骰子.
        /// </summary>
        private void Update()
        {
            for (int ti = listTowerTimer.Count - 1; ti >= 0; ti--)
            {
                // 如果执行到，会在DelTower函数内删除对应的listTowerTimer.
                listTowerTimer[ti].Tick(Time.deltaTime);
            }

            // 更新处理自己方光塔对应的攻击增加.
            updateLightTowerAttRise();

        }
        /// <summary>
        /// 更新火属性Tower对左右塔的攻击增加.
        /// </summary>
        protected void updateLightTowerAttRise()
        {
            int yRow = 2;
            int maxTower = MAX_TOWERNUM / 3;

            for (int ti = 0; ti < maxTower; ti++)
            {
                Tower tw = FindTowerWithGridIdx(ti, yRow);
                if (tw)
                    tw.attackRise = 0.0f;
            }

            for (int ti = 0; ti < maxTower; ti++)
            {
                Tower tw = FindTowerWithGridIdx(ti, yRow);
                if (tw == null) continue;
                if (tw.towerFeature == EFeatureTower.LightTower)
                {
                    int nidx = ti - 1;
                    if (nidx >= 0)
                    {
                        tw = FindTowerWithGridIdx(nidx, yRow);
                        if (tw)
                            tw.attackRise = 0.1f;
                    }
                    nidx = ti + 1;
                    if (nidx < maxTower)
                    {
                        tw = FindTowerWithGridIdx(nidx, yRow);
                        if (tw)
                            tw.attackRise = 0.1f;
                    }
                }
            }
        }
    }
}