Game2048

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

namespace SeqListSort
{
    /// <summary>
    /// <ather>
    /// <lihonglin>
    /// </ather>
    /// <countent>
    /// 2048游戏规则：
　　///开始时棋盘内随机出现两个数字，出现的数字仅可能为2或4
　　///玩家可以选择上下左右四个方向，若棋盘内的数字出现位移或合并，视为有效移动
　　///玩家选择的方向上若有相同的数字则合并，每次有效移动可以同时合并，但不可以连续合并
    ///合并所得的所有新生成数字相加即为该步的有效得分
　　///玩家选择的方向行或列前方有空格则出现位移
　　///每有效移动一步，棋盘的空位(无数字处)随机出现一个数字(依然可能为2或4)
　　///棋盘被数字填满，无法进行有效移动，判负，游戏结束
　　///棋盘上出现2048，判胜，游戏结束
    /// </countent>
    /// </summary>
    //public struct Point
    //{
    //    public int x;
    //    public int y;
    //    public Point(int _x, int _y)
    //    {
    //        this.x = _x;
    //        this.y = _y;
    //    }
    //}
    public enum DIR_TYPE
    {
        TOP,
        LEFT,
        RIGHT,
        BOTTOM
    }
    class Game2048
    {
        const int n = ;
        static int[,] map = new int[n,n];//定义棋盘
        static int[] temp = new int[n+];//一个临时数组，存放十六个位置数据

        static int score = ;

        static Stack<Point> fullCell = new Stack<Point>();//格子是否已满 这个暂时没有用到，愿意是用它来充当临时数组

        public static void GameRandom()
        {
            Random r = new Random();
            int x = ;
            int y = ;
            do
            {
                x = r.Next(, n);
                y = r.Next(, n);
            } while ( map[x,y] != );
            Thread.Sleep();
            if (r.Next(, n + ) % n == )
            {
                map[x,y] = ;
            }
            else
            {
                map[x, y] = ;
            }
            fullCell.Push(new Point(x, y));
        }
        public static void GameInit()
        {
            GameRandom();
            GameRandom();
            Display();
        }
        public static void Display()
        {
            Console.WriteLine("分数 = " + score);
            for (int i = ; i < n; ++i)
            {
                for (int j = ; j < n; ++j)
                {
                    Console.Write("{0,-6}" , map[i, j]);
                }
                Console.WriteLine();
            }
            GameOverOrWine();
        }
        public static void GameContral()
        {
            DIR_TYPE type = DIR_TYPE.TOP;
            while (true)
            {

                Console.WriteLine("请按w、a、s、d键上下左右控制'0'键退出");
                char ch = Convert.ToChar(Console.ReadLine());
                if (ch == 'a'|| ch == 'A' || ch == 'W'|| ch == 'w' || ch == ''
                    || ch == 'S'|| ch == 's' ||ch == 'D'|| ch == 'd' )
                {
                    Console.Clear();
                }
                else
                {
                    Console.WriteLine("按下非法键，请重新按！");
                    continue;
                }

                switch (ch)
                {
                    case '':
                        {
                            Console.WriteLine("是否退出游戏！（y/n）");
                            ch = Convert.ToChar(Console.ReadLine());
                            if (ch == 'y' || ch == 'Y')
                            {
                                Environment.Exit();
                            }
                            else
                            {
                                Console.Clear();
                            }
                        }
                        break;
                    case 'A':
                    case 'a':
                        {
                            type = DIR_TYPE.LEFT;
                        }
                        break;
                    case 'D':
                    case 'd':
                        {
                            type = DIR_TYPE.RIGHT;
                        }
                        break;
                    case 'W':
                    case 'w':
                        {
                            type = DIR_TYPE.TOP;
                        }
                        break;
                    case 'S':
                    case 's':
                        {
                            type = DIR_TYPE.BOTTOM;
                        }
                        break;
                }
                GameRun(type);
                Display();
            }
        }
        //玩家可以选择上下左右四个方向，若棋盘内的数字出现位移或合并，视为有效移动
        public static int GameMove( )
        {
            int change = ;
            int i = ;
            int j = ;
            do //去掉中间的0
            {
                for (i = ; i < n; ++i )
                {
                    if ( == temp[i])//玩家选择的方向行或列前方有空格则出现位移
                    {
                        if (temp[i] != temp[i + ])//不相等移动
                        {
                            change = ;//有效移动
                        }
                        temp[i] = temp[i + ];
                        temp[i + ] = ;
                    }
                }
                j++;
            } while (j < n);

            for (i = ; i < n; ++i )
            {
                //玩家选择的方向上若有相同的数字则合并，每次有效移动可以同时合并，但不可以连续合并
                if (temp[i] == temp[i - ])//相同的数字则合并
                {
                    if ( != temp[i])
                    {
                        change = ;
                        score += temp[i];
                    }
                    temp[i - ] += temp[i - ];//前一个数字乘自己
                    temp[i] = ;// 后一个位置 置0
                }

            }
            return change;
        }
        public static void GameOverOrWine()
        {
            int count = ;//记录格子里不为0 的个数
            if (score >=  <<  )
            {
                Console.WriteLine("您胜利了 88！");
                Thread.Sleep();
                Environment.Exit();
            }
            else
            {
                for (int i = ; i < n; ++i)
                {
                    for (int j = ; j < n; ++j)
                    {
                        if ( map[i,j] !=  )
                        {
                            count++;
                            if ( count == n * n )
                            {
                                Console.WriteLine("game over");
                                Thread.Sleep();
                                Environment.Exit();
                            }
                        }
                        if ( map[i,j] >=  )
                        {
                            Console.WriteLine("您胜利了 88！");
                            Thread.Sleep();
                            //Environment.Exit(0);
                        }
                    }
                }
            }

        }
        public static void GameRun(DIR_TYPE type)
        {

            int i = ;
            int j = ;
            int change = ;/*判断格子中的数是否改变，0不变*/

            if (type == DIR_TYPE.LEFT || type == DIR_TYPE.RIGHT)
            {
                for (i = ; i < n; ++i)
                {
                    for (j = ; j < n; ++j)
                    {
                        if (type == DIR_TYPE.LEFT)
                        {
                            temp[j] = map[i, j];//把每一行数据放到临时数组中
                        }
                        else
                        {
                            temp[j] = map[i,  - j];
                        }
                    }
                    //temp[4] = 0;

                    change += GameMove();//处理每一行数据，进行移除中间的0，合并相同数字，根据change的值可以产生随机数

                    for (j = ; j < n; ++j)
                    {
                        if (type == DIR_TYPE.LEFT)
                        {
                            map[i, j] = temp[j];// 把每一行处理完的数据在放回到地图中
                        }
                        else
                        {
                            map[i,  - j] = temp[j];
                        }
                    }
                }
            }
            else
            {

                for (i = ; i < n; ++i)
                {
                    for (j = ; j < n; ++j)
                    {

                        if (type == DIR_TYPE.TOP)
                        {
                            temp[j] = map[j, i];//把每一列数据存进去
                        }
                        else if (type == DIR_TYPE.BOTTOM)
                        {
                            temp[j] = map[ - j, i];
                        }

                    }
                    temp[] = ;
                    change += GameMove();

                    for (j = ; j < n; ++j)
                    {
                        if (type == DIR_TYPE.TOP)
                        {
                            map[j, i] = temp[j]; //把处理好的中间变量移回来
                        }
                        else if (type == DIR_TYPE.BOTTOM)
                        {
                            map[ - j, i] = temp[j];
                        }
                    }
                }
            }

            if (change > )
            {
                GameRandom();
            }
        }
    }
}