using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using Core.Utilities;
using KTGMGemClient;
using Microsoft.VisualBasic;
using TMPro.Examples;
using TowerDefense.Level;
using TowerDefense.UI.HUD;
using UnityEditor;
using UnityEngine;
using UnityEngine.Analytics;
using UnityEngine.UI;

namespace TowerDefense.Towers.Placement
{
    /// <summary>
    /// A tower placement location made from a grid.
    /// Its origin is centered in the middle of the lower-right cell. It can be oriented in any direction
    /// </summary>
    [RequireComponent(typeof(BoxCollider))]
    public class TowerPlacementGrid : MonoBehaviour, IPlacementArea
    {
        public static float GRID_OPENCASH_SELF = 100;
        public static float GRID_OPENCASH_OPPO = 100;
        /// <summary>
        /// Prefab used to visualise the grid.
        /// 如果在游戏内并不需要Grid显示或者用其它的方式显示，则可以去掉这个数据。
        /// </summary>
        public PlacementTile placementTilePrefab;

        /// <summary>
        /// Visualisation prefab to instantiate on mobile platforms
        /// </summary>
        public PlacementTile placementTilePrefabMobile;

        /// <summary>
        /// 塔位血条对应的UI界面.
        /// </summary>
        public GameObject towerBloodUIPrefab;

        /// <summary>
        /// 此位置上塔对应的子弹充能Prefab.塔放置到当前的塔位后，如果是对应的塔防类型，需要把
        /// 相应的界面指针传到塔防的数据结构内。
        /// </summary>
        public GameObject towerBulletUIPrefab;
        /// <summary>
        /// 充能条对应的界面
        /// </summary>
        public GameObject towerEnergyUIPrefab;

        /// <summary>
        /// 等待购买开启对应按钮.
        /// </summary>
        public Button waitBuyBtnPrefab;

        /// <summary>
        /// 充能特效对应的Prefab.
        /// </summary>
        public ParticleSystem energyEffectPrefab;

        // TEST CODE TO DELETE: 
        public ParticleSystem TestParticle;
        protected ParticleSystem PlayParticle;
        protected Timer effectStopTimer;
        protected bool bTimerStart = false;


        /// <summary>
        /// 用于调试位置信息的Image.
        /// </summary>
        public Image debugImg;

        /// <summary>
        /// 最后一行格子与前一行格子之间的空位长度.
        /// </summary>
        public float gridFreePos;


        /// <summary>
        /// The dimensions of the grid 
        /// </summary>
        public IntVector2 dimensions;


        /// <summary>
        /// Size of the edge of a cell
        /// </summary>
        [Tooltip("The size of the edge of one grid cell for this area. Should match the physical grid size of towers")]
        public float gridSize = 1;

        /// <summary>
        /// Inverted grid size, to multiply with
        /// </summary>
        float m_InvGridSize;

        /// <summary>
        /// Array of available cells
        /// </summary>
        bool[,] m_AvailableCells;

        /// <summary>
        /// 每一个格子的对应的类型。不同的类型可以转化，但可合成的类型不能转化。
        /// 初始化的时候会根据配置数据来初始化不同的格子状态
        /// </summary>
        PlacementGridType[,] m_arrGridType;

        TowerGridOpen[] m_arrTGO;

        float[] m_arrCoinGenTime;

        /// <summary>
        /// 每一个Tile格子的中心点对应的屏幕坐标.
        /// </summary>
        Vector2[,] m_arrGridCentUIPos;

        /// <summary>
        /// 攻击塔位对应的UI位置信息.
        /// </summary>
        Vector2[] m_arrTowerBloodUIPos;
        TowerBloodVis[] arrTowerBloodUi;

        /// <summary>
        /// 攻击塔位对应的子弹UI位置信息.
        /// </summary>
        Vector2[] m_arrTowerBulletUIPos;
        BulletUICtl[] arrTowerBulletUi;
        EnergyUICtl[] arrTowerEnergyUi;
        ParticleSystem[] arrTowerEnergyEffect;


        /// <summary>
        /// 塔位对应的屏幕坐标尺寸
        /// </summary>
        float m_fGridUISize;

        /// <summary>
        /// Array of <see cref="PlacementTile"/>s
        /// </summary>
        PlacementTile[,] m_Tiles;

