The Labyrinth

#include <iostream>
#include <string>
#include <fstream>
#include <Windows.h>
#include <ctype.h>
#include <random>
#include <chrono>
#include <thread>
#include <conio.h>

using namespace std;

string player = "O";

int playerX = 1;

int playerY = 0;

int originalPlayerX = playerX;

int originalPlayerY = playerY;

int mainMenu();

void gameStart();

void customGame();

void gameControls();

void gameCredits();

void customMapInformation();

void exitProgram();

int customGameMenu();

int difficultyMenu();

void easyDifficulty();

void normalDifficulty();

void hardDifficulty();

void backToMenu();

void characterMove(string**, int&, int&, int, int);

void playerMove(string**);

void display(string**, int, int, int, string);

void loadMap(string, int, string);

void loadCustomMapFromTheFolder();

void createCustomMap();

int filesInFolderCount(string);

void levels(string);

void ShowConsoleCursor(bool showFlag);

int main()
{
    system("color 04");

    ShowWindow(GetConsoleWindow(), SW_MAXIMIZE);

    SendMessage(GetConsoleWindow(), WM_SYSKEYDOWN, VK_RETURN, 0x2000000);

    ShowConsoleCursor(false);

    mainMenu();

    return 0;
}

typedef void(*menuOptions)();

menuOptions mainMenuOptions[] = { gameStart, customGame, gameControls, gameCredits, customMapInformation, exitProgram };

int mainMenu()
{
    string menu[] = { "Start Game", "Create a Custom Game", "Controls", "Credits", "How to create a custom map?", "Exit"};

    int pointer = 0;

    bool lastUpKeyState = false;

    bool lastDownKeyState = false;

    bool lastReturnKeyState = false;

    bool arrowVisible = true;

    while (true)
    {
        system("cls");

        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_RED);

        cout << "The Labyrinth" << "\n" << "\n";

        cout << "Main Menu" << "\n" << "\n";

        for (int i = 0; i < size(menu); i++) // FROM i < 5
        {
            if (i == pointer)
            {
                if (arrowVisible)
                {
                    cout << "-> ";

                    arrowVisible = false;
                }

                else
                {
                    cout << "    "; // Prints 4 spaces to cover the previous "-> "

                    arrowVisible = true;
                }

                SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_GREEN);

                cout << menu[i] << endl;
            }

            else
            {
                SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_RED);

                cout << menu[i] << endl;
            }
        }

        bool upKeyState = GetAsyncKeyState(VK_UP);

        if ( (upKeyState) && !(lastUpKeyState) )
        {
            pointer -= 1;

            if (pointer == -1)
            {
                pointer = size(menu) - 1; // FROM pointer = 4
            }
        }

        lastUpKeyState = upKeyState;

        bool downKeyState = GetAsyncKeyState(VK_DOWN);

        if ( (downKeyState) && !(lastDownKeyState) )
        {
            pointer += 1;

            if (pointer == size(menu)) // FROM pointer = 5
            {
                pointer = 0;
            }
        }

        lastDownKeyState = downKeyState;

        bool returnKeyState = GetAsyncKeyState(VK_RETURN);

        if ( (returnKeyState) && !(lastReturnKeyState) )
        {
            mainMenuOptions[pointer]();
        }

        lastReturnKeyState = returnKeyState;

        this_thread::sleep_for(chrono::milliseconds(200));
    }
}

void gameStart()
{
    difficultyMenu();
}

void customGame()
{
    customGameMenu();
}

void gameControls()
{
    system("cls");

    cout << "\n";

    cout << "  --------------CONTROLS---------------" << "\n";
    cout << "  |                                   |" << "\n";
    cout << "  |                                   |" << "\n";
    cout << "  |   ^ --> Up Arrow to move up       |" << "\n";
    cout << "  |   < --> Left Arrow to move left   |" << "\n";
    cout << "  |   > --> Right Arrow to move right |" << "\n";
    cout << "  |   v --> Down Arrow to move down   |" << "\n";
    cout << "  |                                   |" << "\n";
    cout << "  |   Enter / Return --> Enter        |" << "\n";
    cout << "  |   Escape --> Back                 |" << "\n";
    cout << "  |                                   |" << "\n";
    cout << "  |                                   |" << "\n";
    cout << "  -------------------------------------" << "\n";

    while (true)
    {
        backToMenu();
    }
}

void gameCredits()
{
    system("cls");

    cout << "Thanks for playing!" << "\n";

    cout << "\n";

    cout << "Creator: Petar Bogdanov" << "\n";

    cout << "The people who helped me with this project: eng. Stoyan Filipov and eng. Monika Gencheva" << "\n" << "\n";

    cout << "Press \"ESCAPE\" to go back to the Main Menu" << "\n";

    while (true)
    {
        backToMenu();
    }
}

