2048 console game (C#)

Question

So about a week ago I decided to write a simple console version of 2048 game. Well, as you'll see, it came out not that simple... And took a lot more time and practice than expected (should've done it with 2d array...). But anyway here's a code, and I want to know how can it be optimized and improved? I want to know my mistakes and how it can be done easier. If you have some general tips on coding style, readability or anything else I'd appreciate your help.

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

namespace Game
{
    class Program
    {
        static void Main()
        {
            Console.CursorVisible = false;

            do
            {
                Game game = new Game(4, 8, 2);

                string key;
                do
                {
                    Console.WriteLine("1. New game");
                    Console.WriteLine("2. Quit");
                    key = Console.ReadLine();
                    Console.Clear();
                } while (key != "1" && key != "2");

                switch (key)
                {
                    case "1":
                        game.Run();
                        break;
                    case "2":
                        Environment.Exit(0);
                        break;
                }
                Console.Clear();
            } while (true);
        }
    }

    public enum Direction
    {
        Left,
        Right,
        Up,
        Down
    }

    class Cell : IEquatable<Cell>, ICloneable
    {
        public int Value { get; set; }
        public int X { get; set; }
        public int Y { get; set; }

        public Cell(int value, int x, int y)
        {
            Value = value;
            X = x;
            Y = y;
        }

        // Double the value
        public void Double() => Value *= 2;

        // Display value of cell at certain coordinates
        public void Display()
        {
            Console.SetCursorPosition((Y - 1) * 5 + 1, (X - 1) * 2 + 1);
            ColorChanger.ColorCell(Value.ToString());
        }

        // Erase value of cell at certain coordinates
        public void Erase()
        {
            Console.SetCursorPosition((Y - 1) * 5 + 1, (X - 1) * 2 + 1);
            ColorChanger.ColorCell("    ");
        }

        #region overriding section

        public static bool operator ==(Cell cell1, Cell cell2)
        {
            return cell1.Value == cell2.Value && cell1.X == cell2.X && cell1.Y == cell2.Y;
        }

        public static bool operator !=(Cell cell1, Cell cell2)
        {
            return !(cell1.Value == cell2.Value && cell1.X == cell2.X && cell1.Y == cell2.Y);
        }

        public bool Equals(Cell cell)
        {
            if (cell is null)
                return false;

            return Value == cell.Value && X == cell.X && Y == cell.Y;
        }

        public override bool Equals(object obj)
        {
            Cell cell = obj as Cell;
            if (obj == null)
                return false;
            return Value == cell.Value && X == cell.X && Y == cell.Y;
        }

        public override int GetHashCode()
        {
            return Value.GetHashCode() ^ X.GetHashCode() ^ Y.GetHashCode();
        }

        public object Clone() => MemberwiseClone();

        #endregion
    }

    class Game
    {
        // Length & Width of game field (doesn't have to be equal)
        int length;
        int width;

        int Length
        {
            get => length;
            set
            {
                if (value >= 2)
                    length = value;
                else
                    length = 2;
            }
        }
        int Width
        {
            get => width;
            set
            {
                if (value >= 2)
                    width = value;
                else
                    width = 2;
            }
        }

        // Stats of current game
        int Score { get; set; }
        static int Highscore { get; set; }
        int Moves { get; set; }

        // List of current cells & cells on previous move
        List<Cell> cells;
        List<Cell> prevCells;

        Random rand = new Random();

        // Initializing the game with field parameters and cell amount at the beginning
        public Game(int length, int width, int initialCellAmount)
        {
            cells = new List<Cell>();
            prevCells = new List<Cell>();
            Length = length;
            Width = width;
            Score = 0;
            Moves = 0;

            for (int i = 0; i < initialCellAmount; i++)
                AddCell();
        }

        // Launching the game
        public void Run()
        {
            DisplayField();
            DisplayCells();
            DisplayStats();

            do
            {
                if (Console.KeyAvailable)
                {
                    HandleKey();
                    if (IsMoved())
                        AddCell();
                    DisplayCells();
                    DisplayStats();

                    bool isOver = IsOver();
                    bool isWon = IsWon();

                    if (isOver || isWon)
                    {
                        Console.SetCursorPosition(0, 11);
                        Console.WriteLine(isOver ? "You lost!" : "You won!");
                        Thread.Sleep(2000);
                        break;
                    }
                }
            } while (true);
        }

        // Checking for any cell on field that moved
        bool IsMoved()
        {
            foreach (Cell cell in prevCells)
            {
                if (cells.Contains(cell) == false)
                {
                    Moves++;
                    return true;
                }
            }
            return false;
        }

