游戏2048的核心算法c#版本的实现

　　　　接触游戏有一段时间了，也写了一些东西，效果还不错，今天没事，我就把2048 c# 版本的实现贴出来，代码已经测试过，可以正常、完美运行。当然了，在网上有很多有关2048的实现方法，但是没有提出到类里面，只是写的测试代码，我在这里已经完全提到类里面，核心类和核心方法都经过测试，没有问题。由于本人学习有漏，或者不足，也请大家批评指正，大家共同进步。

　　　   该文章分为三个部分，我们分门别类说的，大家也会很清楚。目录如下：

　　　　第一部分：图片展示，最开始，我还是先把程序的运行效果贴出来，大家有一个初步感受。

　　　　第二部分：代码的前端部分，因为我这个程序就是一个在控制台中运行的程序，没有界面。但是有些操作需要在控制台中操作，这部分代码在控制台中。

　　　　第三部分：2048核心的类和辅助类型，所有核心算法和实现都在这里，都已经封装了方法，直接调用就可以。

　　　　其实这三个部分很简单，每个部分都有自己的职责，废话不多说了，直接上代码。

　　　　一、2048 在控制台中的运行效果（主要以贴图为主。）

　　　　　　1、数据初始化

　　　　　　　　
　　　　　　这是程序第一次执行的效果，数据刚刚完成初始化。

　　　　　　2、操作开始，点击键盘的 a 字母代表向做移动，分为两张图，移动前和移动后的效果。

　　　　　　　　左移前
　　　　　　　　

　　　　　　　　左移后
　　　　　　　　

　　　　　　　3、点击键盘的 D 字符代表向右移动，分为两个图片，分别是移动前和移动后。

　　　　　　　　　　移动前
　　　　　　　　　　
　　　　　　　　　　移动后
　　　　　　　　　　

　　　　　　　　4、点击键盘的 w 字符代表向上移动，分为两个图片，分别是移动前和移动后。
　　　　　　　　　　移动前

　　　　　　　　　　

　　　　　　　　　　移动后
　　　　　　　　　　

　　　　　　　　5、点击键盘的 s 字符代表向下移动，分为两个图片，分别是移动前和移动后。
　　　　　　　　　　移动前

　　　　　　　　　　

　　　　　　　　　　移动后
　　　　　　　　　　

　　　　二、在控制台中控制逻辑和一些辅助方法，逻辑很简单，就不多说了，直接上代码。

GameCoreManager game = new GameCoreManager(5);

            game.Initail();

            Console.WriteLine("原始数组：");
            PrintArray(game.DataContainer);
            Console.WriteLine();

            while (true)
            {
                if (game.CalculateEmptyElements(game.DataContainer).Count <= 0)
                {
                    Console.WriteLine("游戏结束");
                    break;
                }
                switch (Console.ReadLine())
                {
                    case "w":
                        game.Move(Direction.Up);
                        break;
                    case "s":
                        game.Move(Direction.Down);
                        break;
                    case "a":
                        game.Move(Direction.Left);
                        break;
                    case "d":
                        game.Move(Direction.Right);
                        break;
                    case "exit":
                        break;
                }
                if (game.IsChange)
                {
                    game.GenerateRandomNumber();
                    PrintArray(game.DataContainer);
                }
            }

 　　　　　　　　以上代码就是放在控制台的 Main 方法中药执行的代码。

 　　　　　　　　这个代码主要适用于打印二维数组的，逻辑不复杂，用于在控制台中显示移动效果。
　　　　　　　　

/// <summary>
        /// 打印二维数组在控制台上。
        /// </summary>
        /// <param name="array">要打印数据的数组。</param>
        private static void PrintArray(int[,] array)
        {
            Console.Clear();
            if (array == null || array.Length <= 0)
            {
                Console.WriteLine("没有任何元素可以打印。");
            }

            for (int row = 0; row < array.GetLength(0); row++)
            {
                for (int column = 0; column < array.GetLength(1); column++)
                {
                    Console.Write(array[row,column]+"	");
                }
                Console.WriteLine();
            }
        }

　　　　　　　　在控制台中的代码就是这些，是不是很简单，其实不是很复杂，接下来我们看看核心类的实现。


　　　　三、2048 核心类 GameCoreManager 的实现，里面有完整的备注，所以我就不多说了。大家可以直接使用，测试。
　　　　　　