        /// <summary>
        /// Converts a location in world space into local grid coordinates.
        /// </summary>
        /// <param name="worldLocation"><see cref="Vector3"/> indicating world space coordinates to convert.</param>
        /// <param name="sizeOffset"><see cref="IntVector2"/> indicating size of object to center.</param>
        /// <returns><see cref="IntVector2"/> containing the grid coordinates corresponding to this location.</returns>
        public IntVector2 WorldToGrid(Vector3 worldLocation, IntVector2 sizeOffset)
        {
            Vector3 localLocation = transform.InverseTransformPoint(worldLocation);

            // Scale by inverse grid size
            localLocation *= m_InvGridSize;

            // Offset by half size
            var offset = new Vector3(sizeOffset.x * 0.5f, 0.0f, sizeOffset.y * 0.5f);
            localLocation -= offset;

            int xPos = Mathf.RoundToInt(localLocation.x);
            int yPos = Mathf.RoundToInt(localLocation.z);

            return new IntVector2(xPos, yPos);
        }

        public IntVector2 getdimsize()
        {
            return this.dimensions;
        }


        /// <summary>
        /// 实现引用.
        /// </summary>
        public bool opponent { get; set; }
        public bool isOpponent()
        {
            return opponent;
        }

        /// <summary>
        /// 获取对应位置的充能子弹界面指针.
        /// </summary>
        /// <param name="x"></param>
        /// <returns></returns>
        public BulletUICtl GetBulletUICtl(int x, int y)
        {
            return this.arrTowerBulletUi[x];
        }

        /// <summary>
        /// 获取对应位置的能量条界面指针.
        /// </summary>
        /// <param name="x"></param>
        /// <returns></returns>
        public EnergyUICtl GetEnergyUICtl(int x, int y)
        {
            return this.arrTowerEnergyUi[x];
        }

        public FreezeBreath GetFreezeBreath(int x, int y)
        {
            return null;
        }

        /// <summary>
        /// 获取一个可以放置塔防的位置.
        /// </summary>
        /// <returns></returns>
        public IntVector2 getFreePos(int xdim, int ydim, bool forceGet = false)
        {
            IntVector2 resvec = new IntVector2();
            int subval = 1;
            if (forceGet)
                subval = 0;
            // Range产生的随机数是包括min,排除max. Y值再减1是因为最前面一排是战斗塔位。
            int maxXdim = this.dimensions.x - xdim + 1;
            int maxYdim = (this.dimensions.y - ydim + 1) - subval;
            resvec.x = UnityEngine.Random.Range(0, maxXdim);
            resvec.y = UnityEngine.Random.Range(0, maxYdim);

            TowerFitStatus tfs = this.Fits(resvec, new IntVector2(xdim, ydim));

            // 处理ForceGet
            bool legalVal = (tfs == TowerFitStatus.Fits);
            if (legalVal && forceGet)
            {
                if (m_arrGridType[resvec.x, resvec.y] != PlacementGridType.EGridOpen)
                    legalVal = false;
            }

            if (legalVal)
            {
                return resvec;
            }
            else
            {
                int looptime = 0;
                while (looptime < 10)
                {
                    looptime++;
                    resvec.x = UnityEngine.Random.Range(0, maxXdim);
                    resvec.y = UnityEngine.Random.Range(0, maxYdim);

                    tfs = this.Fits(resvec, new IntVector2(xdim, ydim));

                    // 处理forceGet.
                    if (forceGet)
                    {
                        if (m_arrGridType[resvec.x, resvec.y] != PlacementGridType.EGridOpen)
                            continue;
                    }

                    if (tfs == TowerFitStatus.Fits) return resvec;
                }

                // 循环超过10次，则直接寻找空位，找不到则返回错误.
                for (int x = 0; x < maxXdim; x++)
                {
                    for (int y = 0; y < maxYdim; y++)
                    {
                        if (!m_AvailableCells[x, y])
                        {
                            // 处理ForceGet
                            if (forceGet)
                            {
                                if (m_arrGridType[x, y] != PlacementGridType.EGridOpen)
                                    continue;
                            }

                            resvec.x = x;
                            resvec.y = y;
                            return resvec;
                        }
                    }
                }
            }

            return new IntVector2(-1, -1);
        }

        /// <summary>
        /// 判断是否是一个空置的攻击位
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <returns></returns>
        public bool isFreeAtackPos(int x, int y)
        {
            if (m_AvailableCells[x, y] == true)
                return false;

            if (m_arrGridType[x, y] == PlacementGridType.EGridOpen)
                return true;

            return false;
        }

