Basic Console Game Engine

using System;
using System.Collections.Generic;

public class ConsolePainter
{
    public ConsoleColor[] DrawColors;
    public ConsoleColor BorderColor = ConsoleColor.White;
    public ConsoleColor TextColor = ConsoleColor.White;

    public List<string[]> TextDataToDraw = new List<string[]>();

    public char[] DrawChars;

    private byte LastColorId = 255;

    private void DrawTextData(int startX, int startY)
    {
        Console.ForegroundColor = TextColor;

        for (int i = 0; i < TextDataToDraw.Count; i++)
        {
            string textToDraw = $"[{TextDataToDraw[i][0]}] is [{TextDataToDraw[i][1]}]";


            Console.SetCursorPosition(startX, startY + i);
            Console.Write(new string(' ', textToDraw.Length + 5));

            Console.SetCursorPosition(startX, startY + i);
            Console.Write(textToDraw);
        }

        Console.ForegroundColor = DrawColors[LastColorId];
    }

    private void DrawBordersForMatrix(byte[,] matrix)
    {
        int height = matrix.GetLength(0);
        int width = matrix.GetLength(1);

        Console.ForegroundColor = BorderColor;

        Console.SetCursorPosition(0, 0);
        Console.Write('┌');

        Console.SetCursorPosition(0, height + 1);
        Console.Write('└');

        Console.SetCursorPosition(width + 1, 0);
        Console.Write('┐');

        Console.SetCursorPosition(width + 1, height + 1);
        Console.Write('┘');

        for (int i = 1; i < height + 1; i++)
        {
            Console.SetCursorPosition(0, i);
            Console.Write('│');

            Console.SetCursorPosition(width + 1, i);
            Console.Write('│');
        }

        for (int i = 1; i < width + 1; i++)
        {
            Console.SetCursorPosition(i, 0);
            Console.Write('─');

            Console.SetCursorPosition(i, height + 1);
            Console.Write('─');
        }

        Console.ForegroundColor = DrawColors[LastColorId];
    }

    private void DrawByteMatrixToConsoleCore(byte[,] matrix, int startX, int startY)
    {
        int height = matrix.GetLength(0);
        int width = matrix.GetLength(1);

        for (int y = 0; y < height; y++)
        {
            for (int x = 0; x < width; x++)
            {
                byte matrixElemId = matrix[y, x];

                if (matrixElemId != LastColorId)
                {
                    LastColorId = matrixElemId;
                    Console.ForegroundColor = DrawColors[matrixElemId];
                }
                Console.SetCursorPosition(x + startX, y + startY);

                Console.Write(DrawChars[matrixElemId]);
            }
        }

        if (TextDataToDraw.Count > 0)
        {
            DrawTextData(0, height + startY + 1);
        }
    }

    public void DrawByteMatrixToConsole(byte[,] matrix)
    {
        DrawByteMatrixToConsoleCore(matrix, 0, 0);
    }

    public void DrawByteMatrixToConsole(byte[,] matrix, bool drawBorders)
    {
        if (drawBorders)
        {
            DrawByteMatrixToConsoleCore(matrix, 1, 1);
            DrawBordersForMatrix(matrix);
        }
        else
        {
            DrawByteMatrixToConsole(matrix);
        }
    }

    public ConsolePainter(ConsoleColor[] drawColors, char[] drawChars)
    {
        SetConsoleDefault();

        DrawColors = drawColors;
        DrawChars = drawChars;
    }
    public ConsolePainter()
    {
        SetConsoleDefault();

        DrawColors = GetDefaultDrawColors();
        DrawChars = GetDefaultDrawChars();
    }

