Client/GameClient/Assets/Game/HotUpdate/Views/MiniGame/TZFEGameVIew.cs

using System;
using System.Collections.Generic;
using ET;
using FairyGUI;
using UI.MiniGame;
using UnityEngine;

namespace GFGGame
{
    public class TZFEGameView : BaseWindow
    {
        private UI_TZFEGameView _ui;

        private int[,] Map;
        enum Direction { up, down, left, right};
        private Vector2 touchFirst = Vector2.zero;//手指开始按下的位置
        private Vector2 touchSecond = Vector2.zero;//手指拖动的位置
        private System.Random rand;

        //这个是数组的行数和列数，mapLength一般采用行列一样
        private int rows = 4;
        private int columns = 4;
        private int mapLength = 5;
        //得分
        private int score = 0;
        private int scoreMax = 0;
        //目标分数
        private int targetNum = 128;
        private int gameID;
        private Merge2048Game gameDate;
        private List<ActivityOpenCfg> activityGameDate;
        //评价
        private List<int> CustemsNum = new List<int>()
        {
            0,
            0,
            0,
        };
        private bool isMove;
        private bool isMerge;
        private struct NumPos
        {
            public int x;
            public int y;
            public bool isCreat;
        }
        //需要播放动效的列表
        private List<NumPos> numPosArray = new List<NumPos>();
        private int time = 0;

        private EffectUI _effectUI1;

        public override void Dispose()
        {
            EffectUIPool.Recycle(_effectUI1);
            _effectUI1 = null;
            if (_ui != null)
            {
                _ui.Dispose();
                _ui = null;
            }
            base.Dispose();
        }

        protected override void OnInit()
        {
            base.OnInit();
            packageName = UI_TZFEGameView.PACKAGE_NAME;
            _ui = UI_TZFEGameView.Create();
            this.viewCom = _ui.target;
            isfullScreen = true;
            isReturnView = true;
            _ui.m_numList.itemRenderer = ListNumItem;
            _ui.m_mask.onTouchBegin.Add(OnClickBegin);
            _ui.m_mask.onTouchEnd.Add(OnClickEnd);
            _ui.m_backBtn.onClick.Add(OnClickBtnBack);
            _ui.m_mergeBtn.onClick.Add(OnClickMergeTips);
            Map = new int[rows, columns];


            _effectUI1 = EffectUIPool.CreateEffectUI(_ui.m_effectTitle, "ui_Activity", "SGLL_Game_Text");
        }

        protected override void OnShown()
        {
            base.OnShown();
            if ((this.viewData as object[]).Length != 0 && this.viewData != null)
            {
                gameID = (int)(this.viewData as object[])[0];
            }
            else
            {
                gameID = 128;
            }
            gameDate = Merge2048GameArray.Instance.GetCfg(gameID);
            activityGameDate = ActivityOpenCfgArray.Instance.GetCfgsBytype(ConstLimitTimeActivityType.ActLimitStlyc);
            InitMap();
            UpdateView();
            UpdateList();
        }
        protected override void OnHide()
        {
            Timers.inst.Remove(UpdateTime);
            base.OnHide();
        }

        private void OnClickBtnBack()
        {
            string exitTip;
            if (gameDate.bonusLoseArr.Length == 0)
            {
                exitTip = "退出游戏不保存进度，不扣除任何次数和道具，是否退出？";
            }
            else
            {
                exitTip = "退出游戏会按失败结算，获得80%的奖励，是否退出？";
            }
            AlertUI.Show(exitTip)
            .SetLeftButton(true, "取消", (object data) =>
            {
            })
            .SetRightButton(true, "确定",async (object data) =>
            {
                var result = await MiniGameProxy.ReqMiniGameEnd(gameID, gameDate.type, time, false, activityGameDate[0].id,true);
                if (!result) return;
                this.Hide();
            });
        }