        /// <summary>
        /// 是否是等待购买的攻击塔位.
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <returns></returns>
        public bool isWaitBuyGrid(int x, int y)
        {
            if (m_AvailableCells[x, y] == true) return false;

            if (m_arrGridType[x, y] == PlacementGridType.EGridWaitBuy)
                return true;

            return false;
        }

        /// <summary>
        /// 开启金币生产模式
        /// </summary>
        public void startCoinGenMode()
        {
            m_arrCoinGenTime = new float[dimensions.x];
            int ty = dimensions.y - 1;
            for (int tx = 0; tx < dimensions.x; tx++)
            {
                if ((m_arrGridType[tx, ty] == PlacementGridType.EGridOpen) || (m_arrGridType[tx, ty] == PlacementGridType.EGridCombo))
                    m_arrCoinGenTime[tx] = 0.0f;
                else
                    m_arrCoinGenTime[tx] = -1f;
            }
        }

        protected void partilceUpdate()
        {
            if (bTimerStart)
            {
                if (effectStopTimer.Tick(Time.deltaTime))
                {
                    bTimerStart = false;
                    effectStopTimer.Reset();
                }
            }

            if (UnityEngine.Input.GetKeyDown(KeyCode.Q))
            {
                this.PlayEnergyEffect(2, true);
                return;
            }
            if (UnityEngine.Input.GetKeyDown(KeyCode.W))
            {
                this.PlayEnergyEffect(2, false);
                return;
            }

            // TEST CODE TO DELETE:
            if (PlayParticle != null)
            {

                if (UnityEngine.Input.GetKeyDown(KeyCode.E))
                {
                    PlayParticle = Instantiate(TestParticle);
                    Vector3 tpos = this.transform.position;
                    tpos.y += 5.0f;
                    PlayParticle.transform.position = tpos;

                    //Vector3 lookVec = Vector3.zero;
                    //lookVec.x = 1;
                    //PlayParticle.transform.LookAt(lookVec);
                    PlayParticle.Play();
                    //effectStopTimer.SetTime(0.15f);
                    //bTimerStart = true;
                }
                if (UnityEngine.Input.GetKeyDown(KeyCode.F))
                {
                    PlayParticle.Stop(true, ParticleSystemStopBehavior.StopEmittingAndClear);
                }
            }
        }

        void Update()
        {
            // 
            // TEST CODE TO DELETE:
            partilceUpdate();

            if (m_arrCoinGenTime == null) return;

            float delta = Time.deltaTime;
            float timePe = JsonDataCenter.GOLD_TIME / 1000.0f;
            // 处理每一开启的格子，用于金币数据增加:
            for (int ti = 0; ti < dimensions.x; ti++)
            {
                // 是否是可以增加金币的格子:
                if (m_arrCoinGenTime[ti] < 0) continue;

                // 时间判断.
                if (m_arrCoinGenTime[ti] >= 0)
                {
                    m_arrCoinGenTime[ti] += delta;
                    if (m_arrCoinGenTime[ti] > timePe)
                    {
                        m_arrCoinGenTime[ti] -= timePe;
                        // 增加金币:
                        if (opponent)
                            OpponentMgr.instance.currency.AddCurrency(JsonDataCenter.GOLD_ADD);
                        else
                            LevelManager.instance.currency.AddCurrency(JsonDataCenter.GOLD_ADD);
                    }

                }

            }
        }

        /// <summary>
        /// 设置格子为合成状态。
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <returns></returns>
        public bool SetComboGrid(int x, int y)
        {
            if (m_arrGridType[x, y] == PlacementGridType.EGridOpen)
            {
                m_arrGridType[x, y] = PlacementGridType.EGridCombo;
                return true;
            }
            else return false;
        }

        /// <summary>
        /// 设置某一个格子为已破坏塔位。
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <returns></returns>
        public bool SetDestroyedGrid(int x, int y)
        {
            // 释放掉界面显示
            if (m_arrGridType[x, y] == PlacementGridType.EGridWaitBuy)
            {
                if (m_arrTGO[x])
                {
                    m_arrTGO[x].Release();
                    m_arrTGO[x] = null;
                }
            }

            // 任何情况下，都可以破坏，没有购买，上面有塔，都得破坏
            m_arrGridType[x, y] = PlacementGridType.EGridDestroyed;
            if (arrTowerBloodUi[x] != null)
                arrTowerBloodUi[x].gameObject.SetActive(false);

            if (arrTowerBulletUi[x] != null)
                arrTowerBulletUi[x].gameObject.SetActive(false);

            if (arrTowerEnergyUi[x] != null)
                arrTowerEnergyUi[x].gameObject.SetActive(false);

            m_Tiles[x, y].SetTileType(PlacementGridType.EGridDestroyed);

            return true;
        }


