Помоги мне исправить режим эпилепсии, чтобы у каждой отдельной линии был свой рандомный цвет
#ifndef SINGLE_FILE_APP
#define SINGLE_FILE_APP

#include <iostream>
#include <string>
#include <vector>
#include <list>
#include <random>
#include <thread>
#include "Windows.h"  // Подключение Windows.h для работы с консолью

class Console {
public:
    static void SetCursorPosition(int x, int y) {
        // Позиционируем курсор в указанную координату
        COORD coord = { static_cast<SHORT>(x), static_cast<SHORT>(y) };
        SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), coord);
    }

    static void SetTextColor(int color) {
        HANDLE h = GetStdHandle(STD_OUTPUT_HANDLE);
        SetConsoleTextAttribute(h, color);
    }

    static void SetErrorColor() {
        SetTextColor(FOREGROUND_RED | FOREGROUND_INTENSITY); // Красный цвет для ошибок
    }

    static void SetDefaultColor() {
        // Белый цвет для консоли
        SetTextColor(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
    }

    static void GetConsoleSize(int &width, int &height) {
        CONSOLE_SCREEN_BUFFER_INFO csbi;
        GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi);
        width = csbi.srWindow.Right - csbi.srWindow.Left + 1;
        height = csbi.srWindow.Bottom - csbi.srWindow.Top + 1;
    }

    static void WriteInfo() {
        system("cls");  // Для Windows используем cls для очистки экрана
        std::cout << "Информация о программе:\n";
        std::cout << "Программа матрица рисует линии типа(ромб), принимает вот такие параметры:\n";
        std::cout << "1 параметр - Скорость (1 - 30)\n";
        std::cout << "2 параметр - Длина (1 - 30)\n";
        std::cout << "3 параметр - Количество линий в секунду (1 - 30)\n";
        std::cout << "4 параметр - режим эпилепсии (y/n)\n\n";
    }
};

class Data {
    static int SPEED, LENGTH, COUNT_PER_SECOND, WIDTH_CONSOLE, HEIGHT_CONSOLE;
    static bool EPILEPSY;

public:
    static void OverwriteConsoleSize() {
        Console::GetConsoleSize(WIDTH_CONSOLE, HEIGHT_CONSOLE);
    }

    static void SetSpeed(const int speed) { SPEED = speed; }
    static int GetSpeed() { return SPEED; }

    static void SetLength(const int length) { LENGTH = length; }
    static int GetLenght() { return LENGTH; }

    static void SetCountPerSecond(const int countPerSecond) { COUNT_PER_SECOND = countPerSecond; }
    static int GetCountPerSecond() { return COUNT_PER_SECOND; }

    static void SetEpilepsy(const bool epilepsy) { EPILEPSY = epilepsy; }
    static bool GetEpilepsy() { return EPILEPSY; }

    static int GetWidthConsole() { return WIDTH_CONSOLE; }
    static int GetHeightConsole() { return HEIGHT_CONSOLE; }

    static std::string GetInput() {
        std::string input;
        getline(std::cin, input);
        return input;
    }

    static char GetRandomChar() {
        const char characters[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()_+[]{}|;':\",.<>?~";
        return characters[rand() % (sizeof(characters) - 1)];
    }

    static int GetRandomColor() {
        return 1 + rand() % 15;  // Возвращаем случайный цвет от 1 до 15
    }

    static int GetRandomInt(int numberBegin, int numberEnd) {
        std::random_device sd;
        std::mt19937 gen(sd());
        std::uniform_int_distribution<> distr(numberBegin, numberEnd);
        return distr(gen);
    }

    static int GetRandomHeight() {
        int width, height;
        Console::GetConsoleSize(width, height);
        std::random_device sd;
        std::mt19937 gen(sd());
        std::uniform_int_distribution<> distr(2, height - 1);
        return distr(gen);
    }
};

int Data::SPEED = 0;
int Data::LENGTH = 0;
int Data::COUNT_PER_SECOND = 0;
int Data::WIDTH_CONSOLE = 1;
int Data::HEIGHT_CONSOLE = 1;
bool Data::EPILEPSY = false;

class Symbol {
    int coordinateSymbolX = 0, coordinateSymbolY = 0;
    char symbol = ' ';
    int color = 7; // Стандартный цвет (белый)

public:
    Symbol(int x, int y, int color) : coordinateSymbolX(x), coordinateSymbolY(y), symbol(Data::GetRandomChar()), color(color) {}

