Таблица рекордов

///----------------------------------------------------------------------------|
/// C++17
///----------------------------------------------------------------------------:
#include <map>
#include <tuple>
#include <iomanip>
#include <iostream>
#include <string_view>
 
///----------------------------------------------------------------------------|
/// Таблица рекордов.
///----------------------------------------------------------------------------:
struct Tabrecords
{
    Tabrecords& operator<<(std::tuple<std::string, int> _r)
    {          m.insert  ({std::get<1>(_r),
                           std::get<0>(_r)});
        return *this;
    }
 
    std::ostream& operator>>(std::ostream& o)
    {   int cnt = 1;
        for(const auto&[number, name] : m)
        {   o << "  " << cnt   << "."
              << std::setw(18) << name   << " - "
              << std::setw( 7) << number << '\n';
            ++cnt;
        }   o << '\n';
        return o;
    }
 
private:
    std::multimap<int, std::string, std::greater<int>> m;
}tabrecords;
 
using rec = std::tuple<std::string, int>;
 
///----------------------------------------------------------------------------|
/// Тест.
///----------------------------------------------------------------------------:
int main()
{
    setlocale(0, "");
 
    tabrecords << rec{"Вася Черный"    , 123 }
               << rec{"Джон"           , 555 }
               << rec{"Петя Шок"       , 4000}
               << rec{"Карабас Барабас", 777 };
 
    tabrecords >> std::cout;
}

for(const auto&[number, name] : m)

///----------------------------------------------------------------------------|
/// C++17
///----------------------------------------------------------------------------:
#include <map>
#include <tuple>
#include <iomanip>
#include <iostream>
#include <string_view>
 
using rec = std::tuple<std::string, int>;
 
template<typename T>
T get()
{   T a = 0;
    while(true)
    {   try
        {   std::cout << "Пожалуйста, введите очки: ";
            std::string s;
            std::getline(std::cin, s);
            size_t            pos ;
            a = std::stoi(s, &pos);
            if(pos == s.size()) break;
            std::cout << "Упс, ты отличаешь цифры от буков?\n";
        }
        catch(...) {}
    }
    return a;
}
 
template<> std::string get<std::string>()
{   std::cout << "Пожалуйста, введите имя : ";
    std::string s;
    std::getline(std::cin, s);
    return s;
}
 
auto input()
{    return rec{get<std::string>(), get<int>()};
}
 
///----------------------------------------------------------------------------|
/// Таблица рекордов.
///----------------------------------------------------------------------------:
struct Tabrecords
{   Tabrecords& operator<<(std::tuple<std::string, int> _r)
    {   m.insert  ({std::get<1>(_r),
                    std::get<0>(_r)});
        return *this;
    }
 
    std::ostream& operator>>(std::ostream& o)
    {   int cnt = 1;
        for(const auto&[number, name] : m)
        {   o << "  " << cnt   << "."
              << std::setw(18) << name   << " - "
              << std::setw( 7) << number << '\n';
            ++cnt;
        }
        o << '\n';
        return o;
    }
 
private:
    std::multimap<int, std::string, std::greater<int>> m;
} tabrecords;
 
///----------------------------------------------------------------------------|
/// Тест.
///----------------------------------------------------------------------------:
int main()
{   setlocale(0, "");
 
    tabrecords << rec{"Вася Черный", 123 }
               << rec{"Джон", 555 }
               << rec{"Петя Шок", 4000}
               << rec{"Карабас Барабас", 777 };
 
    tabrecords >> std::cout;
 
    while(true)
    {   tabrecords << input();
        std::system("cls");
        tabrecords >> std::cout;
    }
}

///----------------------------------------------------------------------------|
/// C++17
///----------------------------------------------------------------------------:
#include <map>
#include <tuple>
#include <iomanip>
#include <fstream>
#include <iostream>
#include <string_view>
 
using rec = std::tuple<std::string, int>;
 
template<typename T>
T get()
{   T a = 0;
    while(true)
    {   try
        {   std::cout << "Пожалуйста, введите очки: ";
            std::string s;
            std::getline(std::cin, s);
            size_t            pos ;
            a = std::stoi(s, &pos);
            if(pos == s.size()) break;
            std::cout << "Упс, ты отличаешь цифры от буков?\n";
        }
        catch(...) {}
    }
    return a;
}
 
template<> std::string get<std::string>()
{   std::cout << "Пожалуйста, введите имя : ";
    std::string s;
    std::getline(std::cin, s);
    if(s == "exit") throw("exit");
    return s;
}
 
