Program.cs

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

namespace Tetris
{
    class Program
    {
        // Игровое поле
        static GameBoard gameBoard;

        // Переменная для хранения нажатых игроком клавиш
        static ConsoleKeyInfo input;

        // Переменные для "таймера" (скорость игры)
        static int maxTime = 20;
        static int timer = 0;


        static void Main()
        {
            while (true) {
                // Отключаем курсор в консоли
                Console.CursorVisible = false;

                // Пишем заголовок
                Console.Title = "Tetris";

                // Запускаем чтение ввода в отдельном потоке
                Thread inputThread = new Thread(() =>
                {
                    // Бесконечно считываем нажатые клавиши, не печатая соответствующие символы
                    while (true)
                    {
                        input = Console.ReadKey(true);
                    }
                });
                inputThread.Start();

                // Инициализируем игровое поле
                gameBoard = new GameBoard();

                // Бесконечный цикл игры
                while (true)
                {
                    // Двигаем фигуру вниз по таймеру
                    if (timer >= maxTime)
                    {
                        if (!gameBoard.CheckCollision(0, 1, -1)) gameBoard.Move(0, 1);
                        else gameBoard.FigureCollision();
                        timer = 0;
                    }
                    timer++;

                    // Обрабатываем ввод пользователя
                    InputHandler();
                    input = new ConsoleKeyInfo();

                    // Отображаем игровое поле
                    gameBoard.Print();

                    // Выжидаем задержку
                    Thread.Sleep(maxTime);

                    // Если нельзя создать фигуру, то обратаываем конец игры
                    if (gameBoard.fail)
                    {
                        GameOver();
                        break;
                    }
                }
            }
        }

        public static void GameOver()
        {

            Console.Clear(); // Очищаем экран
            Console.WriteLine("\n\n\n");
            Console.WriteLine("   *** GAME OVER ***\n");

            // Выводим количество набранных очков
            Console.WriteLine("Ваш счет: " + gameBoard.score + "\n");

            // Предлагаем начать новую игру
            Console.WriteLine("Новая игра начнётся через 5 секунд ...");

            // Ждём 5 секунд
            Thread.Sleep(5000);
            Console.Clear(); // Очищаем экран
        }

        static void InputHandler()
        {
            switch (input.Key)
            {
                // Сдвиг влево (клавиша "A" или стрелка влево)
                case ConsoleKey.A:
                case ConsoleKey.LeftArrow:
                    if (!gameBoard.CheckCollision(-1, 0, -1)) gameBoard.Move(-1,0);
                    break;

                // Сдвиг вправо (клавиша "D" или стрелка влево)
                case ConsoleKey.D:
                case ConsoleKey.RightArrow:
                    if (!gameBoard.CheckCollision(1, 0, -1)) gameBoard.Move(1, 0);
                    break;

                // Вращение фигуры (клавиша "W")
                case ConsoleKey.W:
                case ConsoleKey.UpArrow:
                    if (!gameBoard.CheckCollision(0, 0, (gameBoard.curFig.rot + 1) % 4)) gameBoard.curFig.Rotate();
                    break;

                // Закрытие игр
                case ConsoleKey.Escape:
                    Environment.Exit(1);
                    break;

                // Сдвиг вниз (клавиша "S" или стрелка вниз)
                case ConsoleKey.S:
                case ConsoleKey.DownArrow:
                    timer = maxTime;
                    break;

                default:
                    break;
            }
        }
    }

    class Figure
    {
        // Разновидности фигур и их возможные повороты
        #region Assets
        readonly public static string types = "OILJSZT";