        private void InitMap()
        {
            for(int i = 0; i < rows; i++)
                for(int j = 0; j < columns; j++)
                {
                    Map[i, j] = 0;
                }
        }
        private void UpdateView()
        {
            time = 1;
            score = 0;
            targetNum = Merge2048GameArray.Instance.GetCfg(gameID).targetNum;
            CustemsNum[0] = Merge2048GameArray.Instance.GetCfg(gameID).timeStar3;
            CustemsNum[1] = Merge2048GameArray.Instance.GetCfg(gameID).timeStar2;
            CustemsNum[2] = Merge2048GameArray.Instance.GetCfg(gameID).timeStar1;
            _ui.m_star3.url = "ui://MiniGame/tb_zx_pt_star";
            _ui.m_target.url = ResPathUtil.GetMiniGamePicPath(Merge2048CfgArray.Instance.GetCfgsByidAndnum(gameDate.subType, targetNum)[0].resName, "TZFEGame");
            _ui.m_score.text = string.Format("分数：{0}", score.ToString());
            _ui.m_score.visible = false;
            _ui.m_time.visible = false;
            _ui.m_timeNum.visible = false;
            _ui.m_title.visible = false;
            rand = new System.Random();
            UpdateStar();
            Timers.inst.Add(1.0f, 0, UpdateTime);
        }
        private void UpdateScore()
        {
            _ui.m_score.text = string.Format("分数：{0}", score.ToString());
        }
        private void UpdateList()
        {
            RandomCreateNum();
            _ui.m_numList.numItems = rows * columns;
        }

        private void ListNumItem(int index, GObject item)
        {
            UI_numItem numItem = UI_numItem.Proxy(item);
            int x = index / rows;
            int y = index % columns;
            if(Map[x,y] == 0)
            {
                numItem.m_icon.visible = false;
            }
            else
            {
                //numItem.m_icon.url = string.Format("ui://MiniGame/sgll2_{0}", Map[x, y]);
                numItem.m_icon.url = ResPathUtil.GetMiniGamePicPath(Merge2048CfgArray.Instance.GetCfgsByidAndnum(gameDate.subType, Map[x, y])[0].resName, "TZFEGame");
                numItem.m_icon.visible = true;
            }
            //播放生成和合并动效
            for(int i=0; i<numPosArray.Count; i++)
            {
                if(x == numPosArray[i].x && y == numPosArray[i].y)
                {
                    if(numPosArray[i].isCreat)
                    {
                        numItem.m_t0.Play();
                        numPosArray.RemoveAt(i);
                        break;
                    }
                    else
                    {
                        numItem.m_t1.Play();
                        numPosArray.RemoveAt(i);
                        break;
                    }
                }
            }
            UI_numItem.ProxyEnd();
        }

        //随机生成数字2（%90），4（%10）
        private void RandomCreateNum()
        {
            bool gameOver = false;
            for(int i = 0;i< rows; i++)
            {
                for(int j = 0; j< columns; j++)
                {
                    if (Map[i, j] == 0)
                    {
                        gameOver = true;
                        break;
                    }
                }
            }
            if(!gameOver)
            {
                //GameOver(false);
                return;
            }
            while (true)
            {
                int x = rand.Next(0, rows);
                int y = rand.Next(0, columns);
                NumPos item;
                int num;
                int randNum = rand.Next(1, 11);
                if(randNum <= 9)
                {
                    num = 2;
                }
                else
                {
                    num = 4 ;
                }
                if (Map[x,y] == 0)
                {
                    Map[x, y] = num;
                    item.x = x;
                    item.y = y;
                    item.isCreat = true;
                    numPosArray.Add(item);
                    break;
                }
            }
        }