void customMapInformation()
{
    system("cls");

    cout << "To create a custom map you need to:" << "\n";

    cout << "  1. Create a .txt file." << "\n";

    cout << "  2. Visualize your map." << "\n";

    cout << "  3. Put the file in the subfolder called \"custom\", if you haven't created it there already." << "\n";

    while (true)
    {
        backToMenu();
    }
}

void exitProgram()
{
    exit(0);
}

menuOptions customMenuOptions[] = { loadCustomMapFromTheFolder, createCustomMap };

int customGameMenu()
{
    string menu[] = { "Play on your created custom maps placed in the subfolder", "Create a custom map" };

    int pointer = 0;

    bool lastUpKeyState = false;

    bool lastDownKeyState = false;

    bool lastReturnKeyState = false;

    bool arrowVisible = true;

    while (true)
    {
        system("cls");

        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_RED);

        cout << "Type of a custom map" << "\n" << "\n";

        for (int i = 0; i < size(menu); i++)
        {
            if (i == pointer)
            {
                if (arrowVisible)
                {
                    cout << "-> ";

                    arrowVisible = false;
                }

                else
                {
                    cout << "    "; // Prints 4 spaces to cover the previous "-> "

                    arrowVisible = true;
                }

                SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_GREEN);

                cout << menu[i] << endl;
            }

            else
            {
                SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_RED);

                cout << menu[i] << endl;
            }
        }

        bool upKeyState = GetAsyncKeyState(VK_UP);

        if ( (upKeyState) && !(lastUpKeyState) )
        {
            pointer -= 1;

            if (pointer == -1)
            {
                pointer = size(menu) - 1;
            }
        }

        lastUpKeyState = upKeyState;

        bool downKeyState = GetAsyncKeyState(VK_DOWN);

        if ( (downKeyState) && !(lastDownKeyState) )
        {
            pointer += 1;

            if (pointer == size(menu))
            {
                pointer = 0;
            }
        }

        lastDownKeyState = downKeyState;

        bool returnKeyState = GetAsyncKeyState(VK_RETURN);

        if ( (returnKeyState) && !(lastReturnKeyState) )
        {
            customMenuOptions[pointer]();
        }

        backToMenu();

        lastReturnKeyState = returnKeyState;

        this_thread::sleep_for(chrono::milliseconds(200));
    }
}

menuOptions difficultyMenuOptions[] = { easyDifficulty, normalDifficulty, hardDifficulty };

int difficultyMenu()
{
    string difficulty[] = { "Easy", "Normal", "Hard" };

    int pointer = 0;

    bool lastUpKeyState = false;

    bool lastDownKeyState = false;

    bool lastReturnKeyState = false;

    bool arrowVisible = true;

    while (true)
    {
        system("cls");

        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_RED);

        cout << "Choose difficulty" << "\n" << "\n";

        for (int i = 0; i < size(difficulty); i++)
        {
            if (i == pointer)
            {
                if (arrowVisible)
                {
                    cout << "-> ";

                    arrowVisible = false;
                }

                else
                {
                    cout << "    "; // Prints 4 spaces to cover the previous "-> "

                    arrowVisible = true;
                }

                SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_GREEN);

                cout << difficulty[i] << endl;
            }

            else
            {
                SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_RED);

                cout << difficulty[i] << endl;
            }
        }

        bool upKeyState = GetAsyncKeyState(VK_UP);

        if ( (upKeyState) && !(lastUpKeyState) )
        {
            pointer -= 1;

            if (pointer == -1)
            {
                pointer = size(difficulty) - 1;
            }
        }

        lastUpKeyState = upKeyState;

        bool downKeyState = GetAsyncKeyState(VK_DOWN);

        if ( (downKeyState) && !(lastDownKeyState) )
        {
            pointer += 1;

            if (pointer == size(difficulty))
            {
                pointer = 0;
            }
        }

        lastDownKeyState = downKeyState;

        bool returnKeyState = GetAsyncKeyState(VK_RETURN);

        if ( (returnKeyState) && !(lastReturnKeyState) )
        {
            difficultyMenuOptions[pointer]();
        }

        backToMenu();

        lastReturnKeyState = returnKeyState;

        this_thread::sleep_for(chrono::milliseconds(200));
    }
}

void easyDifficulty()
{
    levels("easy");
}

void normalDifficulty()
{
    levels("normal");
}

void hardDifficulty()
{
    levels("hard");
}

void backToMenu()
{
    if (GetAsyncKeyState(VK_ESCAPE))
    {
        main();
    }
}

void characterMove(string** labyrinth, int& x, int& y, int dx, int dy)
{
    if (labyrinth[x + dx][y + dy] == "S" || labyrinth[x + dx][y + dy] == " " || labyrinth[x + dx][y + dy] == "E")
    {
        x += dx;
        y += dy;
    }
}