        readonly public static int[,,,] rotations =
        {
            {
            {{0,0},{1,0},{0,1},{1,1}},
            {{0,0},{1,0},{0,1},{1,1}},
            {{0,0},{1,0},{0,1},{1,1}},
            {{0,0},{1,0},{0,1},{1,1}}
            },

            {
            {{2,0},{2,1},{2,2},{2,3}},
            {{0,2},{1,2},{2,2},{3,2}},
            {{1,0},{1,1},{1,2},{1,3}},
            {{0,1},{1,1},{2,1},{3,1}},
            },
            {
            {{1,0},{1,1},{1,2},{2,2}},
            {{1,2},{1,1},{2,1},{3,1}},
            {{1,1},{2,1},{2,2},{2,3}},
            {{2,1},{2,2},{1,2},{0,2}}
            },

            {
            {{2,0},{2,1},{2,2},{1,2}},
            {{1,1},{1,2},{2,2},{3,2}},
            {{2,1},{1,1},{1,2},{1,3}},
            {{0,1},{1,1},{2,1},{2,2}}
            },

            {
            {{2,1},{1,1},{1,2},{0,2}},
            {{1,0},{1,1},{2,1},{2,2}},
            {{2,1},{1,1},{1,2},{0,2}},
            {{1,0},{1,1},{2,1},{2,2}}
            },
            {
            {{0,1},{1,1},{1,2},{2,2}},
            {{1,0},{1,1},{0,1},{0,2}},
            {{0,1},{1,1},{1,2},{2,2}},
            {{1,0},{1,1},{0,1},{0,2}}
            },

            {
            {{0,1},{1,1},{1,0},{2,1}},
            {{1,0},{1,1},{2,1},{1,2}},
            {{0,1},{1,1},{1,2},{2,1}},
            {{1,0},{1,1},{0,1},{1,2}}
            }
            };
        #endregion

        public int x = 4;
        public int y = 0;
        public int type;
        public int rot = 0;

        // Конструктор случайной фигуры
        public Figure()
        {
            Random random = new Random();
            this.type = random.Next(7);
        }

        // Метод получения типа фигуры
        public char GetChar()
        {
            return types[type];
        }

        // Метод вращения фигуры
        public void Rotate()
        {
            rot = (rot + 1) % 4;
        }
    }

    class GameBoard
    {
        // Игровое поле
        const int mapW = 10;
        const int mapH = 20;
        char[,] board = new char[mapH, mapW];

        // Счётчик количества очков
        public int score = 0;

        // Текущая фигура
        public Figure curFig;

        // Переменная проигрыша (нельзя создать новую фигуру)
        public bool fail = false;

        // Конструктор игрового поля
        public GameBoard()
        {
            // Инициализируем игровое поле
            for (int y = 0; y < mapH; y++)
                for (int x = 0; x < mapW; x++)
                    board[y, x] = '-';

            // Инициализируем текущую фигуру
            curFig = new Figure();

            // Помещаем фигуру на поле
            PutNextFig();
        }

        // Проверка на коллизию, если сдвинуть или повернуть фигуру
        // dx, dy - сдвиги по осям X и Y
        // rot - какой из 4 поворотов проверяем (-1 для текущего поворота)
        public bool CheckCollision(int dx, int dy, int rot)
        {
            if (rot == -1) rot = curFig.rot;
            for (int i = 0; i < Figure.rotations.GetLength(2); i++)
            {
                int curFigH = Figure.rotations[curFig.type, rot, i, 1];
                int curFigW = Figure.rotations[curFig.type, rot, i, 0];
                // Проверяем выход за пределы поля
                if (curFigH + curFig.y + dy >= mapH
                    || curFigW + curFig.x + dx < 0
                    || curFigW + curFig.x + dx >= mapW)
                {
                    return true;
                }

                // Проверяем на коллизию с другими фигурами
                if (board[curFigH + curFig.y + dy, curFigW + curFig.x + dx] != '-')
                {
                    return true;
                }
            }

            // Если ни с чем не столкнулись, то возвращаем false
            return false;
        }

        // Метод движения фигуры
        public void Move(int dx, int dy)
        {
            curFig.x += dx;
            curFig.y += dy;
        }