        /// <summary>
        /// 去零
        /// </summary>
        /// <param name="row">对于一行或一列元素</param>
        private void Remove0(int[] row,Direction dir,int xy = 0)
        {
            int pos = 0;
            int[] rowB = new int[row.Length];
            for (int i = 0; i < row.Length; i++)
            {
                rowB[i] = row[i];
            }
            for (int i = 0; i < row.Length; ++i)
            {
                if (row[i] != 0)
                {
                    row[pos] = row[i];
                    
                    //-----这里修改需要播放动效的数字位置列表-----
                    int x = 0;
                    int y = 0;
                    int nextX = 0;
                    int nextY = 0;
                    for (int t = 0; t < numPosArray.Count; t++)
                    {
                        switch (dir)
                        {
                            case Direction.up:
                                x = i;
                                y = xy;
                                nextX = pos;
                                nextY = xy;
                                break;
                            case Direction.down:
                                x = row.Length - 1 - i;
                                y = xy;
                                nextX = row.Length - 1 - pos;
                                nextY = xy;
                                break;
                            case Direction.left:
                                x = xy;
                                y = i;
                                nextX = xy;
                                nextY = pos;
                                break;
                            case Direction.right:
                                x = xy;
                                y = row.Length - 1 - i;
                                nextX = xy;
                                nextY = row.Length - 1 - pos;
                                break;
                        }
                        if(numPosArray.Count != 0 && numPosArray[t].x == x && numPosArray[t].y == y && pos != i)
                        {
                            numPosArray.RemoveAt(t);
                            NumPos item;
                            item.x = nextX;
                            item.y = nextY;
                            item.isCreat = false;
                            numPosArray.Add(item);
                        }
                    }
                    //---------------------------------------
                    pos++;
                    
                } 
            }
            for (; pos < row.Length; ++pos) row[pos] = 0;

            for(int i= 0; i< row.Length; i++)
            {
                if(row[i] != rowB[i])
                {
                    isMove = true;
                }
            }
        }
        /// <summary>
        /// 合并
        /// </summary>
        /// <param name="row">对于一行或一列元素，完成一次向左合并的操作</param>
        private void Merge(int[] row , Direction dir, int xy)
        {
            Remove0(row,dir,xy);
            // 相邻相同则合并
            for (int i = 0; i < row.Length - 1; ++i)
            {
                if (row[i] != 0 && row[i] == row[i + 1])
                {
                    row[i] *= 2;
                    row[i + 1] = 0;
                    //将合并的数字放入列表
                    NumPos item;
                    item = MoveAddNum(i, xy, dir, row.Length-1);
                    numPosArray.Add(item);
                    //-------
                    score += row[i];
                    UpdateScore();
                    if (row[i] == targetNum)
                    {
                        //游戏成功
                        GameOver(true);
                    }
                    isMerge = true;
                }
            }
            Remove0(row,dir,xy);
        }
        //将合并的数字位置放入列表的准备
        private NumPos MoveAddNum(int i, int xy, Direction dir,int length)
        {
            NumPos item = new NumPos();
            switch (dir)
            {
                case Direction.up:
                    item.x = i;
                    item.y = xy;
                    item.isCreat = false;
                    break;
                case Direction.down:
                    item.x = length - i;
                    item.y = xy;
                    item.isCreat = false;
                    break;
                case Direction.left:
                    item.x = xy;
                    item.y = i;
                    item.isCreat = false;
                    break;
                case Direction.right:
                    item.x = xy;
                    item.y = length - i;
                    item.isCreat = false;
                    break;
            }
            return item;
        }
        /// <summary>
        /// 上移
        /// </summary>
        /// <param name="map">原棋盘</param>
        /// <returns></returns>
        private void Up(int[,] map)
        {
            int[] arr = new int[rows];
            for (int j = 0; j < columns; ++j)
            {
                for (int i = 0; i < rows; ++i)
                {
                    arr[i] = map[i, j]; 
                }
                Merge(arr,Direction.up,j);
                for (int i = 0; i < rows; ++i) map[i, j] = arr[i];
            }
        }
        /// <summary>
        /// 下移
        /// </summary>
        private int[,] Down(int[,] map)
        {
            int[] arr = new int[rows];
            for (int j = 0; j < columns; ++j)
            {
                for (int i = 0; i < rows; ++i)
                {
                    arr[rows - 1 - i] = map[i, j];
                }
                Merge(arr,Direction.down ,j);
                for (int i = 0; i < rows; ++i) map[i, j] = arr[rows - 1 - i];
            }
            return map;
        }

        /// <summary>
        /// 左移
        /// </summary>
        private int[,] Left(int[,] map)
        {
            int[] arr = new int[columns];
            for (int i = 0; i < rows; ++i)
            {
                for (int j = 0; j < columns; ++j)
                {
                    arr[j] = map[i, j];
                }
                Merge(arr,Direction.left,i);
                for (int j = 0; j < columns; ++j) map[i, j] = arr[j];
            }
            return map;
        }
        /// <summary>
        /// 右移
        /// </summary>
        private int[,] Right(int[,] map)
        {
            int[] arr = new int[columns];
            for (int i = 0; i < rows; ++i)
            {
                for (int j = 0; j < columns; ++j)
                {
                    arr[columns - 1 - j] = map[i, j];
                }
                Merge(arr,Direction.right,i);
                for (int j = 0; j < columns; ++j) map[i, j] = arr[columns - 1 - j];
            }
            return map;
        }
        /// <summary>
        /// 进行一次移动操作
        /// </summary>
        /// <param name="map">原棋盘</param>
        /// <param name="dir">移动的方向（枚举）</param>
        private void Move(int[,] map, Direction dir)
        {
            switch (dir)
            {
                case Direction.up:
                    Up(map); break;
                case Direction.down:
                    Down(map); break;
                case Direction.left:
                    Left(map); break;
                case Direction.right:
                    Right(map); break;
            }
            if(isMerge || isMove)
            {
                isMove = false;
                isMerge = false;
                UpdateList();
                numPosArray.Clear();
            }
            else
            {
                CheckArray();
            }
        }

