HFA 4.0 stable

#include <iostream>
#include <cstdlib>
#include <clocale>
#include <string>
#include <ctime>
#include <conio.h>
#include <windows.h>

using namespace std;

class Profile {
public:
    int Rarities[5];
    string Name, Class;
    //конструктор
    Profile() {
        setRarities(0, 0, 0, 0, 0);
        setName("Бен Броуд");
        setClass("Не выбран");
    }
    void setName(string NameInput) {
        Name = NameInput;
    }
    void setClass(string ClassInput) {
        Class = ClassInput;
    }
    void setRarities(int BasicsInput, int CommonsInput, int RaresInput, int EpicsInput, int LegendariesInput) {
        /*Basics = BasicsInput;
        Commons = CommonsInput;
        Rares = RaresInput;
        Epics = EpicsInput;
        Legendaries = LegendariesInput;*/
        Rarities[0] = BasicsInput;
        Rarities[1] = CommonsInput;
        Rarities[2] = RaresInput;
        Rarities[3] = EpicsInput;
        Rarities[4] = LegendariesInput;

    }
    void getInfo() {
        cout << "Имя:" << Name << endl;
        cout << "Класс:" << Class << endl;
    }
};
class Card {
public:
    int Rarity, Page, Position;
    //конструктор
    Card() {
        setRarity(-1);
        setCard(0, 0);
    }
    void setRarity(int RarityInput) {
        Rarity = RarityInput;
    }
    void setCard(int PageInput, int PositionInput) {
        Page = PageInput;
        Position = PositionInput;
    }
    void getCard() {
        cout << "Страница " << Page + 1 << ", " << Position + 1 << "-ая карта" << endl;
    }
};

void Localize();
void ClearScreen();

void StartScreen();
void Menu();
void InitializeDraftClasses();
string GenerateDraftClasses(int, string[]);
string ChooseClass(string[]);
void SetRarities();
int RarityInput(int);
void BuildDeck();
void GenerateCard(int, int, int);
void ShowDeckbyCard();
void CardRepeatError(int);
int LastPageError(int);
void ShowEntireDeck();

Profile Player;
Card Deck[30];
Card SortedDeck[30];

void Localize() {
    setlocale(LC_CTYPE, "rus");
    SetConsoleCP(1251);
    SetConsoleOutputCP(1251);
}

void ClearScreen() {
    COORD topLeft = { 0, 0 };
    HANDLE console = GetStdHandle(STD_OUTPUT_HANDLE);
    CONSOLE_SCREEN_BUFFER_INFO screen;
    DWORD written;

    GetConsoleScreenBufferInfo(console, &screen);
    FillConsoleOutputCharacterA(
        console, ' ', screen.dwSize.X * screen.dwSize.Y, topLeft, &written
    );
    FillConsoleOutputAttribute(
        console, FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE,
        screen.dwSize.X * screen.dwSize.Y, topLeft, &written
    );
    SetConsoleCursorPosition(console, topLeft);
}

void StartScreen() {
    //Предупреждене о Lucida Console
    cout << "\t\t  Дружественная арена Hearthstone" << endl;
    cout << "\n\n\n\t\t\tНажмите любую кнопку" << endl;
    cout << "\n\n\n\n\n\t\tEsli tekst otobrazahetsya nekorrektno, \n\tviberite shrift ''Lucida Console'' v nastroykah konsoli" << endl;
    _getch();
}