auto input()
{    return rec{get<std::string>(), get<int>()};
}
 
///----------------------------------------------------------------------------|
/// Таблица рекордов.
///----------------------------------------------------------------------------:
struct Tabrecords
{   Tabrecords& operator<<(std::tuple<std::string, int> _r)
    {   for(auto& c : std::get<0>(_r)) if(c == ' ') c = '_';
 
        m.insert  ({std::get<1>(_r),
                    std::get<0>(_r)});
        return *this;
    }
 
    std::ostream& operator>>(std::ostream& o)
    {   int cnt = 1;
        for(const auto&[number, name] : m)
        {   o << "  " << cnt   << ". "
              << std::setw(18) << name   << " - "
              << std::setw( 7) << number << '\n';
            ++cnt;
        }
        o << '\n';
        return o;
    }
 
private:
    std::multimap<int, std::string, std::greater<int>> m;
} tabrecords;
 
std::ifstream& operator>>(std::ifstream& o, Tabrecords& r)
{
    for(std::string s; o >> s;)
    {
        std::string a, b, c;
        o >> a;
        o >> b;
        o >> c;
 
        int n = std::stoi(c);
        r << rec{a, n };
    }
    return o;
}
 
///----------------------------------------------------------------------------|
/// Тест.
///----------------------------------------------------------------------------:
int main()
{   setlocale(0, "");
 
    std::ifstream f("rec.txt"); f >> tabrecords;
 
    if(!f.is_open())
    {   tabrecords << rec{"Вася Черный"    , 123 }
                   << rec{"Джон"           , 555 }
                   << rec{"Петя Шок"       , 4000}
                   << rec{"Карабас Барабас", 777 };
    }
 
    tabrecords >> std::cout;
 
    try
    {
        while(true)
        {   tabrecords << input();
            std::system("cls");
            tabrecords >> std::cout;
        }
    }
    catch(const char* s)
    {
        if(std::string(s) == "exit")
        {
            std::ofstream f("rec.txt");
            tabrecords >> f;
        }
    }
}

#include <iostream>
#include <cstdlib>
#include <windows.h>
#include <conio.h>
#include <ctime>
#include <fstream>
#include <iomanip>
#include <map>
#include <tuple>
#include <string_view>
 
using namespace std;
 
char c[30][21]; //variable for storing screen particles (pixels)
int n[30][21];  //variable for checking
int highscore;
string name;
int number;
int contr, tuk = 0, t = 0, bt = 0, birdx = 0, birdy = 0; //variaous variables for certain operations
bool err; //boolean for error detection
 
void game();  //various functions
void screen();
void pipes();
void bird();
bool gameover();
void checkscore();
void help();
void menu();
void endgame();
void credits();
 
///////////////////////////////////////////////////////////////////////---BEGIN:
///--------------------------------|
/// Подключение русского модуля.   |
///--------------------------------:
///----------------------------------------------------------------------------|
/// C++17
///----------------------------------------------------------------------------:
#include <map>
#include <tuple>
#include <iomanip>
#include <fstream>
#include <iostream>
#include <string_view>
 
using rec = std::tuple<std::string, int>;
 
template<typename T>
T get()
{   T a = 0;
    while(true)
    {   try
        {   std::cout << "Пожалуйста, введите очки: ";
            std::string s;
            std::getline(std::cin, s);
            size_t            pos ;
            a = std::stoi(s, &pos);
            if(pos == s.size()) break;
            std::cout << "Упс, ты отличаешь цифры от буков?\n";
        }
        catch(...) {}
    }
    return a;
}
 
template<> std::string get<std::string>()
{   std::cout << "Пожалуйста, введите имя : ";
    std::string s;
    std::getline(std::cin, s);
    if(s == "exit") throw("exit");
    return s;
}
 
auto input()
{    return rec{get<std::string>(), get<int>()};
}
 
///----------------------------------------------------------------------------|
/// Таблица рекордов.
///----------------------------------------------------------------------------:
struct Tabrecords
{   Tabrecords& operator<<(std::tuple<std::string, int> _r)
    {   for(auto& c : std::get<0>(_r)) if(c == ' ') c = '_';
 
        m.insert  ({std::get<1>(_r),
                    std::get<0>(_r)});
        return *this;
    }
 
    void show()
    {   std::system("cls");
        *this >> std::cout;
 
        std::cout << "\n\nПРОДОЛЖИТЬ ЖМАКАЙ ENTER ...\n";
 
        std::string s; std::getline(std::cin, s);
    }
 