        /// <summary>
        /// Returns the world coordinates corresponding to a grid location.
        /// </summary>
        /// <param name="gridPosition">The coordinate in grid space</param>
        /// <param name="sizeOffset"><see cref="IntVector2"/> indicating size of object to center.</param>
        /// <returns>Vector3 containing world coordinates for specified grid cell.</returns>
        public Vector3 GridToWorld(IntVector2 gridPosition, IntVector2 sizeOffset)
        {
            float freePos = 0;
            if (gridPosition.y == 2)
                freePos = gridFreePos;
            // Calculate scaled local position
            Vector3 localPos = new Vector3(gridPosition.x + (sizeOffset.x * 0.5f), 0, gridPosition.y + (sizeOffset.y * 0.5f) + freePos) *
                               gridSize;

            return transform.TransformPoint(localPos);
        }

        /// <summary>
        /// Tests whether the indicated cell range represents a valid placement location.
        /// </summary>
        /// <param name="gridPos">The grid location</param>
        /// <param name="size">The size of the item</param>
        /// <returns>Whether the indicated range is valid for placement.</returns>
        public TowerFitStatus Fits(IntVector2 gridPos, IntVector2 size)
        {
            // If the tile size of the tower exceeds the dimensions of the placement area, immediately decline placement.
            if ((size.x > dimensions.x) || (size.y > dimensions.y))
            {
                return TowerFitStatus.OutOfBounds;
            }

            IntVector2 extents = gridPos + size;

            // Out of range of our bounds
            if ((gridPos.x < 0) || (gridPos.y < 0) ||
                (extents.x > dimensions.x) || (extents.y > dimensions.y))
            {
                return TowerFitStatus.OutOfBounds;
            }

            // Ensure there are no existing towers within our tile silhuette.
            for (int y = gridPos.y; y < extents.y; y++)
            {
                for (int x = gridPos.x; x < extents.x; x++)
                {
                    if (m_AvailableCells[x, y])
                    {
                        return TowerFitStatus.Overlaps;
                    }
                }
            }

            // If we've got this far, we've got a valid position.
            return TowerFitStatus.Fits;
        }

        /// <summary>
        /// Sets a cell range as being occupied by a tower.
        /// </summary>
        /// <param name="gridPos">The grid location</param>
        /// <param name="size">The size of the item</param>
        public void Occupy(IntVector2 gridPos, IntVector2 size)
        {
            IntVector2 extents = gridPos + size;

            // Validate the dimensions and size
            if ((size.x > dimensions.x) || (size.y > dimensions.y))
            {
                throw new ArgumentOutOfRangeException("size", "Given dimensions do not fit in our grid");
            }

            // Out of range of our bounds
            if ((gridPos.x < 0) || (gridPos.y < 0) ||
                (extents.x > dimensions.x) || (extents.y > dimensions.y))
            {
                Debug.Log("目标GridPos is:" + gridPos.x + "," + gridPos.y + "," + size.x + "," + size.y);
                throw new ArgumentOutOfRangeException("gridPos", "Given footprint is out of range of our grid");
            }

            // 填充对应格子为占用状态
            for (int y = gridPos.y; y < extents.y; y++)
            {
                for (int x = gridPos.x; x < extents.x; x++)
                {
                    m_AvailableCells[x, y] = true;
                }
            }
        }

        /// <summary>
        /// Removes a tower from a grid, setting its cells as unoccupied.
        /// </summary>
        /// <param name="gridPos">The grid location</param>
        /// <param name="size">The size of the item</param>
        public void Clear(IntVector2 gridPos, IntVector2 size)
        {
            IntVector2 extents = gridPos + size;

            // Validate the dimensions and size
            if ((size.x > dimensions.x) || (size.y > dimensions.y))
            {
                throw new ArgumentOutOfRangeException("size", "Given dimensions do not fit in our grid");
            }

            // Out of range of our bounds
            if ((gridPos.x < 0) || (gridPos.y < 0) ||
                (extents.x > dimensions.x) || (extents.y > dimensions.y))
            {
                throw new ArgumentOutOfRangeException("gridPos", "Given footprint is out of range of our grid");
            }

            // 清空对应格子为占用状态
            for (int y = gridPos.y; y < extents.y; y++)
            {
                for (int x = gridPos.x; x < extents.x; x++)
                {
                    m_AvailableCells[x, y] = false;
                }
            }
        }