    private static ConsoleColor[] GetDefaultDrawColors()
    {
        ConsoleColor[] result = new ConsoleColor[256]; //from 0 to 255

        FillArrayWithValue(result, ConsoleColor.Red);

        result[0] = ConsoleColor.White;
        result[1] = ConsoleColor.DarkBlue;
        result[2] = ConsoleColor.DarkGreen;
        result[3] = ConsoleColor.DarkCyan;
        result[4] = ConsoleColor.DarkMagenta;
        result[5] = ConsoleColor.DarkRed;
        result[6] = ConsoleColor.DarkYellow;
        result[7] = ConsoleColor.Blue;
        result[8] = ConsoleColor.Green;
        result[9] = ConsoleColor.Cyan;
        result[10] = ConsoleColor.Magenta;
        result[11] = ConsoleColor.Red;
        result[12] = ConsoleColor.Yellow;
        result[13] = ConsoleColor.White;
        result[14] = ConsoleColor.Gray;
        result[15] = ConsoleColor.DarkGray;
        result[16] = ConsoleColor.Black;
        result[17] = ConsoleColor.DarkBlue;
        result[18] = ConsoleColor.DarkGreen;
        result[19] = ConsoleColor.DarkCyan;
        result[20] = ConsoleColor.DarkMagenta;
        result[21] = ConsoleColor.DarkRed;
        result[22] = ConsoleColor.DarkYellow;
        result[23] = ConsoleColor.Blue;
        result[24] = ConsoleColor.Green;
        result[25] = ConsoleColor.Cyan;

        return result;
    }
    private static char[] GetDefaultDrawChars()
    {
        char[] result = new char[256]; //from 0 to 255

        FillArrayWithValue(result, '█');

        result[0] = '?';
        result[1] = '█';
        result[2] = '▓';
        result[3] = '▒';
        result[4] = '░';
        result[5] = 'X';
        result[6] = '@';
        result[7] = '#';
        result[8] = '$';
        result[9] = '%';
        result[10] = '&';
        result[11] = '*';
        result[12] = '+';
        result[13] = '-';
        result[14] = '=';
        result[15] = '.';
        result[16] = '/';
        result[17] = '0';
        result[18] = '1';
        result[19] = '2';
        result[20] = '3';
        result[21] = '4';
        result[22] = '5';
        result[23] = '6';
        result[24] = '7';
        result[25] = '8';

        return result;
    }

    private static void FillArrayWithValue<T>(T[] arr, T fillerValue) where T : struct
    {
        for (int i = 0; i < arr.Length; i++)
        {
            arr[i] = fillerValue;
        }
    }
    private static void SetConsoleDefault()
    {
        Console.Clear();
        Console.CursorVisible = false;
    }

    public void EndDrawing()
    {
        Console.CursorVisible = true;
    }
}

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

public class UserInputManager
{
    private bool RunMonitorAndCleanerThread { get; set; } = false; // Прапорець для керування роботою потоків
    private Thread MonitorThread { get; set; } // Потік для моніторингу введення
    private Thread CleanerThread { get; set; } // Потік для очищення даних

    public List<ConsoleKeyAndTime> PressedKeys = new List<ConsoleKeyAndTime>(); // Список натиснутих клавіш

    // Метод, який перевіряє, чи натиснута певна клавіша за символьним значенням
    public bool IsKeyPressed(char key)
    {
        return IsKeyPressed(key);
    }

    // Метод, який перевіряє, чи натиснута певна клавіша за рядковим значенням
    public bool IsKeyPressed(string key)
    {
        bool result = false;

        // Перебір усіх натиснутих клавіш для перевірки співпадіння з введеним значенням
        for (int i = 0; i < PressedKeys.Count; i++)
        {
            if (PressedKeys[i].ConsoleKey.ToString() == key)
            {
                PressedKeys.RemoveAt(i); // Видалення клавіші зі списку
                result = true;
                break;
            }
        }

        return result;
    }

    // Метод для початку моніторингу натиснутих клавіш
    public void StartMonitoring()
    {
        RunMonitorAndCleanerThread = true;
        MonitorThread.Start(); // Запуск потоку моніторингу
        CleanerThread.Start(); // Запуск потоку очищення
    }

    // Метод для зупинки моніторингу натиснутих клавіш
    public void StopMonitoring()
    {
        RunMonitorAndCleanerThread = false;
    }

    // Функція потоку моніторингу
    public void MonitorThreadFunction()
    {
        while (RunMonitorAndCleanerThread)
        {
            ConsoleKey input = Console.ReadKey(true).Key; // Отримання натиснутої клавіші

            long timeNow = DateTime.Now.Ticks; // Отримання поточного часу

            bool alreadyInBuffer = false;
            int inBufferId = 0;

            // Перевірка наявності клавіші в буфері натиснутих клавіш
            for (int i = 0; i < PressedKeys.Count; i++)
            {
                if (!alreadyInBuffer && input == PressedKeys[i].ConsoleKey)
                {
                    alreadyInBuffer = true;
                    inBufferId = i;
                }
            }

            // Оновлення часу натискання клавіші або додавання нової клавіші в буфер
            if (alreadyInBuffer)
            {
                PressedKeys[inBufferId].PressTime = timeNow;
            }
            else
            {
                PressedKeys.Add(new ConsoleKeyAndTime(input, timeNow));
            }
        }
        Console.WriteLine("Кінець функції потоку моніторингу");
    }