    std::ostream& operator>>(std::ostream& o)
    {   int cnt = 1;
        for(const auto&[number, name] : m)
        {   o << "  " << cnt   << ". "
              << std::setw(18) << name   << " - "
              << std::setw( 7) << number << '\n';
            ++cnt;
        }
        o << '\n';
        return o;
    }
 
private:
    std::multimap<int, std::string, std::greater<int>> m;
} tabrecords;
 
std::ifstream& operator>>(std::ifstream& o, Tabrecords& r)
{
    for(std::string s; o >> s;)
    {
        std::string a, b, c;
        o >> a;
        o >> b;
        o >> c;
 
        try
        {   int n = std::stoi(c);
            r << rec{a, n };
        }
        catch(...){}
    }
    return o;
}
 
///----------------------------------------------------------------------------|
/// Тест.
///----------------------------------------------------------------------------:
void test()
{   setlocale(0, "");
 
    std::ifstream f("rec.txt"); f >> tabrecords;
 
    if(!f.is_open())
    {   tabrecords << rec{"Вася Черный"    , 123 }
                   << rec{"Джон"           , 555 }
                   << rec{"Петя Шок"       , 4000}
                   << rec{"Карабас Барабас", 777 };
    }
 
    tabrecords >> std::cout;
 
    try
    {
        while(true)
        {   tabrecords << input();
            std::system("cls");
            tabrecords >> std::cout;
        }
    }
    catch(const char* s)
    {
        if(std::string(s) == "exit")
        {
            std::ofstream f("rec.txt");
            tabrecords >> f;
        }
    }
}
 
///---------------------|
/// Личная инфа игрока. |
///---------------------:
struct Player
{   std::string name    ;
    int         score{0};
}player;
/////////////////////////////////////////////////////////////////////////---END.
 
 
int main()
{   SetConsoleCP(1251);
    SetConsoleOutputCP(1251); //підключення української мови
    srand(time(0));  //seeding random number gen, we will need it later;
 
    ///---------------------------------------------|
    /// 1.                                          |
    ///---------------------------------------------:
    {
        ///-----------------------------------------|
        /// Загрузка с диска.                       |
        ///-----------------------------------------:
        std::ifstream f("rec.txt"); f >> tabrecords;
 
        ///-----------------------------------------|
        /// Щоп не было одиноко.                    |
        ///-----------------------------------------:
        if(!f.is_open())
        {   tabrecords << rec{"Вася Черный"    , 123 }
                       << rec{"Джон"           , 555 }
                       << rec{"Петя Шок"       , 4000}
                       << rec{"Карабас Барабас", 777 };
        }
 
        tabrecords.show();
 
        std::cout << "Введите ваше имя: "; std::getline(std::cin, player.name);
    }
 
    err = false;  //error will be false, because file opened successfully
 
    int a = 0;
    char sl; //selection variable
    while (1) //loop for repeating actions after each start
    {   if (a == 0) goto play;
        if (a > 0)               //if you play not the first time, it will ask you if you want to play
        {   player.score = 0;
            cout << "Do you want to play again? [y/n] ";
            cin >> sl;
            if (sl == 'n') goto quit;
            else goto play;
        }
play:
        menu(); //calling menu function
        cin >> sl;
        switch (sl) //menu selections
        {   case '1':
            {   game(); //if you choose play, it calls function game
                break;
            }
            case '2': //other selections-other functions
            {   help();
                goto play;
                break;
            }
            case '3':
            {   credits();
                goto play;
                break;
            }
            case '4':
            {   goto quit; //exits game
                break;
            }
            default:
            {   goto play;
                break;
            }
        }
        a++; //variable for checking how many times you've played
    }
quit:
    {   cout << "I quit."; //stops game, app closes.
        ///----------------------------------|
        /// Записываем результат.            |
        ///----------------------------------:
        {
            tabrecords << rec{player.name, highscore };
            std::ofstream f("rec.txt"); tabrecords >> f;
            tabrecords.show();
        }
    }
 
    return 0;
}
 