        /// <summary>
        /// Initialize values
        /// </summary>
        protected virtual void Awake()
        {
            ResizeCollider();

            // Initialize empty bool array (defaults are false, which is what we want)
            m_AvailableCells = new bool[dimensions.x, dimensions.y];

            // 暂使这种简单的模式来处理正反双方
            if (dimensions.y > 1)
                opponent = false;
            else
                opponent = true;

            /*
			// 初始化塔位类型.
			initTileGridType();

			// Precalculate inverted grid size, to save a division every time we translate coords
			m_InvGridSize = 1 / gridSize;

			SetUpGrid();
			*/
        }

        protected void addDebugImg(Vector2 pos)
        {
            Image timg = Instantiate(this.debugImg);
            GameObject go = GameObject.Find("BattleMainUI");
            if (!go) return;
            Transform tp = go.GetComponent<Transform>();
            timg.GetComponent<Transform>().SetParent(tp, true);
            Vector3 tpos = timg.transform.position;
            tpos.x = pos.x;
            tpos.y = pos.y;
            timg.transform.position = tpos;

            return;
        }

        /// <summary>
        /// 预计算塔位格子对应的屏幕坐标以及塔位格子的屏幕尺寸
        /// WORK START: 计算屏幕坐标，然后开搞屏幕相关的内容。下午要把塔位上显示界面搞出来。
        /// WORK START: 为什么OppoGrid对应的屏幕坐标不对？
        /// 
        /// </summary>
        void preCalculateGridUIPos()
        {
            m_arrGridCentUIPos = new Vector2[dimensions.x, dimensions.y];

            Vector3 targetPos = GridToWorld(new IntVector2(0, 0), new IntVector2(1, 1));
            Vector3 svec = this.transform.position;

            if (!ViewPortAdj.instance.bAdjViewPort)
                ViewPortAdj.instance.adjViewportRect();

            UnityEngine.Camera sceneCam = ViewPortAdj.instance.cachedCamera;
            Vector3 centPos = sceneCam.WorldToScreenPoint(targetPos);
            Vector3 lbPos = sceneCam.WorldToScreenPoint(svec);

            m_fGridUISize = (centPos.y - lbPos.y) * 2.0f;

            for (int ty = 0; ty < dimensions.y; ty++)
            {
                for (int tx = 0; tx < dimensions.x; tx++)
                {
                    m_arrGridCentUIPos[tx, ty].x = centPos.x + tx * m_fGridUISize;
                    m_arrGridCentUIPos[tx, ty].y = centPos.y + ty * m_fGridUISize;
                }

                if ((gridFreePos > 0) && (ty == (dimensions.y - 1)))
                {
                    targetPos = GridToWorld(new IntVector2(0, ty), new IntVector2(1, 1));
                    centPos = sceneCam.WorldToScreenPoint(targetPos);

                    for (int tx = 0; tx < dimensions.x; tx++)
                    {
                        m_arrGridCentUIPos[tx, ty].x = centPos.x + tx * m_fGridUISize;
                        m_arrGridCentUIPos[tx, ty].y = centPos.y;
                    }
                }
            }

            // 血条位置的设定
            preCalculateTowerBloodUi();

            m_arrTGO = new TowerGridOpen[dimensions.x];
            // 设置界面相关的内容:
            for (int y = dimensions.y - 1; y < dimensions.y; y++)
            {
                for (int x = 0; x < dimensions.x; x++)
                {
                    if (m_arrGridType[x, y] != PlacementGridType.EGridWaitBuy)
                        continue;
                    Button tbtn = Instantiate(this.waitBuyBtnPrefab);
                    GameObject go = GameObject.Find("BattleMainUI");
                    if (!go) continue;
                    Transform tp = go.GetComponent<Transform>();
                    tbtn.GetComponent<Transform>().SetParent(tp, true);
                    Vector3 tpos = tbtn.transform.position;
                    tpos.x = m_arrGridCentUIPos[x, y].x;
                    tpos.y = m_arrGridCentUIPos[x, y].y + m_fGridUISize / 10;
                    tbtn.transform.position = tpos;

                    // 设置为界面最下层:
                    tbtn.transform.SetAsFirstSibling();

                    // 设置按钮对应的点击功能
                    TowerGridOpen tgo = tbtn.GetComponent<TowerGridOpen>();
                    if (tgo)
                    {
                        tgo.SetBuyBtnInfo(x, y, this);
                        if (opponent)
                            tgo.cashText.SetText(TowerPlacementGrid.GRID_OPENCASH_OPPO.ToString());
                        else
                            tgo.cashText.SetText(TowerPlacementGrid.GRID_OPENCASH_SELF.ToString());
                        m_arrTGO[x] = tgo;
                    }
                }
            }

        }

