修复了新手引导多次点击开宝箱页面BUG 所有塔不论上不上阵均受缩放影响 冰冻效果只显示1次 结算页面动效修改 修改地面

wangguan

2020-12-07 7d526eef93f8071121dfcfcd4a039b9e51dc3d67

 Assets/Scripts/TowerDefense/Towers/Placement/TowerPlacementGridEndless.cs

@@ -1,10 +1,10 @@
using System;
using System.Collections.Generic;
using Core.Utilities;
using KTGMGemClient;
using TowerDefense.Level;
using TowerDefense.UI.HUD;
using UnityEngine;
using UnityEngine.UI;

namespace TowerDefense.Towers.Placement
{
@@ -13,9 +13,9 @@
    /// 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 TowerPlacementGridEndless : MonoBehaviour, IPlacementArea
    public class TowerPlacementGridEndless : Singleton<TowerPlacementGridEndless>, IPlacementArea
    {
        public static float GRID_OPENCASH = 100;
        public static float GRID_OPENCASH = 200;

        /// <summary>
        /// Prefab used to visualise the grid.
@@ -36,7 +36,7 @@
        /// <summary>
        /// 等待购买开启对应按钮.
        /// </summary>
        public Button waitBuyBtnPrefab;
        public GameObject waitBuyBtnPrefab;

        /// <summary>
        /// 最后一行格子与前一行格子之间的空位长度.
@@ -44,6 +44,10 @@
        public float gridFreePos;

        public float gridFreePos2;

        public float gridFreePos3;

        public float gridFreePos4;

        /// <summary>
        /// The dimensions of the grid 
@@ -54,7 +58,7 @@
        /// Size of the edge of a cell
        /// </summary>
        [Tooltip("The size of the edge of one grid cell for area. Should match the physical grid size of towers")]
        public float gridSize = 1;
        public float gridSize = 1;//1.109

        /// <summary>
        /// Inverted grid size, to multiply with
@@ -77,10 +81,19 @@
        /// </summary>
        private EndlessTowerGridOpen[,] m_arrTGO;

        public GameObject[] TowerGridOpenObjArr;

        private float[,] m_arrCoinGenTime;

        public GameObject GridContainer;

        /// <summary>
        /// 每一个Tile格子的中心店的世界坐标
        /// 所有格子对应的世界坐标
        /// </summary>
        private Vector3[,] GridWorldPosArr;

        /// <summary>
        /// 每一个Tile格子的中心店的屏幕坐标
        /// </summary>
        private Vector2[,] arrGridCentPos;

@@ -114,6 +127,20 @@

        private EnergyUICtl[,] arrTowerEnergyUi;

        private FreezeBreath[,] arrTowerFreezeBreathUi;

        private GameObject[,] arrTowerEnergyEffect;

        /// <summary>
        /// 水精灵充能满特效
        /// </summary>
        private GameObject[,] arrTowerFreezeBreathEffect;

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

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

        /// <summary>
        /// 水精灵塔技能（冷冻气息）充能条
        /// </summary>
        public GameObject FreezeBreathChargePrefab;

        /// <summary>
        /// 水精灵塔充能条特效
        /// </summary>
        public GameObject FreezeBreathChargeEffect;

        /// <summary>
        /// Converts a location in world space into local grid coordinates.
@@ -182,6 +219,16 @@
            return arrTowerEnergyUi[x, 3 - y];
        }

        /// <summary>
        /// 获取水精灵对应位置的充能条
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <returns></returns>
        public FreezeBreath GetFreezeBreath(int x, int y)
        {
            return arrTowerFreezeBreathUi[x, 3 - y];
        }