void game()  //function for playing game
{   int x, y;
    char s;
    for (y = 0; y < 21; y++)  //setting screen
    {   for (x = 0; x < 30; x++)
        {   if (y < 20)
            {   c[x][y] = ' ';
                n[x][y] = 0;
            }
            if (y == 20)
            {   c[x][y] = '-';
                n[x][y] = 2;
            }
        }
    }
    c[10][10] = '*';  //in these coordinates will be our bird, marked *
    screen();      //calls func for showin screen
    while (1)       //loop starts, actual gameplay begins
    {   s = '~';  //default control variable
        Sleep(0.2 * 1000);  //this sets how fast everyhing moves
        t++;              //this is a variable for storing 'time',or how many times a loop passed
        if (_kbhit()) //if key is pressed, certain operations are done for bird to move up.
        {   s = _getch();        //gets what key is pressed
            if (s != '~') tuk = 1; //if it is not default, then 'tuk' will be equal to 1, meaning that bird will fly up
        }
        for (x = 0; x < 30; x++) //just setting ground
        {   c[x][20] = '-';
            n[x][20] = 2;
        }
        bird();                       //cals bird move function
        checkscore();                 //checks score
 
        if (gameover() == true) goto gameEnd;   //checks if bird hits pipes, if yes, game ends
        pipes();                             //spawns and moves pipes
        if (player.score > highscore) highscore = player.score;  //i think this is clear
        screen();                            //finally, calls screen function to show enerything.
 
        if (tuk > 0) tuk++;           //if key is pressed, bird will fly up 2 times.
        if (tuk == 3) tuk = 0;          //after that, bird falls
    }
gameEnd:   //ends game
    {
 
        if (player.score > highscore) highscore = player.score;
        screen();    //shows ending screen, and returns to int main
        endgame();
        return;
    }
}
 
void screen()    //func for showing screen
{   int x, y;
    system("cls");    //clears console
    for (y = 0; y < 21; y++) //shows pixels on their coordinates, and your score
    {   for (x = 0; x < 30; x++)
        {   if (x < 29) cout << c[x][y];
            if (x == 29) cout << c[x][y] << endl;
        }
    }
    cout << "" << endl;
    cout << "Your Score: " << player.score;
}
 
void pipes()  //pipe movement and spawn func
{   int x, y, r;
    if (t == 10)   //if time is 10, or loop has passed 10 times, it spawns a new pipe
    {   r = (rand() % 11) + 5;  //generates random number, which will be the pipe's hole center
        for (y = 0; y < 20; y++)  // only y coordinate is needed
        {   c[29][y] = '|';  //sets pipe
            n[29][y] = 2;    //n will be 2, for checking if bird has hit it,
        }
        c[29][r - 1] = ' ';  //sets hole
        c[29][r] = ' ';
        c[29][r + 1] = ' ';
        n[29][r - 1] = 0;
        n[29][r] = 0;
        n[29][r + 1] = 0;
        t = 0;
        goto mv; //moves pipes
    }
    else goto mv;
mv:                 //pipe movement
    {   for (y = 0; y < 20; y++)  //loops for generating coordinates
        {   for (x = 0; x < 30; x++)
            {   if (c[x][y] == '|')  //all the pipes will be moved left by 1;
                {   if (x > 0)
                    {   c[x - 1][y] = '|';
                        n[x - 1][y] = 2;
                        c[x][y] = ' ';
                        n[x][y] = 0;
                    }
                    if (x == 0)  //if screen ends (x=0) pipe will dissapear, to prevent errors
                    {   c[x][y] = ' ';
                        n[x][y] = 0;
                    }
                }
            }
        }
    }
}
 
void bird()   //bird movement function!
{   int x, y;
    if (tuk > 0) //if key is pressed, bird moves up
    {   bt = 0;
        for (y = 0; y < 20; y++)   //loops for finding bird coordinates
        {   for (x = 0; x < 30; x++)
            {   if (c[x][y] == '*')
                {   if (y > 0)
                    {   c[x][y - 1] = '*';  //bird moves up by 1;
                        c[x][y] = ' ';
                        birdx = x;        //sets bird x coordinate
                        birdy = y - 1;      //sets bird y coord
                        return;         //retuns to game func
                    }
                }
            }
        }
    }
    else   //if no key is pressed, bird falls
    {   bt++;
        for (y = 0; y < 20; y++)
        {   for (x = 0; x < 30; x++)
            {   if (c[x][y] == '*')
                {   if (y < 20)  //if bird is not on the ground
                    {   if (bt < 3)   //if bird time is lower that 3, it falls 1 pixel
                        {   c[x][y + 1] = '*';
                            c[x][y] = ' ';
                            birdx = x;
                            birdy = y + 1;
                            return;
                        }
                        else if (bt > 2 && bt < 5)  //more time has passed, faster bird falls (acceleration)
                        {   c[x][y + 2] = '*';
                            c[x][y] = ' ';
                            birdx = x;
                            birdy = y + 2;
                            return;
                        }
                        else if (bt > 4)
                        {   c[x][y + 3] = '*';
                            c[x][y] = ' ';
                            birdx = x;
                            birdy = y + 3;
                            return;
                        }
                    }
                    else
                    {   return;  //if bird is already on the ground, function returns to check for game over.
                    }
                }
            }
        }
    }
}
 