void Menu() {
    char Input = '0';
    string Name;
    do {
        ClearScreen();
        Player.getInfo();
        cout << "\t\t  Дружественная арена Hearthstone" << endl;
        cout << "\n\t\t\t1. Начать новую арену" << endl;
        cout << "\n\t\t     2. Правила дружеской арены" << endl;
        cout << "\n\t\t\t      3. Выход" << endl;
        Input = _getch();
    } while (Input != '1' && Input != '2' && Input != '3');
    switch (Input) {
    case '1':
        ClearScreen();
        Player.getInfo();
        cout << "Введите имя:" << endl;
        cin >> Name;
        Player.setName(Name);
        ClearScreen();
        Player.getInfo();
        break;
    case '2':
        ClearScreen();
        Player.getInfo();
        cout << "\t\t\t  Смысл дружеской арены" << endl;
        cout << "\n     Зачастую игроки Hearthstone не могут комфортно играть дуэли " << endl;
        cout << "     друг между другом, сталкиваясь с проблемой разницы в наборе" << endl;
        cout << " карт и колод. Также в игре существует режим ''Арена'', уравнивающий" << endl;
        cout << "    опытных игроков и новичков, однако он недоступен для дружеской" << endl;
        cout << "      дуэли. Эта небольшая утилита призвана решить эту проблему." << endl;
        cout << "\n\t\t\t       Как играть" << endl;
        cout << "\n    Игрок вводит своё имя, выбирает один из предложенных ему трёх" << endl;
        cout << "     классов. Выбрав класс, игрок должен открыть свою коллекцию" << endl;
        cout << "       в Hearthstone и создать пустую колоду выбранного класса." << endl;
        cout << "    Далее игрок, выбирая при помощи внутриигровых фильтров поиска " << endl;
        cout << "    карты определённой редкости, вводит номер последней страницы " << endl;
        cout << "    коллекции при включенном фильтре той или иной редкости. После" << endl;
        cout << "    этого утилита по очереди показывает игроку редкость, страницу " << endl;
        cout << "       и положение на странице очередной карты, а игрок находит " << endl;
        cout << "    соответствующую карту в коллекции и добавляет её в свою колоду." << endl;
        cout << "      В случае невозможности добавить предложенную карту утилита" << endl;
        cout << "     предусматривает перевыбор случайной карты. После добавления" << endl;
        cout << " тридцатой карты игроку для удобства показывается вся колода целиком." << endl;

        cout << "\n\t       Нажмите любую кнопку, чтобы вернуться в меню" << endl;
        _getch();
        Menu();
        break;
    case '3':
        exit(0);
        break;
    }
}

void InitializeDraftClasses() {
    string DraftClasses[] = { "NULL", "NULL", "NULL" };
    for (int i = 0; i < 3; i++) { //Генерируем три класса для драфта
        DraftClasses[i] = GenerateDraftClasses(i, DraftClasses);
    }

    Player.setClass(ChooseClass(DraftClasses)); //Запоминаем класс игрока
    ClearScreen();
    Player.getInfo();
}

string GenerateDraftClasses(int i, string DraftClasses[]) {
    string AllClasses[] = { "Воин", "Шаман", "Разбойник", "Паладин", "Охотник", "Друид", "Чернокнижник", "Маг", "Жрец" };
    string GeneratedClass = AllClasses[0 + rand() % 9];
    switch (i) {
    case 0: //Первый класс - выбираем случайный класс
        return (GeneratedClass);
        break;
    case 1: //Второй класс - сравниваем с первым на несовпадение, иначе перезапускаем
        while (GeneratedClass == DraftClasses[i - 1]) {
            return GenerateDraftClasses(i, DraftClasses);
        }
        return (GeneratedClass);
        break;
    case 2: //Третий класс - сравниваем с первым и вторым на несовпадение, иначе перезапускаем
        while (GeneratedClass == DraftClasses[i - 1] || GeneratedClass == DraftClasses[i - 2]) {
            return GenerateDraftClasses(i, DraftClasses);
        }
        return (GeneratedClass);
        break;
    }
}

string ChooseClass(string DraftClasses[]) {
    char ClassInput = 0;
    do { //выводим три сгенерированных класса
        ClearScreen();
        Player.getInfo();
        cout << "Выберите номер класса:" << endl;
        for (int i = 0; i < 3; i++) { //Выводим на экран три класса
            cout << i + 1 << "." << DraftClasses[i] << endl;
        }
        ClassInput = _getch();
    } while (ClassInput != '1' && ClassInput != '2' && ClassInput != '3');
    switch (ClassInput) {
    case '1':
        return DraftClasses[((int)ClassInput - 48) - 1];
        break;
    case '2':
        return DraftClasses[((int)ClassInput - 48) - 1];
        break;
    case '3':
        return DraftClasses[((int)ClassInput - 48) - 1];
        break;
    }
}

