2048 project realization

1 2048

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

namespace _2048
{
    
    public class MatrixOperation
    {
    
        //  Calculate the smoothness and connectivity of the matrix 
        public int[] SmoothAndNum(int[,] matrix)
        {
    
            int[,] matrixIndex = new int[5, 5];
            int num = 0;
            int smooth = 0;
            for (int i = 0; i < 5; i++)
            {
    
                for (int j = 0; j < 5; j++)
                {
    
                    int[] vs1 = MatrixMove(matrix, i, j, 1, ref matrixIndex);
                    int[] vs2 = MatrixMove(matrix, i, j, 2, ref matrixIndex);
                    int[] vs3 = MatrixMove(matrix, i, j, 3, ref matrixIndex);
                    smooth = smooth - vs1[0] - vs2[0] - vs3[0];
                    num = num + vs1[1] + vs2[1] + vs3[1];
                }
            }

            return new int[2] {
     smooth, num };
        }
        //  List all possible filling combinations 
        //public List<List<int>> AllComb(int max,int min,int num)
        // {
    
        // List<int> comb = new List<int>();
        // return;
        // }
        public static int[] MatrixMove(int[,] matrix, int x, int y, int z, ref int[,] matrixIndex)
        {
    
            int num = 0;
            int smooth = 0;
            switch (z)
            {
    
                case 1:
                    if (x + 1 <= matrix.GetUpperBound(1))
                    {
    
                        smooth = (int)Math.Abs(Math.Log(matrix[x, y], 2) - Math.Log(matrix[x + 1, y], 2));
                        if (smooth == 0)
                        {
    
                            if (matrixIndex[x, y] == 0)
                            {
    
                                matrixIndex[x, y] = 1;
                                num = num + 1;
                            }
                            if (matrixIndex[x + 1, y] == 0)
                            {
    
                                matrixIndex[x + 1, y] = 1;
                                num = num + 1;
                            }
                        }
                    }
                    else
                    {
    
                        smooth = 0;
                    }
                    break;
                case 2:
                    if ((x + 1 <= matrix.GetUpperBound(1)) && (y + 1 <= matrix.GetUpperBound(0)))
                    {
    
                        smooth = (int)Math.Abs(Math.Log(matrix[x, y], 2) - Math.Log(matrix[x + 1, y + 1], 2));
                        if (smooth == 0)
                        {
    
                            if (matrixIndex[x, y] == 0)
                            {
    
                                matrixIndex[x, y] = 1;
                                num = num + 1;
                            }
                            if (matrixIndex[x + 1, y + 1] == 0)
                            {
    
                                matrixIndex[x + 1, y + 1] = 1;
                                num = num + 1;
                            }
                        }
                    }
                    else
                    {
    
                        smooth = 0;
                    }
                    break;
                case 3:
                    if (y + 1 <= matrix.GetUpperBound(0))
                    {
    
                        smooth = (int)Math.Abs(Math.Log(matrix[x, y], 2) - Math.Log(matrix[x, y + 1], 2));
                        if (smooth == 0)
                        {
    
                            if (matrixIndex[x, y] == 0)
                            {
    
                                matrixIndex[x, y] = 1;
                                num = num + 1;
                            }
                            if (matrixIndex[x, y + 1] == 0)
                            {
    
                                matrixIndex[x, y + 1] = 1;
                                num = num + 1;
                            }
                        }
                    }
                    else
                    {
    
                        smooth = 0;
                    }
                    break;
            }

            return new int[2] {
     smooth, num };
        }
        public int[,] FillMatrix(int[,] matrix)
        {
    
            List<Tuple<int, int>> fillSteps = new List<Tuple<int, int>>();
            for (int i = 0; i < 5; i++)
            {
    
                for (int j = 0; j < 5; j++)
                {
    
                    if (matrix[i, j] == 0)
                    {
    
                        Tuple<int, int> pos = new Tuple<int, int>(i, j);
                        fillSteps.Add(pos);
                    }
                }

            }
            return matrix;
        }
        // total： Number to fill 
        public static int [] AllComb(int total,int [] nums,int start, ref List<int []> all_list ,int [] all)
        {
    
            if (start < total) {
    
                for (int i = 0; i < nums.Length; i++)
                {
    
                    all[start] = nums[i];
                    AllComb(total, nums, start+1,ref all_list,all);
                    int[] b = new int[total];
                    Array.Copy(all, b, total);
                    all_list.Add(b);  
                }
                return all;
            }
            else
            {
    
                return  all;
            }
        }
        static void Main(string[] args)
        {
    
            int[] nums = {
     2, 4, 8 };
            int num = 3;
            List<int []> all = new List<int []>();
            int[] s = new int[num];
            AllComb(3, nums, 0,ref all, s);
            for(int i=0;i<all.Count;i++)
            {
    
                for(int j=0;j<num;j++)
                {
    
                    Console.WriteLine(all[i][j]);
                }
                
            }

           



        }
    }
}