        /// <summary>
        /// 获取一个可以放置塔防的位置.
@@ -268,10 +315,14 @@
        public bool isFreeAtackPos(int x, int y)
        {
            if (m_AvailableCells[x, y])
            {
                return false;
            }

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

            return false;
        }
@@ -400,6 +451,14 @@
                freePos = gridFreePos;
            else if (gridPosition.y == 2)
                freePos = gridFreePos2;
            else if (gridPosition.y == 1)
            {
                freePos = gridFreePos3;
            }
            else if (gridPosition.y == 0)
            {
                freePos = gridFreePos4;
            }
            // Calculate scaled local position
            Vector3 localPos = new Vector3(gridPosition.x + (sizeOffset.x * 0.5f), 0, gridPosition.y + (sizeOffset.y * 0.5f) + freePos) *
                               gridSize;
@@ -514,8 +573,9 @@
        /// <summary>
        /// Initialize values
        /// </summary>
        protected virtual void Awake()
        protected override void Awake()
        {
            base.Awake();
            ResizeCollider();

            // Initialize empty bool array (defaults are false, which is what we want)
@@ -531,14 +591,59 @@
        {
            // 初始化塔位类型.
            initTileGridType();
            InitGridWorldPos();

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

            SetUpGrid();
            // 初始化格子对应的屏幕坐标数据 延迟执行
            Invoke("preCalculateGridUIPos", 0.3f);
            EventCenter.Ins.Add<int>((int)KTGMGemClient.EventType.EndlessCritBulletNumChange, OnCritBulletNumChange);
            EventCenter.Ins.Add((int)KTGMGemClient.EventType.OpenAllTowerGrid, OpenAllTowerGrid);
        }

            // 初始化格子对应的屏幕坐标数据
            preCalculateGridUIPos();
        /// <summary>
        /// 初始化所有格子的世界坐标（中心）
        /// </summary>
        private void InitGridWorldPos()
        {
            GridWorldPosArr = new Vector3[dimensions.x, dimensions.y];

            for (int i = 0; i < dimensions.x; ++i)
            {
                for (int j = 0; j < dimensions.y; ++j)
                {
                    GridWorldPosArr[i, j] = GridToWorld(new IntVector2(i, j), new IntVector2(1, 1));
                }
            }
        }

        /// <summary>
        /// 根据坐标获取格子世界坐标（中心）
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <returns></returns>
        public Vector3 GetGridWorldPos(int x, int y)
        {
            if (x < 0 || x >= dimensions.x || y < 0 || y >= dimensions.y) return new Vector3();

            return GridWorldPosArr[x, y];
        }

        /// <summary>
        /// 木属性暴击子弹数量改变
        /// </summary>
        /// <param name="count"></param>
        private void OnCritBulletNumChange(int count)
        {
            for (int i = 0; i < dimensions.x; ++i)
            {
                for (int j = 0; j < AttackRowNumbers; ++j)
                {
                    arrTowerBulletUi[i, j].CritBulletNum = count;
                }
            }
        }

        /// <summary>
@@ -550,7 +655,7 @@
        {
            arrGridCentPos = new Vector2[dimensions.x, dimensions.y];

            Vector3 targetPos = GridToWorld(new IntVector2(0, 0), new IntVector2(1, 1));
            Vector3 targetPos = GetGridWorldPos(0, 0);

            if (!ViewPortAdj.instance.bAdjViewPort)
                ViewPortAdj.instance.adjViewportRect();
@@ -569,32 +674,43 @@
            // 血条位置的设定
            PreCalculateTowerBloodUi();

            float[] gapArr = { 0.5f, 1f };
            m_arrTGO = new EndlessTowerGridOpen[dimensions.x, dimensions.y];

            GameObject container = GameObject.Find("BuyButtonContainer");
            TowerPlacementGridEndless.GRID_OPENCASH = 200;
            //Debug.Log("修改了数值:" + TowerPlacementGridEndless.GRID_OPENCASH);
            //float[] xup = { -0.6f, -0.3f, 0, 0.3f, 0.6f };
            for (int x = 0; x < dimensions.x; ++x)
            {
                for (int y = dimensions.y - AttackRowNumbers; y < dimensions.y; ++y)
                {
                    if (m_arrGridType[x, y] != PlacementGridType.EGridWaitBuy) continue;

                    GameObject container = GameObject.Find("BuyButtonContainer");
                    Button buyButton = Instantiate(waitBuyBtnPrefab);
                    buyButton.transform.SetParent(container.transform);
                    GameObject buyButton = Instantiate(waitBuyBtnPrefab);
                    buyButton.transform.SetParent(container.transform, false);

                    Vector3 pos = buyButton.transform.position;
                    pos.x = arrGridCentPos[x, y].x;
                    pos.z = arrGridCentPos[x, y].y + (y - AttackRowNumbers) * 1.9f;
                    //pos.x = arrGridCentPos[x, y].x + (x - 2) * gapArr[3 - y] + xup[x];
                    pos.x = arrGridCentPos[x, y].x + (x - 2) * gapArr[3 - y];
                    pos.z = arrGridCentPos[x, y].y + 6f;
                    // if (y == 2)
                    // {
                    //     pos.z = arrGridCentPos[x, y].y + 9f;
                    // }
                    // else if (y == 3)
                    // {
                    //     pos.z = arrGridCentPos[x, y].y + 7f;
                    // }
                    pos.y = 30;
                    buyButton.transform.position = pos;
                    buyButton.transform.localRotation = Quaternion.identity;
                    buyButton.transform.localScale = Vector3.one;

                    // 设置按钮对应的点击功能
                    EndlessTowerGridOpen tgo = buyButton.GetComponent<EndlessTowerGridOpen>();
                    if (tgo)
                    {
                        tgo.SetBuyBtnInfo(x, y, this);
                        tgo.cashText.SetText(TowerPlacementGrid.GRID_OPENCASH_SELF.ToString());
                        tgo.cashText.SetText(TowerPlacementGridEndless.GRID_OPENCASH.ToString());
                        m_arrTGO[x, y] = tgo;
                    }
                }
@@ -642,6 +758,11 @@
            m_arrTowerBulletUIPos = new Vector2[dimensions.x, AttackRowNumbers];
            arrTowerBulletUi = new BulletUICtl[dimensions.x, AttackRowNumbers];
            arrTowerEnergyUi = new EnergyUICtl[dimensions.x, AttackRowNumbers];
            arrTowerFreezeBreathUi = new FreezeBreath[dimensions.x, AttackRowNumbers];
            arrTowerEnergyEffect = new GameObject[dimensions.x, AttackRowNumbers];
            arrTowerFreezeBreathEffect = new GameObject[dimensions.x, AttackRowNumbers];

            float[] gapArr = { 0.4f, 0.6f };

            for (int x = 0; x < dimensions.x; x++)
            {
@@ -652,6 +773,7 @@
                    m_arrTowerBulletUIPos[x, y].x = arrGridCentPos[x, dy - y].x;
                    m_arrTowerBulletUIPos[x, y].y = arrGridCentPos[x, dy - y].y;

                    // 现在PVE基地不需要血条
                    GameObject img = Instantiate(towerBloodUIPrefab);
                    GameObject container = GameObject.Find("BuyButtonContainer");
                    img.transform.SetParent(container.transform);
@@ -667,15 +789,15 @@
                    arrTowerBloodUi[x, y] = tbv;
                    tbv.gameObject.SetActive(false);

                    Vector3 targetPos = GridToWorld(new IntVector2(x, dy - y), new IntVector2(2, 1));

                    // 子弹条
                    img = Instantiate(towerBulletUIPrefab);
                    img.transform.SetParent(container.transform, true);
                    tpos = img.transform.position;
                    tpos.x = m_arrTowerBulletUIPos[x, y].x + 4.2f;
                    tpos.z = m_arrTowerBulletUIPos[x, y].y + 1.1f -  y * 1.66f;
                    tpos.y = 30f;
                    img.transform.position = tpos;
                    img.transform.localScale = Vector3.one;
                    img.transform.localRotation = Quaternion.identity;
                    img.transform.SetParent(transform, false);
                    img.transform.position = targetPos;
                    Vector3 pos = img.transform.position;
                    pos.x -= 1f;
                    img.transform.position = pos;

                    BulletUICtl buc = img.GetComponent<BulletUICtl>();
                    arrTowerBulletUi[x, y] = buc;
@@ -685,8 +807,8 @@
                    img = Instantiate(towerEnergyUIPrefab);
                    img.transform.SetParent(container.transform);
                    tpos = img.transform.position;
                    tpos.x = m_arrTowerBulletUIPos[x, y].x + 4.2f;
                    tpos.z = m_arrTowerBulletUIPos[x, y].y + 1.1f - y * 1.66f;
                    tpos.x = m_arrTowerBulletUIPos[x, y].x + 4.4f + (x - 2) * gapArr[y];
                    tpos.z = m_arrTowerBulletUIPos[x, y].y + 5f;
                    tpos.y = 30f;
                    img.transform.position = tpos;
                    img.transform.localScale = Vector3.one;
@@ -695,13 +817,38 @@
                    EnergyUICtl euc = img.GetComponent<EnergyUICtl>();
                    arrTowerEnergyUi[x, y] = euc;
                    euc.gameObject.SetActive(false);

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

                    arrTowerEnergyEffect[x, y] = Instantiate(energyEffectPrefab);
                    arrTowerEnergyEffect[x, y].transform.position = vpos;

                    // 创建水精灵充能条
                    img = Instantiate(FreezeBreathChargePrefab);
                    img.transform.SetParent(container.transform);
                    tpos = img.transform.position;
                    tpos.x = m_arrTowerBulletUIPos[x, y].x + 4.4f + (x - 2) * gapArr[y];
                    tpos.z = m_arrTowerBulletUIPos[x, y].y + 5f;
                    tpos.y = 30f;
                    img.transform.position = tpos;
                    img.transform.localScale = Vector3.one;
                    img.transform.localRotation = Quaternion.identity;

                    FreezeBreath freezeBreath = img.GetComponent<FreezeBreath>();
                    arrTowerFreezeBreathUi[x, y] = freezeBreath;
                    freezeBreath.gameObject.SetActive(false);

                    arrTowerFreezeBreathEffect[x, y] = Instantiate(FreezeBreathChargeEffect);
                    arrTowerFreezeBreathEffect[x, y].transform.position = vpos;
                }
            }
        }

        public void updateGridOpenCoin(int ix, int iy)
        {
            GRID_OPENCASH += GRID_OPENCASH;
            GRID_OPENCASH = Mathf.Floor(GRID_OPENCASH * 1.25f);

            for (int x = 0; x < dimensions.x; x++)
            {
@@ -754,6 +901,30 @@
        }

        /// <summary>
        /// 免费开启所有塔位
        /// </summary>
        public void OpenAllTowerGrid()
        {
            int sy = dimensions.y - 1;

            for (int tx = 0; tx < dimensions.x; tx++)
            {
                if (m_arrGridType[tx, sy - 1] == PlacementGridType.EGridWaitBuy)
                {
                    BuyTowerGrid(tx, sy - 1);
                    Destroy(m_arrTGO[tx, sy - 1].gameObject);
                    ++GameConfig.EndlessOpenAttackTowerCount;
                }
                if (m_arrGridType[tx, sy] == PlacementGridType.EGridWaitBuy)
                {
                    BuyTowerGrid(tx, sy);
                    Destroy(m_arrTGO[tx, sy].gameObject);
                    ++GameConfig.EndlessOpenAttackTowerCount;
                }
            }
        }

        /// <summary>
        /// 购买对应的待购攻击塔位.
        /// </summary>
        /// <param name="x"></param>
@@ -779,12 +950,65 @@

            for (int tx = 0; tx < dimensions.x; tx++)
            {
                m_arrGridType[tx, sy] = PlacementGridType.EGridWaitBuy;
                m_arrGridType[tx, sy - 1] = PlacementGridType.EGridWaitBuy;
                m_arrGridType[tx, sy] = PlacementGridType.EGridOpen;
            }
            // 设置塔位默认开启，后面需要根据配置来
            m_arrGridType[2, 3] = PlacementGridType.EGridOpen;
            ++GameConfig.EndlessOpenAttackTowerCount;
        }

        /// <summary>
        /// 在指定的位置播放充能成功的特效.
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <param name="play">是播放还是停止播放</param>
        public void PlayEnergyEffect(int x, int y, bool play = true)
        {
            int dy = dimensions.y - 1 - y;

            if (!arrTowerEnergyEffect[x, dy]) return;

            ParticleSystem ps = arrTowerEnergyEffect[x, dy].GetComponent<ParticleSystem>();

            if (ps == null)
                ps = arrTowerEnergyEffect[x, dy].transform.GetChild(0).GetComponent<ParticleSystem>();

            if (play)
            {
                if (!arrTowerEnergyEffect[x, dy].gameObject.activeSelf)
                    arrTowerEnergyEffect[x, dy].gameObject.SetActive(true);
                ps.Play();
            }
            else
            {

                ps.Stop();
                arrTowerEnergyEffect[x, dy].gameObject.SetActive(false);
            }
        }

        public void PlayFreezeBreathEffect(int x, int y, bool play = true)
        {
            int dy = dimensions.y - 1 - y;

            if (!arrTowerFreezeBreathEffect[x, dy]) return;

            ParticleSystem ps = arrTowerFreezeBreathEffect[x, dy].GetComponent<ParticleSystem>();

            if (ps == null)
                ps = arrTowerFreezeBreathEffect[x, dy].transform.GetChild(0).GetComponent<ParticleSystem>();

            if (play)
            {
                if (!arrTowerFreezeBreathEffect[x, dy].gameObject.activeSelf)
                    arrTowerFreezeBreathEffect[x, dy].gameObject.SetActive(true);
                ps.Play();
            }
            else
            {
                ps.Stop();
                arrTowerFreezeBreathEffect[x, dy].gameObject.SetActive(false);
            }
        }

        /// <summary>
@@ -807,7 +1031,8 @@
        {
            PlacementTile tileToUse;
#if UNITY_STANDALONE
         tileToUse = placementTilePrefab;
            //tileToUse = placementTilePrefab;
            tileToUse = placementTilePrefabMobile;
#else
            tileToUse = placementTilePrefabMobile;
#endif
@@ -826,7 +1051,7 @@
                {
                    for (int x = 0; x < dimensions.x; x++)
                    {
                        Vector3 targetPos = GridToWorld(new IntVector2(x, y), new IntVector2(1, 1));
                        Vector3 targetPos = GetGridWorldPos(x, y);
                        targetPos.z -= 1.0f;
                        PlacementTile newTile = Instantiate(tileToUse);
                        newTile.transform.parent = tilesParent.transform;
@@ -835,9 +1060,123 @@

                        m_Tiles[x, y] = newTile;
                        newTile.SetTileType(m_arrGridType[x, y]);
                        newTile.SetRender(false, "");//初始化不显示
                    }
                }
            }
        }

