test

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace _64_app
{
    public partial class Form1 : Form
    {
        PictureBox[,] pictureGrid = new PictureBox[4, 4];
        Game coreGame = new Game();

        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            // Создание массива пикчебоксов
            for (int row = 0; row < 4; row++)
            {
                for (int column = 0; column < 4; column++)
                {
                    pictureGrid[row, column] = new PictureBox();
                    pictureGrid[row, column].Location = new Point((12 + column * 70), (12 + row * 70));
                    pictureGrid[row, column].Name = "imgBox" + row.ToString() + column.ToString();
                    pictureGrid[row, column].Size = new System.Drawing.Size(64, 64);
                    pictureGrid[row, column].TabIndex = row + column;

                    Controls.Add(pictureGrid[row, column]);
                }
            }

            // Заполнение пикчебоксов
            coreGame.FillPictureGrid(this);
        }

        public void SetPictureGrid(int row, int column, int countOfNumber)
        {
            switch (countOfNumber)
            {
                case 0:
                    pictureGrid[row, column].Image = _64_app.Properties.Resources.zero;
                    break;
                case 2:
                    pictureGrid[row, column].Image = _64_app.Properties.Resources._2;
                    break;
                case 4:
                    pictureGrid[row, column].Image = _64_app.Properties.Resources._4;
                    break;
                case 8:
                    pictureGrid[row, column].Image = _64_app.Properties.Resources._8;
                    break;
                case 16:
                    pictureGrid[row, column].Image = _64_app.Properties.Resources._16;
                    break;
                case 32:
                    pictureGrid[row, column].Image = _64_app.Properties.Resources._32;
                    break;
                case 64:
                    pictureGrid[row, column].Image = _64_app.Properties.Resources._64;
                    break;
                case 128:
                    pictureGrid[row, column].Image = _64_app.Properties.Resources._128;
                    break;
                case 256:
                    pictureGrid[row, column].Image = _64_app.Properties.Resources._256;
                    break;
                case 512:
                    pictureGrid[row, column].Image = _64_app.Properties.Resources._512;
                    break;
                case 1024:
                    pictureGrid[row, column].Image = _64_app.Properties.Resources._1024;
                    break;
                case 2048:
                    pictureGrid[row, column].Image = _64_app.Properties.Resources._2048;
                    break;
                default: break;
            }
        }

        public void ClearPictureGrid()
        {
            for (int row = 0; row < 4; row++)
            {
                for (int column = 0; column < 4; column++)
                {
                    pictureGrid[row, column].Image = null;
                }
            }
        }

        private void button1_Click(object sender, EventArgs e)
        {
            coreGame.MoveRowOfArrayDown();
            ClearPictureGrid();
            coreGame.FillPictureGrid(this);
        }

        private void button2_Click(object sender, EventArgs e)
        {
            coreGame.MoveRowOfArrayUp();
            ClearPictureGrid();
            coreGame.FillPictureGrid(this);
        }

        private void button3_Click(object sender, EventArgs e)
        {
            coreGame.MoveRowOfArrayRight();
            ClearPictureGrid();
            coreGame.FillPictureGrid(this);
        }

        private void button4_Click(object sender, EventArgs e)
        {
            coreGame.MoveRowOfArrayLeft();
            ClearPictureGrid();
            coreGame.FillPictureGrid(this);
        }
    }

    public class Game
    {
        // Свойства
        int[,] array;
        int sizeOfArray;
        Random randomNumberForArray;

        // Конструктор
        public Game()
        {
            randomNumberForArray = new Random();

            // Создание массива
            sizeOfArray = 4;
            array = new int[sizeOfArray, sizeOfArray];

            for (int row = 0; row < sizeOfArray; row++)
            {
                for (int column = 0; column < sizeOfArray; column++)
                {
                    array[row, column] = 0;
                }
            }


            // Заполнение массива "0" и "2"
            int overflow_array = 1;
            do
            {
                array[randomNumberForArray.Next(4), randomNumberForArray.Next(4)] = 2;
                overflow_array++;
            } while (overflow_array < sizeOfArray);
        }

        // Функция, для загрузки в пикчебоксы картинок
        public void FillPictureGrid(Form1 form1)
        {
            // Генерация пикчебоксов
            for (int row = 0; row < sizeOfArray; row++)
            {
                for (int column = 0; column < sizeOfArray; column++)
                {
                    switch (array[row, column])
                    {
                        case 0:
                            form1.SetPictureGrid(row, column, 0);
                            break;
                        case 2:
                            form1.SetPictureGrid(row, column, 2);
                            break;
                        case 4:
                            form1.SetPictureGrid(row, column, 4);
                            break;
                        case 8:
                            form1.SetPictureGrid(row, column, 8);
                            break;
                        case 16:
                            form1.SetPictureGrid(row, column, 16);
                            break;
                        case 32:
                            form1.SetPictureGrid(row, column, 32);
                            break;
                        case 64:
                            form1.SetPictureGrid(row, column, 64);
                            break;
                        case 128:
                            form1.SetPictureGrid(row, column, 128);
                            break;
                        case 256:
                            form1.SetPictureGrid(row, column, 256);
                            break;
                        case 512:
                            form1.SetPictureGrid(row, column, 512);
                            break;
                        case 1024:
                            form1.SetPictureGrid(row, column, 1024);
                            break;
                        case 2048:
                            form1.SetPictureGrid(row, column, 2048);
                            break;
                        default: break;
                    }
                }
            }
        }

        // Функция для сдвига массива вниз
        public void MoveRowOfArrayDown()
        {
            bool flag = false;
            // Собсно сдвиг
            for (int row = 0; row < sizeOfArray - 1; row++)
            {
                for (int column = 0; column < sizeOfArray; column++)
                {
                    // Сдвиг
                    if (array[row + 1, column] == 0 & (array[row, column] != 0))
                    {
                        array[row + 1, column] = array[row, column];
                        array[row, column] = 0;
                        flag = true;
                    }

                    // Складывание
                    if (array[row + 1, column] == array[row, column] & (array[row, column] != 0))
                    {
                        array[row + 1, column] *= 2;
                        array[row, column] = 0;
                        flag = true;
                    }
                }
            }
            // есть поставить параметр true, то не будет ограничений на генерацию рандомных двоек
            GenerateRandomNumberInArray(flag);
        }

        // Функция для сдвига массива вверх
        public void MoveRowOfArrayUp()
        {
            bool flag = false;
            // Собсно сдвиг
            for (int row = 3; row < sizeOfArray & row > 0; row--)
            {
                for (int column = 0; column < sizeOfArray; column++)
                {
                    // Сдвиг
                    if (array[row - 1, column] == 0 & (array[row, column] != 0))
                    {
                        array[row - 1, column] = array[row, column];
                        array[row, column] = 0;
                        flag = true;
                    }

                    // Складывание
                    if (array[row, column] == array[row - 1, column] & (array[row, column] != 0))
                    {
                        array[row - 1, column] *= 2;
                        array[row, column] = 0;
                        flag = true;
                    }
                }
            }
            // есть поставить параметр true, то не будет ограничений на генерацию рандомных двоек
            GenerateRandomNumberInArray(flag);
        }

        // Функция для сдвига массива вправо
        public void MoveRowOfArrayRight()
        {
            bool flag = false;
            // Собсно сдвиг
            for (int column = 0; column < sizeOfArray - 1; column++)
            {
                for (int row = 0; row < sizeOfArray; row++)
                {
                    // Сдвиг
                    if (array[row, column + 1] == 0 & (array[row, column] != 0))
                    {
                        array[row, column + 1] = array[row, column];
                        array[row, column] = 0;
                        flag = true;
                    }

                    // Складывание
                    if (array[row, column + 1] == array[row, column] & (array[row, column] != 0))
                    {
                        array[row, column + 1] *= 2;
                        array[row, column] = 0;
                        flag = true;
                    }
                }
            }
            // есть поставить параметр true, то не будет ограничений на генерацию рандомных двоек
            GenerateRandomNumberInArray(flag);
        }

        // Функция для сдвига массива вправо
        public void MoveRowOfArrayLeft()
        {
            bool flag = false;
            // Собсно сдвиг
            for (int column = 3; column < sizeOfArray & column > 0; column--)
            {
                for (int row = 0; row < sizeOfArray; row++)
                {
                    // Сдвиг
                    if (array[row, column - 1] == 0 & (array[row, column] != 0))
                    {
                        array[row, column - 1] = array[row, column];
                        array[row, column] = 0;
                        flag = true;
                    }

                    // Складывание
                    if (array[row, column - 1] == array[row, column] & (array[row, column] != 0))
                    {
                        array[row, column - 1] *= 2;
                        array[row, column] = 0;
                        flag = true;
                    }
                }
            }
            // есть поставить параметр true, то не будет ограничений на генерацию рандомных двоек
            GenerateRandomNumberInArray(flag);
        }

        private void GenerateRandomNumberInArray(bool flag)
        {
            // Генерате
            if (flag)
            {
                int randomRow = randomNumberForArray.Next(4);
                int randomColumn = randomNumberForArray.Next(4);
                int isGenerated = 0;

                while (isGenerated == 0 && ArrayIsNotFull() == true)
                {
                    if (array[randomRow, randomColumn] == 0)
                    {
                        array[randomRow, randomColumn] = 2;
                        isGenerated = 1;
                    }
                    else
                    {
                        randomRow = randomNumberForArray.Next(4);
                        randomColumn = randomNumberForArray.Next(4);
                    }
                }
            }
        }

        private bool ArrayIsNotFull()
        {
            bool flag = false;

            for (int row = 0; row < sizeOfArray; row++)
            {
                for (int column = 0; column < sizeOfArray; column++)
                {
                    if (array[row, column] == 0)
                    {
                        flag = true;
                    }
                }
            }
            return flag;
        }
    }
}