游戲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]+"\t");
                }
                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的核心算法，我發的代碼都是經過測試的，大家可以拿過去直接使用，修改和測試。而且代碼都很完整，所以我就沒有把源碼貼出來。