        PlacementTile currentCanPlace;//记录当前标记

        /// <summary>
        /// 开始拖拽的时候判断哪些可以放置
        /// </summary>
        /// <param name="allTowerP">不符合条件的数组</param>
        public void CheckAllCanPlace(List<IntVector2> allTowerP)
        {
            int iy = dimensions.y - 1;//3
            bool canPlace;
            currentCanPlace = null;
            for (int ix = 0; ix < dimensions.x; ix++)
            {
                for (int y = iy; y >= dimensions.y - AttackRowNumbers; --y)
                {
                    if (m_arrGridType[ix, y] == PlacementGridType.EGridOpen)
                    {
                        canPlace = true;
                        if (allTowerP != null)
                        {
                            for (int i = 0; i < allTowerP.Count; i++)
                            {
                                if (allTowerP[i].x == ix && allTowerP[i].y == y)
                                {
                                    canPlace = false;
                                    break;
                                }
                            }
                        }
                        //m_Tiles[ix, y].CheckCanPlace(canPlace);
                    }
                }
            }
        }


        /// <summary>
        /// 播放升级动画
        /// </summary>
        /// <param name="allTowerP"></param>
        public void PlayPS(List<IntVector2> allTowerP)
        {
            // for (int i = 0; i < allTowerP.Count; i++)
            // {
            //     m_Tiles[allTowerP[i].x, allTowerP[i].y].SetParticleSystem(true);
            // }
        }
        /// <summary>
        /// /// 停止所有升级动画
        /// </summary>
        public void StopPS()
        {
            // int iy = dimensions.y - 1;//3
            // for (int ix = 0; ix < dimensions.x; ix++)
            // {
            //     for (int y = iy; y >= dimensions.y - AttackRowNumbers; --y)
            //     {
            //         if (m_arrGridType[ix, y] == PlacementGridType.EGridOpen)
            //         {
            //             m_Tiles[ix, y].SetParticleSystem(false);
            //         }
            //     }
            // }
        }