void SetRarities() {
    int BasicsInput = 0, CommonsInput = 0, RaresInput = 0, EpicsInput = 0, LegendariesInput = 0;
    for (int i = 0; i < 5; i++) {
        switch (i) {
        case 0:
            BasicsInput = RarityInput(i);
            break;
        case 1:
            CommonsInput = RarityInput(i);
            break;
        case 2:
            RaresInput = RarityInput(i);
            break;
        case 3:
            EpicsInput = RarityInput(i);
            break;
        case 4:
            LegendariesInput = RarityInput(i);
            break;
        }
    }
    Player.setRarities(BasicsInput, CommonsInput, RaresInput, EpicsInput, LegendariesInput);
    ClearScreen();
    Player.getInfo();
}

int RarityInput(int i) {
    int Input;
    string Rarities[] = { "базовых", "обычных", "редких", "эпических", "легендарных" };
    do {
        ClearScreen();
        Player.getInfo();
        cout << "Введите кол-во страниц " << Rarities[i] << " карт" << endl;
        cin.clear();
        cin.ignore(10000, '\n');
        cin >> Input;
    } while (cin.fail());
    return (Input);
}

void BuildDeck() {
    int CardNumber, Chance;
    for (CardNumber = 0; CardNumber < 30; CardNumber++) {
        cout << "Генерируем колоду..." << ((CardNumber + 4) * 3) << "/100" << endl;
        Chance = 0 + rand() % 100;
        if (Chance < 15) { //Базовые
            Deck[CardNumber].setRarity(0);
            GenerateCard(Player.Rarities[0], CardNumber, 8);
        }
        else if (Chance >= 15 && Chance < 45) { //Обычные
            Deck[CardNumber].setRarity(1);
            GenerateCard(Player.Rarities[1], CardNumber, 8);
        }
        else if (Chance >= 45 && Chance < 85) { //Редкие
            Deck[CardNumber].setRarity(2);
            GenerateCard(Player.Rarities[2], CardNumber, 8);
        }
        else if (Chance >= 85 && Chance < 95) { //Эпические
            Deck[CardNumber].setRarity(3);
            GenerateCard(Player.Rarities[3], CardNumber, 8);
        }
        else if (Chance >= 95 && Chance < 100) { //Легендарные
            Deck[CardNumber].setRarity(4);
            GenerateCard(Player.Rarities[4], CardNumber, 8);
        }
        ClearScreen();
        Player.getInfo();
    }
}

void GenerateCard(int Pages, int CardNumber, int CardsOnPage) {
    int Page = 0 + rand() % Pages;
    int Position = 0 + rand() % CardsOnPage;
    Deck[CardNumber].setCard(Page, Position);
}

void ShowDeckbyCard() {
    string AllRarities[] = { "Базовая", "Обычная", "Редкая", "Эпическая", "Легендарная" };
    int RarityFilter = 4; //Фильтрует карты по убыванию редкости
    int SortedCardNumber = 0; //Счетчик карт отфильтрованной колоды
    while (RarityFilter >= 0) {
        for (int CardNumber = 0; CardNumber < 30; CardNumber++) {
            if (Deck[CardNumber].Rarity == RarityFilter) {
                cout << SortedCardNumber + 1 << "/30" << endl;
                cout << AllRarities[Deck[CardNumber].Rarity] << endl;
                Deck[CardNumber].getCard();
                CardRepeatError(CardNumber);
                ClearScreen();
                Player.getInfo();
                Deck[CardNumber].getCard();
                //cout << "Если ошибка 1, если нет любая кнопка" << endl;
                /*if (_getch() == '1') {
                    CardError(CardNumber);
                    cout << SortedCardNumber + 1 << "/30" << endl;
                    cout << AllRarities[Deck[CardNumber].Rarity] << endl;
                    Deck[CardNumber].getCard();
                };*/
                SortedDeck[SortedCardNumber].setCard(Deck[CardNumber].Page, Deck[CardNumber].Position);
                SortedDeck[SortedCardNumber].setRarity(Deck[CardNumber].Rarity);
                SortedCardNumber++;

            }
            ClearScreen();
            Player.getInfo();
        }
        RarityFilter--; //Все карты отфильтрованы, переходим к следующей редкости
    }
}