void playerMove(string** labyrinth)
{
    char key = _getch();

    if (key == 72) // The ASCII CODE FOR THE UP ARROW KEY
    {
        characterMove(labyrinth, playerX, playerY, -1, 0);
    }

    else if (key == 75) // The ASCII CODE FOR THE LEFT ARROW KEY
    {
        characterMove(labyrinth, playerX, playerY, 0, -1);
    }

    else if (key == 80) // The ASCII CODE FOR THE DOWN ARROW KEY
    {
        characterMove(labyrinth, playerX, playerY, 1, 0);
    }

    else if (key == 77) // The ASCII CODE FOR THE RIGHT ARROW KEY
    {
        characterMove(labyrinth, playerX, playerY, 0, 1);
    }
}

void display(string** labyrinth, int rowsCount, int columnsCount, int level, string levelType)
{
    bool breakAfterRender = false;

    while (true)
    {
        system("cls");

        cout << "Difficulty: " << levelType << "\n";

        cout << "Level: " << level << " / " << filesInFolderCount(levelType) << "\n" << "\n";

        int colour = rand() % 15 + 1;

        for (int i = 0; i < rowsCount; i++)
        {
            for (int j = 0; j < columnsCount; j++)
            {
                if ((i == playerX) && (j == playerY))
                {
                    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), colour);

                    cout << player;

                    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 7);
                }

                else
                {
                    cout << labyrinth[i][j];
                }
            }

            cout << "\n";
        }

        if (breakAfterRender)
        {
            cout << "\n";

            cout << "Congratulations! You have reached the end of the level!" << "\n";

            playerX = originalPlayerX;

            playerY = originalPlayerY;

            cout << "\n" << "\n";

            cout << "Press \"ENTER\" to continue" << "\n";

            while (true)
            {
                if (_getch() == 13) // The ASCII CODE FOR THE ENTER / RETURN KEY
                {
                    break;
                }
            }

            break;
        }

        labyrinth[playerX][playerY] = " ";

        playerMove(labyrinth);

        if (labyrinth[playerX][playerY] == "E")
        {
            breakAfterRender = true;
        }

        labyrinth[playerX][playerY] = player;

        this_thread::sleep_for(chrono::milliseconds(24));
    }
}

void loadMap(string fileName, int level, string levelType)
{
    int rowsCount = 1;

    int columnsCount = 0;

    int startAt = 0;

    int endAt = 0;

    ifstream mapFile;
    mapFile.open(fileName);

    if (mapFile.is_open())
    {
        char mychar;

        while (mapFile)
        {
            mychar = mapFile.get();

            if (mychar == '\n')
            {
                rowsCount++;
            }

            else if ( (mychar != '\n') && (rowsCount == 1) )
            {
                columnsCount++;
            }

            else if (mychar == 'S')
            {
                startAt = rowsCount - 1;
            }

            else if (mychar == 'E')
            {
                endAt = rowsCount - 1;
            }
        }
    }

    else
    {
        cout << "Error: Unable to open file " << fileName << "\n" << "\n";

        cout << "Press \"ESCAPE\" to go back to the Main Menu" << "\n";

        while (true)
        {
            backToMenu();
        }
    }

    mapFile.close();

    // Dynamically allocating row space in the heap
    string** labyrinth = new string * [rowsCount];

    // Dynamically allocating column space in the heap
    for (int i = 0; i < rowsCount; i++)
    {
        labyrinth[i] = new string[columnsCount];
    }

    int currentRow = 0;

    int currentColumn = 0;

    mapFile.open(fileName);

    if (mapFile.is_open())
    {
        char currentSymbol;

        while (mapFile.get(currentSymbol))
        {
            if ( (currentRow < rowsCount) && (currentColumn < columnsCount) )
            {
                labyrinth[currentRow][currentColumn] = currentSymbol;
            }

            if (currentSymbol == '\n')
            {
                currentRow++;

                currentColumn = 0;
            }

            else
            {
                currentColumn++;
            }
        }
    }

    mapFile.close();

    // Displaying the labyrinth
    display(labyrinth, rowsCount, columnsCount, level, levelType);

    // Free up the space after the use of the array
    for (int i = 0; i < rowsCount; i++)
    {
        delete[] labyrinth[i];
    }

    delete[] labyrinth;
}