        /// <summary>
        /// 设置某一个位置的血条.
        /// </summary>
        /// <param name="ix">Tower在X方向上的位置信息</param>
        /// <param name="health"></param>
        public void setTowerPosHealth(int ix, float health)
        {
            if (m_arrGridType[ix, dimensions.y - 1] == PlacementGridType.EGridDestroyed)
                return;

            if ((arrTowerBloodUi[ix] != null))
            {
                if (health < 1.0f)
                {
                    arrTowerBloodUi[ix].gameObject.SetActive(true);
                    arrTowerBloodUi[ix].SetHealthScale(health);
                }
            }
        }

        /// <summary>
        /// 处理Tower血量的UI界面
        /// </summary>
        protected void preCalculateTowerBloodUi()
        {
            // 处理攻击塔位的血条位置信息.
            m_arrTowerBloodUIPos = new Vector2[dimensions.x];
            arrTowerBloodUi = new TowerBloodVis[dimensions.x];
            int dy = dimensions.y - 1;
            for (int x = 0; x < dimensions.x; x++)
            {
                m_arrTowerBloodUIPos[x].x = m_arrGridCentUIPos[x, dy].x;
                m_arrTowerBloodUIPos[x].y = m_arrGridCentUIPos[x, dy].y + m_fGridUISize / 10 * 3;

                GameObject img = Instantiate(towerBloodUIPrefab);
                GameObject go = GameObject.Find("BattleMainUI");
                if (!go) continue;
                Transform tp = go.GetComponent<Transform>();
                img.GetComponent<Transform>().SetParent(tp, true);
                Vector3 tpos = img.transform.position;
                tpos.x = m_arrTowerBloodUIPos[x].x;
                tpos.y = m_arrTowerBloodUIPos[x].y;
                img.transform.position = tpos;

                // 设置为界面最下层:
                img.transform.SetAsFirstSibling();

                TowerBloodVis tbv = img.GetComponent<TowerBloodVis>();
                arrTowerBloodUi[x] = tbv;
                tbv.gameObject.SetActive(false);
            }

            // 处理攻击塔位对应的血条
            m_arrTowerBulletUIPos = new Vector2[dimensions.x];
            arrTowerBulletUi = new BulletUICtl[dimensions.x];
            arrTowerEnergyUi = new EnergyUICtl[dimensions.x];
            arrTowerEnergyEffect = new ParticleSystem[dimensions.x];

            for (int x = 0; x < dimensions.x; x++)
            {
                m_arrTowerBulletUIPos[x].x = m_arrGridCentUIPos[x, dy].x + m_fGridUISize / 2.0f - 10;
                m_arrTowerBulletUIPos[x].y = m_arrGridCentUIPos[x, dy].y;


                GameObject go = GameObject.Find("BattleMainUI");
                if (!go) continue;
                Transform tp = go.GetComponent<Transform>();

                GameObject img;

                img = Instantiate(towerBulletUIPrefab);
                img.GetComponent<Transform>().SetParent(tp, true);
                Vector3 tpos = img.transform.position;
                tpos.x = m_arrTowerBulletUIPos[x].x;
                tpos.y = m_arrTowerBulletUIPos[x].y;
                img.transform.position = tpos;

                // 设置为界面最下层，并记录相应的数据指针。
                img.transform.SetAsFirstSibling();
                BulletUICtl buc = img.GetComponent<BulletUICtl>();
                arrTowerBulletUi[x] = buc;
                buc.gameObject.SetActive(false);

                // 把充能条也创建出来了.
                img = Instantiate(towerEnergyUIPrefab);
                img.GetComponent<Transform>().SetParent(tp, true);
                tpos = img.transform.position;
                tpos.x = m_arrTowerBulletUIPos[x].x;
                tpos.y = m_arrTowerBulletUIPos[x].y;
                img.transform.position = tpos;

                img.transform.SetAsFirstSibling();
                EnergyUICtl euc = img.GetComponent<EnergyUICtl>();
                arrTowerEnergyUi[x] = euc;
                euc.gameObject.SetActive(false);

                // 设置播放特效对应的3D坐标:
                Vector3 vpos = GridToWorld(new IntVector2(x, dy), new IntVector2(2, 1));
                vpos.x -= (gridSize / 2.0f);
                vpos.y += 5.0f;

                arrTowerEnergyEffect[x] = Instantiate(energyEffectPrefab);
                arrTowerEnergyEffect[x].transform.position = vpos;
                arrTowerEnergyEffect[x].Stop();
            }

            return;
        }