void CardRepeatError(int CardNumber) {
    int OldPage = Deck[CardNumber].Page;
    int OldPosition = Deck[CardNumber].Position;
    int RepeatFlag = 1;
    int RepeatCounter = 0;
    int CardsOnPage = LastPageError(CardNumber);
    if (CardsOnPage == 8) {
        if (Deck[CardNumber].Rarity == 4) {
            do {
                GenerateCard(Player.Rarities[Deck[CardNumber].Rarity], CardNumber, 8);
                for (int i = 0; i < CardNumber; i++) {
                    if ((Deck[i].Page == Deck[CardNumber].Page) && (Deck[i].Position == Deck[CardNumber].Position)) {
                        RepeatFlag = 0;
                        break;
                    }
                }
            } while (RepeatFlag != 1);
        }
        else {
            do {
                GenerateCard(Player.Rarities[Deck[CardNumber].Rarity], CardNumber, 8);
                for (int i = 0; i < CardNumber; i++) {
                    if ((Deck[i].Page == Deck[CardNumber].Page) && (Deck[i].Position == Deck[CardNumber].Position) && (RepeatCounter == 0)) {
                        RepeatCounter++;
                    }
                    else if ((Deck[i].Page == Deck[CardNumber].Page) && (Deck[i].Position == Deck[CardNumber].Position) && (RepeatCounter != 0)) {
                        RepeatFlag = 0;
                        break;
                    }
                }
            } while (RepeatFlag != 1);
        }
    }
    else {
        if (Deck[CardNumber].Rarity == 4) {
            do {
                GenerateCard(Player.Rarities[Deck[CardNumber].Rarity], CardNumber, CardsOnPage);
                for (int i = 0; i < CardNumber; i++) {
                    if ((Deck[i].Page == Deck[CardNumber].Page) && (Deck[i].Position == Deck[CardNumber].Position)) {
                        RepeatFlag = 0;
                        break;
                    }
                }
            } while (RepeatFlag != 1);
        }
        else {
            do {
                GenerateCard(Player.Rarities[Deck[CardNumber].Rarity], CardNumber, CardsOnPage);
                for (int i = 0; i < CardNumber; i++) {
                    if ((Deck[i].Page == Deck[CardNumber].Page) && (Deck[i].Position == Deck[CardNumber].Position) && (RepeatCounter == 0)) {
                        RepeatCounter++;
                    }
                    else if ((Deck[i].Page == Deck[CardNumber].Page) && (Deck[i].Position == Deck[CardNumber].Position) && (RepeatCounter != 0)) {
                        RepeatFlag = 0;
                        break;
                    }
                }
            } while (RepeatFlag != 1);
        }
    }
}

int LastPageError(int CardNumber) {
    int CardsOnPage = 8;
    cout << "Если на странице не 8 карт, нажмите 1" << endl;
        if (_getch() == '1') {
            do {
                ClearScreen();
                Player.getInfo();
                cout << "Введите кол-во карт на странице" << endl;
                cin.clear();
                cin.ignore(10000, '\n');
                cin >> CardsOnPage;
            } while ((cin.fail()) || CardsOnPage > 7 || CardsOnPage < 1);
        }
        return CardsOnPage;
}

void ShowEntireDeck() {
    string AllRarities[] = { "Базовая", "Обычная", "Редкая", "Эпическая", "Легендарная" };
    ClearScreen();
    Player.getInfo();
    cout << "Номер \t Редкость \t Страница    Карта" << endl;
    cout << "------------------------------------------" << endl;
    for (int CardNumber = 0; CardNumber < 30; CardNumber++) {
        if (SortedDeck[CardNumber].Rarity == 2) {
            cout << CardNumber + 1 << "\t " << AllRarities[SortedDeck[CardNumber].Rarity] << "\t\t     " << SortedDeck[CardNumber].Page + 1 << "\t\t" << SortedDeck[CardNumber].Position + 1 << endl;
            cout << "------------------------------------------" << endl;
        }
        else {
            cout << CardNumber + 1 << "\t " << AllRarities[SortedDeck[CardNumber].Rarity] << "\t     " << SortedDeck[CardNumber].Page + 1 << "\t\t" << SortedDeck[CardNumber].Position + 1 << endl;
            cout << "------------------------------------------" << endl;
        }
    }
    cout << "Приятной игры!" << endl;
}

int main() {
    Localize();
    srand(time(NULL));
    StartScreen();
    Menu();
    InitializeDraftClasses();
    SetRarities();
    BuildDeck();
    ShowDeckbyCard();
    ShowEntireDeck();
    /*---------------*/
    cout << "Конец выполнения" << endl;
    _getch();
    return 0;
}