void loadCustomMapFromTheFolder()
{
    int fileCount = filesInFolderCount("custom");

    string* menu = new string[fileCount]; // NOTE: To work with a dynamic array the second if statement in the while loop, that's located in a if statement is needed

    //vector<string> menu(fileCount); // NOTE: Works perfectly

    WIN32_FIND_DATA findData;
    HANDLE hFind;

    string folderPath = "maps/custom/";

    wstring wideFolderPath(folderPath.begin(), folderPath.end());
    wideFolderPath += L"*";

    hFind = FindFirstFile(wideFolderPath.c_str(), &findData);

    if (hFind != INVALID_HANDLE_VALUE)
    {
        char narrowString[MAX_PATH];

        int counter = 0;

        while (FindNextFile(hFind, &findData) != 0)
        {
            WideCharToMultiByte(CP_ACP, 0, findData.cFileName, -1, narrowString, MAX_PATH, NULL, NULL);

            if (strcmp(narrowString, ".") != 0 && strcmp(narrowString, "..") != 0)
            {
                if (counter == fileCount)
                {
                    string* newData = new string[fileCount * 2];

                    for (int i = 0; i < counter; i++)
                    {
                        newData[i] = menu[i];
                    }

                    delete[] menu;

                    menu = newData;
                }

                menu[counter] = narrowString;

                counter++;
            }
        }

        FindClose(hFind);
    }

    int pointer = 0;

    bool lastUpKeyState = false;

    bool lastDownKeyState = false;

    bool lastReturnKeyState = false;

    bool arrowVisible = true;

    while (true)
    {
        system("cls");

        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_RED);

        cout << "There are " << fileCount << " files in the subfolder called \"custom\"." << "\n" << "\n";

        cout << "Select a Custom Map" << "\n" << "\n";

        for (int i = 0; i < fileCount; i++)
        {
            if (i == pointer)
            {
                if (arrowVisible)
                {
                    cout << "-> ";

                    arrowVisible = false;
                }

                else
                {
                    cout << "    "; // Prints 4 spaces to cover the previous "-> "

                    arrowVisible = true;
                }

                SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_GREEN);

                cout << menu[i] << "\n";
            }

            else
            {
                SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_RED);

                cout << menu[i] << "\n";
            }
        }

        bool upKeyState = GetAsyncKeyState(VK_UP);

        if ( (upKeyState) && !(lastUpKeyState) )
        {
            pointer -= 1;

            if (pointer == -1)
            {
                pointer = fileCount - 1;
            }
        }

        lastUpKeyState = upKeyState;

        bool downKeyState = GetAsyncKeyState(VK_DOWN);

        if ( (downKeyState) && !(lastDownKeyState) )
        {
            pointer += 1;

            if (pointer == fileCount)
            {
                pointer = 0;
            }
        }

        lastDownKeyState = downKeyState;

        bool returnKeyState = GetAsyncKeyState(VK_RETURN);

        if ((returnKeyState) && !(lastReturnKeyState))
        {
            // code to load the selected file goes here
        }

        lastReturnKeyState = returnKeyState;

        if (GetAsyncKeyState(VK_ESCAPE))
        {
            customGame();
        }

        this_thread::sleep_for(chrono::milliseconds(200));
    }

    delete[] menu;
}

void createCustomMap()
{

}

int filesInFolderCount(string levelType)
{
    int fileCount = 0;

    string folderPath = "maps/" + levelType + "/";

    // Get the first file in the folder
    WIN32_FIND_DATAA findFileData;

    HANDLE hFind = FindFirstFileA((folderPath + "*").c_str(), &findFileData);

    // Iterate through the files in the folder
    if (hFind != INVALID_HANDLE_VALUE)
    {
        while (true)
        {
            // Check if the current file is a regular file
            if ( (findFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0 )
            {
                fileCount++;
            }

            if ( !(FindNextFileA(hFind, &findFileData)) )
            {
                break;
            }
        }

        // Clean up
        FindClose(hFind);
    }

    return fileCount;
}

void levels(string levelType)
{
    int level = 1;

    if ( (levelType != "easy") && (levelType != "normal") && (levelType != "hard") )
    {
        system("cls");

        cout << "Invalid level!" << "\n";

        return;
    }

    while (level <= filesInFolderCount(levelType))
    {
        system("cls");

        string mapFile = "maps/" + levelType + "/map_" + to_string(level) + ".txt";

        // Opening the text file
        loadMap(mapFile, level, levelType);

        level++;
    }

    system("cls");

    cout << "Congratulations! You have finished the game!" << "\n" << "\n";

    cout << "Press \"ENTER\" to continue";

    while (true)
    {
        if (_getch() == 13) // The ASCII CODE FOR THE ENTER / RETURN KEY
        {
            break;
        }
    }

    gameCredits();
}

void ShowConsoleCursor(bool showFlag)
{
    HANDLE out = GetStdHandle(STD_OUTPUT_HANDLE);

    CONSOLE_CURSOR_INFO     cursorInfo;

    GetConsoleCursorInfo(out, &cursorInfo);

    cursorInfo.bVisible = showFlag; // SET THE CURSOR VISIBILITY

    SetConsoleCursorInfo(out, &cursorInfo);
}