        private void OnClickBegin()
        {
            touchFirst = Input.mousePosition;//记录开始按下的位置
        }
        private void OnClickEnd()
        {
            touchSecond = Input.mousePosition;//记录拖动的位置
            if (touchSecond.x < touchFirst.x && Math.Abs(touchSecond.x - touchFirst.x) > Math.Abs(touchSecond.y - touchFirst.y))
            {
                //向左滑动
                Move(Map, Direction.left);
            }
            if (touchSecond.x > touchFirst.x && Math.Abs(touchSecond.x - touchFirst.x) > Math.Abs(touchSecond.y - touchFirst.y))
            {
                //向右滑动
                Move(Map, Direction.right);
            }
            if (touchSecond.y < touchFirst.y && Math.Abs(touchSecond.y - touchFirst.y) > Math.Abs(touchSecond.x - touchFirst.x))
            {
                //向下滑动
                Move(Map, Direction.down);
            }
            if (touchSecond.y > touchFirst.y && Math.Abs(touchSecond.y - touchFirst.y) > Math.Abs(touchSecond.x - touchFirst.x))
            {
                //向上滑动
                Move(Map, Direction.up);
            }
            touchFirst = touchSecond;
        }

        private void OnClickMergeTips()
        {
            ViewManager.Show<SyntheticRoutetipView>(new object[] { targetNum , gameDate.subType}) ;
        }
        private void UpdateTime(object param = null)
        {
            _ui.m_timeNum.text = sec_to_hms(time);
            time++;
            //UpdateStar();
        }

        private void UpdateStar()
        {
            int starNum = 0;
            for (int i = CustemsNum.Count - 1; i >= 0; i--)
            {
                if (time <= CustemsNum[i])
                {
                    starNum += 1;
                }
            }
            switch (starNum)
            {
                case 1:
                    _ui.m_star1.url = "ui://MiniGame/tb_zx_pt_star";
                    _ui.m_star2.url = "ui://MiniGame/tb_zx_pt_star_grey";
                    _ui.m_star3.url = "ui://MiniGame/tb_zx_pt_star_grey";
                    break;
                case 2:
                    _ui.m_star1.url = "ui://MiniGame/tb_zx_pt_star";
                    _ui.m_star2.url = "ui://MiniGame/tb_zx_pt_star";
                    _ui.m_star3.url = "ui://MiniGame/tb_zx_pt_star_grey";
                    break;
                case 3:
                    _ui.m_star1.url = "ui://MiniGame/tb_zx_pt_star";
                    _ui.m_star2.url = "ui://MiniGame/tb_zx_pt_star";
                    _ui.m_star3.url = "ui://MiniGame/tb_zx_pt_star";
                    break;
                default:
                    _ui.m_star1.visible = false;
                    _ui.m_star2.visible = false;
                    _ui.m_star3.visible = false;
                    break;
            }
        }

        //将秒数转化为时分秒 duration为秒数
        private string sec_to_hms(int duration)
        {
            TimeSpan ts = new TimeSpan(0, 0, duration);
            int _hours = 0;
            if (ts.Days > 0)
            {
                _hours = ts.Days * 24;
            }
            string str = "";
            if (ts.Hours > 0)
            {

                str = String.Format("{0:00}", ts.Hours + _hours) + ":" + String.Format("{0:00}", ts.Minutes) + ":" + String.Format("{0:00}", ts.Seconds);
            }
            if (ts.Hours == 0 && ts.Minutes > 0)
            {
                str = "00:";
                if (_hours > 0)
                {
                    str = String.Format("{0:00}", ts.Hours + _hours) + ":";
                }
                str += String.Format("{0:00}", ts.Minutes) + ":" + String.Format("{0:00}", ts.Seconds);
            }
            if (ts.Hours == 0 && ts.Minutes == 0)
            {
                str = "00";
                if (_hours > 0)
                {
                    str = String.Format("{0:00}", ts.Hours + _hours);
                }
                str += ":00:" + String.Format("{0:00}", ts.Seconds);
            }
            return str;
        }
        private void CheckArray()
        {
            bool gameOver = false;
            for (int i = 0; i < rows; i++)
            {
                for (int j = 0; j < columns; j++)
                {
                    if (Map[i, j] == 0)
                    {
                        gameOver = true;
                        break;
                    }
                }
            }
            if (!gameOver)
            {
                // 游戏结束
                GameOver(false);
                return;
            }
        }

        private void GameOver(bool target)
        {
            Timers.inst.Remove(UpdateTime);
            ViewManager.Show<ResultTipsView>(new object[]{target, gameDate.type, time, gameDate.id });
        }
    }
}