        // Adding new cell on the field (90% - '2', 10% - '4')
        void AddCell()
        {
            if (IsFieldFull())
                return;
            Cell cell;
            do
            {
                cell = new Cell(rand.NextDouble() < 0.9 ? 2 : 4, rand.Next(1, Length), rand.Next(1, Width));
            } while (cells.Any(c => c.X == cell.X && c.Y == cell.Y));
            cells.Add(cell);
        }

        // Drawing the field
        void DisplayField()
        {
            for (int i = 0; i < Length + 1; i++)
            {
                for (int j = 0; j < Width; j++)
                    Console.Write(" ----");

                Console.WriteLine();

                if (i == Length)
                    break;

                for (int j = 0; j < Width + 1; j++)
                    Console.Write("|    ");

                Console.WriteLine();
            }
        }

        // Displaying existing cells
        void DisplayCells()
        {
            foreach (Cell cell in cells)
                cell.Display();
        }

        // Displaying score, highscore and moves
        void DisplayStats()
        {
            Console.SetCursorPosition(0, 9);
            Console.WriteLine($"Score: {Score}   Highscore: {Highscore}\n" +
                $"Moves: {Moves}");
        }

        // Cells movement algorithm
        void MoveCells(Direction dir)
        {
            // Erasing existing cells on field
            foreach (Cell cell in cells)
                cell.Erase();

            // Choosing type of order based on chosen Direction
            switch (dir)
            {
                case Direction.Left:
                    cells = cells.OrderBy(c => c.X).ThenBy(c => c.Y).ToList();
                    break;
                case Direction.Right:
                    cells = cells.OrderBy(c => c.X).ThenByDescending(c => c.Y).ToList();
                    break;
                case Direction.Up:
                    cells = cells.OrderBy(c => c.Y).ThenBy(c => c.X).ToList();
                    break;
                case Direction.Down:
                    cells = cells.OrderBy(c => c.Y).ThenByDescending(c => c.X).ToList();
                    break;
                default:
                    return;
            }

            // Get X or Y coordinate of certain cell
            int getCoord(Cell cell, bool isOpposite)
            {
                return isOpposite ^ (dir == Direction.Left || dir == Direction.Right) ? cell.Y : cell.X;
            }

            // Set X or Y coordinate of certain cell
            void setCoord(ref Cell cell, int value)
            {
                if (dir == Direction.Left || dir == Direction.Right)
                    cell.Y = value;
                else
                    cell.X = value;
            }

            // Assigning first value for every enumerated column or row
            int border = 0;
            switch (dir)
            {
                case Direction.Left:
                    border = 1;
                    break;
                case Direction.Right:
                    border = Width;
                    break;
                case Direction.Up:
                    border = 1;
                    break;
                case Direction.Down:
                    border = Length;
                    break;
            }

            // Assigning the number, that will be added to certain coordinate
            int n = dir == Direction.Left || dir == Direction.Up ? 1 : -1;

            for (int i = -1; i + 1 < cells.Count(); i++)
            {
                Cell getCurr() => i >= 0 ? cells[i] : null;
                Cell getNext() => cells[i + 1];

                if (i == -1 || getCoord(getCurr(), true) != getCoord(getNext(), true))
                {
                    Cell temp = getNext();
                    setCoord(ref temp, border);
                    continue;
                }

                if (getCurr().Value == getNext().Value)
                {
                    getCurr().Double();
                    CalculateScore(getCurr().Value);
                    cells.Remove(getNext());
                    i--;
                }
                else
                {
                    Cell temp = getNext();
                    setCoord(ref temp, getCoord(getCurr(), false) + n);
                }
            }
        }

        // Setting new score and highscore
        void CalculateScore(int value)
        {
            Score += value;
            if (Score > Highscore)
                Highscore = Score;
        }

        // Choosing movement direction of corresponding key 
        void HandleKey()
        {
            prevCells = cells.Select(c => (Cell)c.Clone()).ToList();
            ConsoleKeyInfo cki = Console.ReadKey(true);
            switch (cki.Key)
            {
                case ConsoleKey.LeftArrow:
                    MoveCells(Direction.Left);
                    break;
                case ConsoleKey.RightArrow:
                    MoveCells(Direction.Right);
                    break;
                case ConsoleKey.UpArrow:
                    MoveCells(Direction.Up);
                    break;
                case ConsoleKey.DownArrow:
                    MoveCells(Direction.Down);
                    break;
            }
        }