        // Обработка коллизии
        public void FigureCollision()
        {
            // Фиксируем фигуру на поле
            for (int i = 0; i < Figure.rotations.GetLength(2); i++)
            {
                int curFigH = Figure.rotations[curFig.type, curFig.rot, i, 1];
                int curFigW = Figure.rotations[curFig.type, curFig.rot, i, 0];
                board[curFigH + curFig.y, curFigW + curFig.x] = curFig.GetChar();
            }

            // Проверяем заполненные линии
            while (true)
            {
                int line = Line();

                if (line != -1)
                {
                    ClearLine(line);
                    continue;
                }
                break;
            }

            // Создаём новую фигуру
            PutNextFig();
        }

        // Метод нахождения заполненных линий (-1, если не нашли)
        int Line()
        {
            for (int y = 0; y < mapH; y++)
            {
                bool b = true;
                for (int x = 0; x < mapW; x++)
                {
                    if (board[y, x] == '-')
                    {
                        b = false;
                    }
                }
                if (b) return y;
            }
            return -1;
        }

        // Метод очистки заданной линии со сдвигом всех фигур выше
        void ClearLine(int line)
        {
            score += 10;
            for (int y = line - 1; y > 0; y--)
            {
                for (int x = 0; x < mapW; x++)
                { 
                    board[y + 1, x] = board[y, x];
                }
            }

            for (int x = 0; x < mapW; x++) board[0, x] = '-';
        }

        // Добавление следующей фигуры, если это возможно, иначе - конец игры
        public void PutNextFig()
        {
            curFig = new Figure();
            if (CheckCollision(0, 0, -1)) fail = true;
        }

        // Метод вывода игрового поля и количества набранных очков
        public void Print()
        {
            // Создаём вспомогательный массив
            char[,] view = new char[mapH, mapW];

            // Копируем игровое поле с уже поставленными фигурами во вспомогательный массив
            for (int y = 0; y < mapH; y++)
                for (int x = 0; x < mapW; x++)
                    view[y, x] = board[y, x];

            // Добавляем во вспомогательный падающую в данный момент фигуру
            for (int i = 0; i < Figure.rotations.GetLength(2); i++)
            {
                int curFigH = Figure.rotations[curFig.type, curFig.rot, i, 1];
                int curFigW = Figure.rotations[curFig.type, curFig.rot, i, 0];
                view[curFigH + curFig.y, curFigW + curFig.x] = curFig.GetChar();
            }


            // Печатаем полученный массив
            for (int y = 0; y < mapH; y++)
            {
                for (int x = 0; x < mapW; x++)
                {
                    char i = ' ';
                    i = view[y, x];

                    // Выбираем цвет для каждой фигуры
                    switch (i)
                    {
                        case 'O':
                            Console.ForegroundColor = ConsoleColor.Red;
                            Console.Write(i);
                            break;
                        case 'I':
                            Console.ForegroundColor = ConsoleColor.Blue;
                            Console.Write(i);
                            break;

                        case 'T':
                            Console.ForegroundColor = ConsoleColor.Cyan;
                            Console.Write(i);
                            break;

                        case 'S':
                            Console.ForegroundColor = ConsoleColor.DarkMagenta;
                            Console.Write(i);
                            break;
                        case 'Z':
                            Console.ForegroundColor = ConsoleColor.DarkCyan;
                            Console.Write(i);
                            break;
                        case 'L':
                            Console.ForegroundColor = ConsoleColor.Green;
                            Console.Write(i);
                            break;

                        case 'J':
                            Console.ForegroundColor = ConsoleColor.DarkCyan;
                            Console.Write(i);
                            break;
                        default:
                            Console.ForegroundColor = ConsoleColor.DarkGray;
                            Console.Write(i);
                            break;
                    }
                }

                // Выводим сверху количество набранных очков
                if (y == 0)
                {
                    Console.ForegroundColor = ConsoleColor.DarkGray;
                    Console.Write("   " + score);
                }
                Console.WriteLine();
            }

            // Сбрасываем положение курсора
            Console.SetCursorPosition(0, Console.CursorTop - mapH);
        }
    }
}