        /// <summary>
        /// 在指定的位置播放充能成功的特效.
        /// </summary>
        /// <param name="x"></param>
        /// <param name="play">是播放还是停止播放</param>
        public void PlayEnergyEffect(int x, bool play = true)
        {
            if (!arrTowerEnergyEffect[x]) return;
            if (play)
            {
                arrTowerEnergyEffect[x].Play();
            }
            else
            {
                arrTowerEnergyEffect[x].Stop();
            }
            return;
        }


        public void updateGridOpenCoin(int ix, int iy)
        {
            // 更新显示相关的信息, 
            if (opponent)
                GRID_OPENCASH_OPPO += GRID_OPENCASH_OPPO;
            else
                GRID_OPENCASH_SELF += GRID_OPENCASH_SELF;

            for (int x = 0; x < dimensions.x; x++)
            {
                if (x == ix)
                {
                    m_arrTGO[x] = null;
                }
                else
                {
                    if (m_arrGridType[x, iy] != PlacementGridType.EGridWaitBuy)
                        continue;
                    if (m_arrTGO[x] != null)
                    {
                        if (opponent)
                            m_arrTGO[x].cashText.SetText(GRID_OPENCASH_OPPO.ToString());
                        else
                            m_arrTGO[x].cashText.SetText(GRID_OPENCASH_SELF.ToString());
                    }
                }
            }
        }

        /// <summary>
        /// 是否有已开启的可放置攻击位置。
        /// </summary>
        /// <returns></returns>
        public bool hasFreeAttackPos()
        {
            int iy = dimensions.y - 1;
            for (int ix = 0; ix < dimensions.x; ix++)
            {
                if (m_arrGridType[ix, iy] == PlacementGridType.EGridOpen)
                    return true;
            }
            return false;
        }

        /// <summary>
        /// 购买塔位.
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        public void BuyTowerGrid(int ix, int iy)
        {
            // 更新核心的数据信息
            if (m_arrGridType[ix, iy] != PlacementGridType.EGridWaitBuy) return;
            m_arrGridType[ix, iy] = PlacementGridType.EGridOpen;
            m_AvailableCells[ix, iy] = false;

            /*			// 更新显示相关的信息, 
                        if (opponent)
                            GRID_OPENCASH_OPPO += GRID_OPENCASH_OPPO;
                        else
                            GRID_OPENCASH_SELF += GRID_OPENCASH_SELF;*/

            m_Tiles[ix, iy].SetTileType(PlacementGridType.EGridOpen);
            // 开启金币获取模式.
            m_arrCoinGenTime[ix] = 0.0f;

        }


        /// <summary>
        /// 购买对应的待购攻击塔位.
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <returns></returns>
        public bool buyWaitBuyGrid(int x, int y)
        {
            TowerGridOpen tgo = m_arrTGO[x];
            if (tgo)
                tgo.OnClick();
            else
                return false;
            return true;
        }

        /// <summary>
        /// 预计算每一个塔位格子的屏幕坐标。
        /// </summary>
        void Start()
        {
            // 初始化塔位类型.
            initTileGridType();

            // Precalculate inverted grid size, to save a division every time we translate coords
            m_InvGridSize = 1 / gridSize;

            SetUpGrid();


            // 初始化格子对应的屏幕坐标数据
            preCalculateGridUIPos();

            // TEST CODE TO DELETE:
            if (TestParticle != null)
                PlayParticle = Instantiate(TestParticle);
            effectStopTimer = new Timer(1.0f, stopParticle);
            bTimerStart = false;
        }

        protected void stopParticle()
        {
            if (PlayParticle)
                PlayParticle.Stop(true, ParticleSystemStopBehavior.StopEmittingAndClear);
            //if (fireParticleSystem)
            //fireParticleSystem.gameObject.SetActive(false);
            //fireParticleSystem.Stop(true,ParticleSystemStopBehavior.StopEmittingAndClear );
            //fireParticleSystem.Clear();
            //Vector3 vpos = fireParticleSystem.gameObject.transform.position;
            //vpos.y = 3000;
            //fireParticleSystem.gameObject.transform.position = vpos;
        }
        /// <summary>
        /// 初始化当前塔防位的类型信息.
        /// </summary>
        void initTileGridType()
        {
            m_arrGridType = new PlacementGridType[dimensions.x, dimensions.y];
            int sy = dimensions.y - 1;
            for (int tx = 0; tx < dimensions.x; tx++)
            {
                m_arrGridType[tx, sy] = PlacementGridType.EGridWaitBuy;
                if ((tx * 2 + 1) == dimensions.x)
                    m_arrGridType[tx, sy] = PlacementGridType.EGridOpen;
            }
        }