        // Checking for field overflow
        bool IsFieldFull()
        {
            return cells.Count() == Length * Width;
        }

        // Checking if there is no cell that can be moved
        bool IsOver()
        {
            if (!IsFieldFull())
                return false;

            cells = cells.OrderBy(c => c.X).ThenBy(c => c.Y).ToList();

            int[,] values = new int[Length, Width];

            foreach (Cell cell in cells)
            {
                values[cell.X - 1, cell.Y - 1] = cell.Value;
            }

            for (int i = 0; i < Length; i++)
            {
                for (int j = 0; j < Width; j++)
                {
                    int center = values[i, j];
                    int right = j + 1 < Width ? values[i, j + 1] : 0;
                    int bottom = i + 1 < Length ? values[i + 1, j] : 0;

                    if (center == right || center == bottom)
                        return false;
                }
            }
            return true;
        }

        // Searching for cell with 2048
        bool IsWon()
        {
            return cells.Any(c => c.Value == 2048);
        }
    }

    // Class for changing color for cells
    static class ColorChanger
    {
        // Get color for corresponding value of cell
        static ConsoleColor GetCellColor(string value)
        {
            switch (value)
            {
                case "2":
                    return ConsoleColor.Blue;
                case "4":
                    return ConsoleColor.Magenta;
                case "8":
                    return ConsoleColor.Cyan;
                case "16":
                    return ConsoleColor.Green;
                case "32":
                    return ConsoleColor.Yellow;
                case "64":
                    return ConsoleColor.DarkBlue;
                case "128":
                    return ConsoleColor.DarkMagenta;
                case "256":
                    return ConsoleColor.DarkCyan;
                case "512":
                    return ConsoleColor.DarkGreen;
                case "1024":
                    return ConsoleColor.DarkYellow;
                default:
                    return ConsoleColor.Red;
            }
        }

        // Color certain cell with optional background color
        public static void ColorCell(string value, ConsoleColor bgColor = ConsoleColor.Black)
        {
            ConsoleColor defaultFg = Console.ForegroundColor;
            ConsoleColor defaultBg = Console.BackgroundColor;

            Console.ForegroundColor = GetCellColor(value);
            Console.BackgroundColor = bgColor;

            Console.WriteLine(value);

            Console.ForegroundColor = defaultFg;
            Console.BackgroundColor = defaultBg;
        }
    }
}

Answer 1

Bravo, well done! The code is very readable and well structured.

If you intend to make several console games, you will notice that some things remain the same. To allow reusability I suggest abstracting certain aspects through interfaces. It also reduces dependencies between components, enhances testability and allows you to easily replace a component by another one.

public interface IMainUserInterface
{
    void StartGame(IGameLoop gameLoop, IGame game);
}

public interface IGameLoop
{
    void Run(IGame game);
}

public interface IGame
{
    void DisplayField();
    void DisplayCells();
    void DisplayStats();
    void MakeMove(ConsoleKeyInfo cki);
    bool IsOver();
    bool IsWon();
}

The IMainUserInterface implementation:

public class MainUserInterface : IMainUserInterface
{
    public void StartGame(IGameLoop gameLoop, IGame game)
    {
        Console.CursorVisible = false;
        do
        {
            string key;
            do
            {
                Console.WriteLine("1. New game");
                Console.WriteLine("2. Quit");
                key = Console.ReadLine();
                Console.Clear();
            } while (key != "1" && key != "2");
            switch (key)
            {
                case "1":
                    gameLoop.Run(game);
                    break;
                case "2":
                    Environment.Exit(0);
                    break;
            }
            Console.Clear();
        } while (true);
    }
}

The IGameLoop implementation:

public class GameLoop : IGameLoop
{
    void Run(IGame game)
    {
        game.DisplayField();
        game.DisplayCells();
        game.DisplayStats();

        do
        {
            if (Console.KeyAvailable)
            {
                game.MakeMove(Console.ReadKey(true));
                game.DisplayCells();
                game.DisplayStats();

                bool isOver = game.IsOver();
                bool isWon = game.IsWon();

                if (isOver || isWon)
                {
                    Console.SetCursorPosition(0, 11);
                    Console.WriteLine(isOver ? "You lost!" : "You won!");
                    Thread.Sleep(2000);
                    break;
                }
            }
        } while (true);
    }
}

I won't show the game implementation here. The Main method becomes

class Program
{
    static void Main()
    {
        IMainUserInterface userInterface = new MainUserInterface();
        IGameLoop gameLoop = new GameLoop();
        IGame game = new Game2048();

        userInterface.StartGame(gameLoop, game);
    }
}