    // Функція потоку очищення
    public void CleanerThreadFunction()
    {
        while (RunMonitorAndCleanerThread)
        {
            Thread.Sleep(10); // Пауза для ефективного використання ресурсів

            long timeNow = DateTime.Now.Ticks; // Отримання поточного часу

            // Перевірка часу натискання клавіш для їхнього видалення зі списку
            for (int i = 0; i < PressedKeys.Count; i++)
            {
                if (PressedKeys[i].PressTime + 5000000 < timeNow)
                {
                    PressedKeys.RemoveAt(i); // Видалення клавіші зі списку
                }
            }
        }
        Console.WriteLine("Кінець функції потоку очищення");
    }

    // Конструктор класу
    public UserInputManager()
    {
        MonitorThread = new Thread(() => MonitorThreadFunction()); // Ініціалізація потоку моніторингу
        CleanerThread = new Thread(() => CleanerThreadFunction()); // Ініціалізація потоку очищення
    }
}

// Клас, що репрезентує натиснуту клавішу і час натискання
public class ConsoleKeyAndTime
{
    public ConsoleKey ConsoleKey { get; set; } // Клавіша консолі
    public long PressTime { get; set; } // Час натискання клавіші

    // Конструктор класу
    public ConsoleKeyAndTime(ConsoleKey consoleKey, long pressTime)
    {
        ConsoleKey = consoleKey;
        PressTime = pressTime;
    }
}

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

namespace ConsoleGameExample
{
    class Program
    {
        static void Main(string[] args)
        {
            // Початок моніторингу введення користувача
            P.UserInputManager.StartMonitoring();

            // Ініціалізація символів для малювання та встановлення кольорів
            P.Painter.DrawChars[0] = ' ';
            P.Painter.DrawChars[1] = '%';
            P.Painter.DrawChars[2] = '+';
            P.Painter.DrawColors[1] = ConsoleColor.Green;
            P.Painter.DrawColors[2] = ConsoleColor.Red;

            // Встановлення кольору рамки
            P.Painter.BorderColor = ConsoleColor.Yellow;

            // Додавання текстових даних для малювання
            P.Painter.TextDataToDraw.Add(new string[] { "X", "test_val" });
            P.Painter.TextDataToDraw.Add(new string[] { "Y", "test_val" });
            P.Painter.TextDataToDraw.Add(new string[] { "Score", "0" });

            // Встановлення початкових координат персонажа
            P.GamePlayer.X = P.GameBoard.Width / 4;
            P.GamePlayer.Y = P.GameBoard.Height / 2;

            // Головний цикл гри
            MainLoop();

            // Зупинка моніторингу введення користувача та завершення малювання
            P.UserInputManager.StopMonitoring();
            P.Painter.EndDrawing();
        }

        public static void MainLoop()
        {
            while (P.GameIsRunning)
            {
                Thread.Sleep(50);
                P.GameBoard.ClearMatrix();

                // Обробка балів
                GamePointsInLoop();

                // Оновлення положення персонажа
                GamePlayerInLoop();

                P.Painter.TextDataToDraw[2][1] = P.Score.ToString();

                // Малювання матриці у консоль
                P.Painter.DrawByteMatrixToConsole(P.GameBoard.Matrix, true);
            }
        }

        private static void GamePointsInLoop()
        {
            // Додавання випадкових геймпоінтів, поки не досягнуто потрібну кількість
            if (P.GamePoints.Count < P.TargetGamePointsCount)
            {
                P.GamePoints.Add(GamePoint.GetNewRandomPoint(P.GameBoard));
            }

            // Перевірка колізій геймпоінтів з гравцем та їх видалення у разі зіткнення
            // А також відображення геймпоінтів на ігровій дошці
            for (int i = 0; i < P.GamePoints.Count; i++)
            {
                if (P.GamePoints[i].IsCollidingWith(P.GamePlayer))
                {
                    P.GamePoints.RemoveAt(i);
                    P.Score++;
                }
                else
                {
                    P.GameBoard.Matrix[P.GamePoints[i].Y, P.GamePoints[i].X] = 2;
                }
            }
        }


        private static void GamePlayerInLoop()
        {
            // Керування персонажем та оновлення його положення
            P.GamePlayer.Control(P.UserInputManager, P.GameBoard);
            P.GamePlayer.OneTick();

            // Оновлення текстових даних про положення персонажа та його місцезнаходження на ігровій дошці
            P.Painter.TextDataToDraw[0][1] = Convert.ToString(P.GamePlayer.X);
            P.Painter.TextDataToDraw[1][1] = Convert.ToString(P.GamePlayer.Y);
            P.GameBoard.Matrix[P.GamePlayer.Y, P.GamePlayer.X] = 1;
        }
    }
}