        /// <summary>
        /// Set collider's size and center
        /// </summary>
        void ResizeCollider()
        {
            var myCollider = GetComponent<BoxCollider>();
            Vector3 size = new Vector3(dimensions.x, 0, dimensions.y) * gridSize;
            myCollider.size = size;

            // Collider origin is our bottom-left corner
            myCollider.center = size * 0.5f;
        }

        /// <summary>
        /// Instantiates Tile Objects to visualise the grid and sets up the <see cref="m_AvailableCells" />
        /// </summary>
        protected void SetUpGrid()
        {
            PlacementTile tileToUse;
#if UNITY_STANDALONE
			tileToUse = placementTilePrefab;
#else
            tileToUse = placementTilePrefabMobile;
#endif

            if (tileToUse != null)
            {
                // Create a container that will hold the cells.
                var tilesParent = new GameObject("Container");
                tilesParent.transform.parent = transform;
                tilesParent.transform.localPosition = Vector3.zero;
                tilesParent.transform.localRotation = Quaternion.identity;
                m_Tiles = new PlacementTile[dimensions.x, dimensions.y];

                for (int y = dimensions.y - 1; y < dimensions.y; y++)
                {
                    for (int x = 0; x < dimensions.x; x++)
                    {
                        Vector3 targetPos = GridToWorld(new IntVector2(x, y), new IntVector2(1, 1));
                        targetPos.z -= 1.0f;
                        PlacementTile newTile = Instantiate(tileToUse);
                        newTile.transform.parent = tilesParent.transform;
                        newTile.transform.position = targetPos;
                        newTile.transform.localRotation = Quaternion.identity;

                        m_Tiles[x, y] = newTile;
                        newTile.SetTileType(m_arrGridType[x, y]);
                    }
                }
            }
        }

#if UNITY_EDITOR
        /// <summary>
        /// On editor/inspector validation, make sure we size our collider correctly.
        /// Also make sure the collider component is hidden so nobody can mess with its settings to ensure its integrity.
        /// Also communicates the idea that the user should not need to modify those values ever.
        /// </summary>
        void OnValidate()
        {
            // Validate grid size
            if (gridSize <= 0)
            {
                Debug.LogError("Negative or zero grid size is invalid");
                gridSize = 1;
            }

            // Validate dimensions
            if (dimensions.x <= 0 ||
                dimensions.y <= 0)
            {
                Debug.LogError("Negative or zero grid dimensions are invalid");
                dimensions = new IntVector2(Mathf.Max(dimensions.x, 1), Mathf.Max(dimensions.y, 1));
            }

            // Ensure collider is the correct size
            ResizeCollider();

            GetComponent<BoxCollider>().hideFlags = HideFlags.HideInInspector;
        }

        /// <summary>
        /// Draw the grid in the scene view
        /// </summary>
        void OnDrawGizmos()
        {
            Color prevCol = Gizmos.color;
            Gizmos.color = Color.yellow;

            Matrix4x4 originalMatrix = Gizmos.matrix;
            Gizmos.matrix = transform.localToWorldMatrix;

            // Draw local space flattened cubes
            for (int y = 0; y < dimensions.y; y++)
            {
                float freePos = 0;
                if ((y > 0) && (y == dimensions.y - 1))
                    freePos = gridFreePos;

                for (int x = 0; x < dimensions.x; x++)
                {
                    var position = new Vector3((x + 0.5f) * gridSize, 0, (y + 0.5f) * gridSize + freePos);
                    Gizmos.DrawWireCube(position, new Vector3(gridSize, 0, gridSize));
                }
            }

            Gizmos.matrix = originalMatrix;
            Gizmos.color = prevCol;

            // Draw icon too, in center of position
            Vector3 center = transform.TransformPoint(new Vector3(gridSize * dimensions.x * 0.5f,
                                                                  1,
                                                                  gridSize * dimensions.y * 0.5f));
            Gizmos.DrawIcon(center, "build_zone.png", true);
        }
#endif
    }
}