void checkscore()  //checks if bird gained score
{   int y;
    for (y = 0; y < 20; y++)
    {   if (c[birdx][y] == '|')  //if bird x coord is equal to pipe's coord, you get 1 point
        {   player.score++;
            return;
        }
    }
}
 
bool gameover()  //checks if bird has hit something
{   int f = 0;
    if (birdy > 19) //checks if bird hits ground
    {   c[birdx][19] = '*';  //sets bird and ground again, prevents errors
        c[birdx][20] = '-';
        f = 1;           //f=1, means function will return true
        goto quit;
    }
    else
    {   //checks if bird has hit pipes, here the 'n' variable is needed (pipe's coordinate's n is equal 2 (more than 0))
        if (n[birdx][birdy] > 0 && (c[birdx][birdy] == '|' || c[birdx][birdy] == '*'))
        {   c[birdx][birdy] = '|';
            c[birdx - 1][19] = '*';
            f = 1;
            goto quit;
        }
    }
quit:
    if (f == 1) return true;
    else return false;
}
 
void endgame() //just some screens for certain actions
{   screen();   //this one pops up if game ends
    cout << "" << endl << endl;
    cout << " ------------------------------------------------------------------------- " << endl;
    cout << "|    *****      *     *       * ******       ****  *       ****** ****    |" << endl;
    cout << "|   *          * *    * *   * * *           *    *  *     * *     *   *   |" << endl;
    cout << "|   *  ****   *   *   *  * *  * *****       *    *   *   *  ****  ****    |" << endl;
    cout << "|   *  *  *  *******  *   *   * *           *    *    * *   *     * *     |" << endl;
    cout << "|    *****  *       * *       * ******       ****      *    ***** *   *   |" << endl;
    cout << " ------------------------------------------------------------------------- " << endl;
    cout << "" << endl << endl;
    cout << "                        Y O U R   S C O R E : " << player.score << endl << endl;
    cout << "                        H I G H   S C O R E : " << highscore << endl;
    cout << "" << endl << endl;
}
 
void menu()  //shows menu
{   system("cls");
    cout << "" << endl;
    cout << " --------------------------------------------------------  " << endl;
    cout << "|                                                        | " << endl;
    cout << "|   **** *    **** **** **** *   *    ***  * ***  ***    | " << endl;
    cout << "|   *    *    *  * *  * *  * *   *    *  * * *  * *  *   | " << endl;
    cout << "|   ***  *    **** **** **** *****    ***  * ***  *  *   | " << endl;
    cout << "|   *    *    *  * *    *      *      *  * * *  * *  *   | " << endl;
    cout << "|   *    **** *  * *    *      *      ***  * *  * ***    | " << endl;
    cout << "|                                                  v 1.0 | " << endl;
    cout << " --------------------------------------------------------  " << endl;
    cout << "" << endl << endl;
    cout << "                  High Score:  " << highscore << endl << endl;
    cout << "" << endl << endl;
    cout << "                     М Е Н Ю:    " << endl << endl;
    cout << "                  1: Почати гру  " << endl << endl;
    cout << "                  2: Інструкція        " << endl << endl;
    cout << "                  3: Таблиця рекордів     " << endl << endl;
    cout << "                  4: Вихід        " << endl << endl;
}
 
void credits()
{   std::system("cls");
    tabrecords >> std::cout;
 
    std::string s; std::getline(std::cin, s);
    std::cin.get();
}
 
void help()
{   char sel;
    system("cls");
    while (true)
    {   cout << "" << endl << endl;
        cout << "                   Controls: Press any key to fly up.         " << endl << endl;
        cout << "             Goal: Fly through the holes between the pipes.   " << endl;
        cout << "             When you pass through the hole,you get 1 point.  " << endl;
        cout << "                    Try to pass as much as you can.           " << endl;
        cout << "            But be careful, don't hit the pipes or the ground!" << endl << endl;
        cout << "                          Are you ready? Go!                  " << endl << endl << endl;
        cout << "Go back? [y/n]  ";
        cin >> sel;
        if (sel == 'y') return;
        else system("cls");
    }
}