/// <summary>
    /// 游戏核心算法的管理器类型，该类型定义 2048 游戏的核心算法。
    /// </summary>
    public sealed class GameCoreManager
    {
        #region 实例字段

        private int[,] _dataContainer;

        #endregion

        #region 构造函数

        /// <summary>
        /// 初始化 GameCoreManager 类型的新实例，数据容器维度默认值：4.
        /// </summary>
        public GameCoreManager() : this(4) { }

        /// <summary>
        /// 通过制定的数据维度初始化 GameCoreManager 类型的新实例。
        /// </summary>
        /// <param name="capacity">数据容量。</param>
        public GameCoreManager(int capacity)
        {
            if (capacity <= 0 || capacity >= 32)
            {
                throw new ArgumentNullException("dimensional is null.");
            }
            DataContainer = new int[capacity, capacity];
        }

        #endregion

        #region 实例属性

        /// <summary>
        /// 获取数据
        /// </summary>
        public int[,] DataContainer { get => _dataContainer; private set => _dataContainer = value; }

        #endregion

        #region 实例接口方法

        /// <summary>
        /// 初始化游戏数据。
        /// </summary>
        public void Initail()
        {
            int length = DataContainer.GetLength(0) / 2 + DataContainer.GetLength(0) % 2;
            for (int i = 0; i < length; i++)
            {
                GenerateRandomNumber();
            }
        }

        /// <summary>
        /// 数据移动。
        /// </summary>
        /// <param name="direction">要移动的方向</param>
        public void Move(Direction direction)
        {
            //判断原数组是否发生了变化。
            //记录原数组。
            int[,] destinationArray = new int[DataContainer.GetLength(0), DataContainer.GetLength(1)];
            Array.Copy(DataContainer, destinationArray, DataContainer.Length);
            IsChange = false;

            switch (direction)
            {
                case Direction.Up:
                    MoveUp();
                    break;
                case Direction.Down:
                    MoveDown();
                    break;
                case Direction.Left:
                    MoveLeft();
                    break;
                case Direction.Right:
                    MoveRight();
                    break;
            }

            //比较现在的数组和以前的数组比较
            for (int row = 0; row < DataContainer.GetLength(0); row++)
            {
                for (int column = 0; column < DataContainer.GetLength(1); column++)
                {
                    if (DataContainer[row, column] != destinationArray[row, column])
                    {
                        IsChange = true;
                        return;
                    }
                }
            }
        }

        /// <summary>
        /// 获取或者设置数组元素是否发生变动。true 表示发生变动，false 表示没有变动。
        /// </summary>
        public bool IsChange { get; private set; }

        /// <summary>
        /// 计算空元素的个数，并保存元素的索引位置。
        /// </summary>
        /// <param name="sourceArray">要处理的二维数组。</param>
        /// <returns>返回保存空元素索引位置的列表对象。</returns>
        public IList<Position> CalculateEmptyElements(int[,] sourceArray)
        {
            IList<Position> elements = new List<Position>(DataContainer.GetLength(0) * DataContainer.GetLength(1));
            if (sourceArray == null || sourceArray.Length <= 0)
            {
                return elements;
            }

            for (int row = 0; row < sourceArray.GetLength(0); row++)
            {
                for (int column = 0; column < sourceArray.GetLength(1); column++)
                {
                    if (sourceArray[row, column] == 0)
                    {
                        elements.Add(new Position(row, column));
                    }
                }
            }
            return elements;
        }

        /// <summary>
        /// 随机生成数字元素填充空的数组元素。
        /// </summary>
        public void GenerateRandomNumber()
        {
            var list = CalculateEmptyElements(this.DataContainer);
            if (list.Count > 0)
            {
                Random random = new Random();
                var position = list[random.Next(0, list.Count)];
                DataContainer[position.Row, position.Column] = random.Next(0, 10) == 4 ? 4 : 2;
            }
        }

        #endregion

        #region 实例私有方法（核心算法）

        /// <summary>
        /// 将数组中的为 0 的元素移动到数组最后面。[1,0,0,2]，结果为【1,2,0,0】
        /// </summary>
        /// <param name="array">要处理的数组。</param>
        private void MoveZeroToLast(int[] array)
        {
            if (array == null || array.Length <= 0)
            {
                return;
            }

            int[] myarray = new int[array.Length];

            int index = 0;
            for (int i = 0; i < array.Length; i++)
            {
                if (array[i] != 0)
                {
                    myarray[index++] = array[i];
                }
            }
            //通过引用修改元素才可以，修改引用对外界没有影响。
            myarray.CopyTo(array, 0);
        }

        /// <summary>
        /// 合并数组中相邻相同的数字元素，后一个元素清零。[2,2,0,2]，结果为【4,2,0,0】
        /// </summary>
        /// <param name="array">要处理的数组。</param>
        private void MergeSameNumber(int[] array)
        {
            if (array == null || array.Length <= 0)
            {
                return;
            }

            MoveZeroToLast(array);//2,2,2,0

            for (int i = 0; i < array.Length - 1; i++)
            {
                if (array[i] != 0 && array[i] == array[i + 1])
                {
                    array[i] += array[i + 1];
                    array[i + 1] = 0;
                }
            }

            //4,0,2,0

            MoveZeroToLast(array);//4,2,0,0            
        }

        /// <summary>
        /// 向上移动数据。
        /// </summary>
        private void MoveUp()
        {
            //从上往下取数据。
            if (DataContainer == null || DataContainer.Length <= 0)
            {
                return;
            }

            int[] tempArray = new int[DataContainer.GetLength(0)];

            for (int column = 0; column < DataContainer.GetLength(1); column++)
            {
                for (int row = 0; row < DataContainer.GetLength(0); row++)
                {
                    tempArray[row] = DataContainer[row, column];
                }

                MergeSameNumber(tempArray);

                for (int row = 0; row < DataContainer.GetLength(0); row++)
                {
                    DataContainer[row, column] = tempArray[row];
                }
            }
        }

        /// <summary>
        /// 向下移动数据。
        /// </summary>
        private void MoveDown()
        {
            //从下往上取
            if (DataContainer == null || DataContainer.Length <= 0)
            {
                return;
            }

            int[] tempArray = new int[DataContainer.GetLength(0)];

            for (int column = 0; column < DataContainer.GetLength(1); column++)
            {
                for (int row = DataContainer.GetLength(0) - 1; row >= 0; row--)
                {
                    tempArray[DataContainer.GetLength(0) - 1 - row] = DataContainer[row, column];
                }

                MergeSameNumber(tempArray);

                for (int row = DataContainer.GetLength(0) - 1; row >= 0; row--)
                {
                    DataContainer[row, column] = tempArray[DataContainer.GetLength(0) - 1 - row];
                }
            }
        }

        /// <summary>
        /// 向左移动数据。
        /// </summary>
        private void MoveLeft()
        {
            if (DataContainer == null || DataContainer.Length <= 0)
            {
                return;
            }
            //从左往右

            int[] tempArray = new int[DataContainer.GetLength(1)];

            for (int i = 0; i < DataContainer.GetLength(0); i++)
            {
                for (int j = 0; j < DataContainer.GetLength(1); j++)
                {
                    tempArray[j] = DataContainer[i, j];
                }

                MergeSameNumber(tempArray);

                for (int j = 0; j < DataContainer.GetLength(1); j++)
                {
                    DataContainer[i, j] = tempArray[j];
                }
            }
        }

        /// <summary>
        /// 向右移动数据。
        /// </summary>
        private void MoveRight()
        {
            if (DataContainer == null || DataContainer.Length <= 0)
            {
                return;
            }

            //从右向左取

            //{ 2,2,4,8 },0,4,4,8
            //{ 2,4,4,4 },
            //{ 0,8,4,0 },
            //{ 2,4,0,4 }

            int[] tempArray = new int[DataContainer.GetLength(1)];

            for (int i = 0; i < DataContainer.GetLength(1); i++)
            {
                for (int j = DataContainer.GetLength(1) - 1; j >= 0; j--)
                {
                    //8,4,2,2
                    tempArray[DataContainer.GetLength(1) - 1 - j] = DataContainer[i, j];
                }

                //8,4,4,0
                MergeSameNumber(tempArray);

                for (int j = DataContainer.GetLength(1) - 1; j >= 0; j--)
                {
                    DataContainer[i, j] = tempArray[DataContainer.GetLength(1) - 1 - j];
                }
            }
        }        

        #endregion
    }

 　　　　另外，还有两个枚举类型，代码很简单，直接贴代码了。

    /// <summary>
    /// 元素的坐标位置。
    /// </summary>
    public struct Position
    {
        /// <summary>
        /// 获取或者设置元素的行坐标。
        /// </summary>
        public int Row { get; set; }

        /// <summary>
        /// 获取或者设置元素的列坐标。
        /// </summary>
        public int Column { get; set; }

        /// <summary>
        /// 通过行坐标、列坐标初始化 Position 对象实例。
        /// </summary>
        /// <param name="row">元素的行坐标。</param>
        /// <param name="column">元素的列坐标。</param>
        public Position(int row, int column)
        {
            if (row >= 0 && column >= 0)
            {
                this.Row = row;
                this.Column = column;
            }
            else
            {
                throw new ArgumentNullException("parameter is null.");
            }
        }
    }

    /// <summary>
    /// 移动的方向。
    /// </summary>
    public enum Direction
    {
        /// <summary>
        /// 向上移动
        /// </summary>
        Up,

        /// <summary>
        /// 向下移动
        /// </summary>
        Down,

        /// <summary>
        /// 向左移动
        /// </summary>
        Left,

        /// <summary>
        /// 向右移动
        /// </summary>
        Right
    }

　　　　这就是2048 核心类的实现，代码都有备注，其实，逻辑也不复杂，大家看也是可以看得懂的，只是需要点耐心。

　　　　文章就到此为止了，这是有关2028的核心算法，我发的代码都是经过测试的，大家可以拿过去直接使用，修改和测试。而且代码都很完整，所以我就没有把源码贴出来。