        /// <summary>
        /// 拖动时候实时检查距离哪个格子近
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        public void CheckCanPlaceUpdate(int x, int y, bool isEmpty, string towerName)
        {
            CloseCanPlace();
            currentCanPlace = m_Tiles[x, y];
            currentCanPlace?.SetRender(true, isEmpty ? towerName : "");
            // if (isEmpty)
            // {
            //     currentCanPlace.SetTowerVirtualshadow(towerName);
            // }
        }

        /// <summary>
        /// 关闭上一个
        /// </summary>
        public void CloseCanPlace()
        {
            if (currentCanPlace != null)
            {
                currentCanPlace.SetRender(false, "");
                currentCanPlace = null;
            }
        }

        /// <summary>
        /// 关闭所有
        /// </summary>
        public void CloseCanPlaceRenderer()
        {
            int iy = dimensions.y - 1;
            for (int ix = 0; ix < dimensions.x; ix++)
            {
                for (int y = iy; y >= dimensions.y - AttackRowNumbers; --y)
                {
                    if (m_arrGridType[ix, y] == PlacementGridType.EGridOpen)
                    {
                        //m_Tiles[ix, y].CheckCanPlace(false);
                        m_Tiles[ix, y].SetRender(false, "");
                    }
                }
            }
            //StopPS();
        }

#if UNITY_EDITOR
@@ -888,7 +1227,10 @@
                    freePos = gridFreePos;
                else if (y > 0 && y == dimensions.y - 2)
                    freePos = gridFreePos2;

                else if (y > 0 && y == dimensions.y - 3)
                    freePos = gridFreePos3;
                else if (y == dimensions.y - 4)
                    freePos = gridFreePos4;
                for (int x = 0; x < dimensions.x; x++)
                {
                    var position = new Vector3((x + 0.5f) * gridSize, 0, (y + 0.5f) * gridSize + freePos);