    void WriteSelf() const {
        Console::SetTextColor(color);
        Console::SetCursorPosition(coordinateSymbolX, coordinateSymbolY);
        std::cout << symbol;
    }

    void EraseSelf() const {
        Console::SetCursorPosition(coordinateSymbolX, coordinateSymbolY);
        std::cout << " ";
    }
};

class Line {
    std::list<Symbol> symbols;
    int CoordinateLineX, CoordinateLineY;
    int lineColor;

    void CreateSymbol(int CoordinateSymbolX, int CoordinateSymbolY) {
        symbols.emplace_back(CoordinateSymbolX, CoordinateSymbolY, lineColor);
        symbols.back().WriteSelf();
        Console::SetCursorPosition(1, 1);
    }

    void DeleteSymbol() {
        symbols.front().EraseSelf();
        symbols.pop_front();
    }

public:
    Line() : CoordinateLineX(1), CoordinateLineY(Data::GetRandomHeight()) {
        // Если включена эпилепсия, создаем случайный цвет для линии
        lineColor = Data::GetEpilepsy() ? Data::GetRandomColor() : FOREGROUND_GREEN | FOREGROUND_INTENSITY;
    }

    void UpdateLine() {
        if (CoordinateLineX <= Data::GetLenght()) {
            CreateSymbol(CoordinateLineX, CoordinateLineY);
            CoordinateLineX++;
        } else if (CoordinateLineX <= Data::GetWidthConsole()) {
            CreateSymbol(CoordinateLineX, CoordinateLineY);
            DeleteSymbol();
            CoordinateLineX++;
        } else {
            DeleteSymbol();
        }
    }
};

class Manager {
    std::vector<Line> Lines;

    void CreateLine() {
        Lines.emplace_back();
    }

public:
    Manager() { system("cls"); Data::OverwriteConsoleSize(); }

    void DoMatrix() {
        while (true) {
            Data::OverwriteConsoleSize();
            CreateLine();
            for (int i = 0; i < Data::GetLenght() + Data::GetWidthConsole(); i++) {
                Lines.back().UpdateLine();
                std::this_thread::sleep_for(std::chrono::milliseconds(1000 / Data::GetSpeed()));
            }
            Lines.erase(Lines.begin());
        }
    }
};

int main(int argc, char *argv[]) {
    Console::WriteInfo();

    if (argc == 5) {
        Data::SetSpeed(std::stoi(argv[1]));
        Data::SetLength(std::stoi(argv[2]));
        Data::SetCountPerSecond(std::stoi(argv[3]));
        Data::SetEpilepsy(std::string(argv[4]) == "y");
    } else if (argc == 1) {
        std::cout << "Скорость (1-30): ";
        Data::SetSpeed(std::stoi(Data::GetInput()));
        Console::WriteInfo();
        std::cout << "Длина (1-30): ";
        Data::SetLength(std::stoi(Data::GetInput()));
        Console::WriteInfo();
        std::cout << "Линии/с (1-30): ";
        Data::SetCountPerSecond(std::stoi(Data::GetInput()));
        Console::WriteInfo();
        std::cout << "Эпилепсия (y/n): ";
        Data::SetEpilepsy(Data::GetInput() == "y");
    }

    Manager manager;
    manager.DoMatrix();
    return 0;
}

#endif // SINGLE_FILE_APP