C++ Adventure Game Skeleton

/*
============================================================================
==========================Adventure Game Skeleton!==========================
============================================================================

- This has all of the basic features of a text based adventure game.

- The AI isn't very good(all randomized), but it's a start. If you want a really smart enemy, have them go directly for the
    player.

- Nothing can go through walls. It will stop you if you try.

- The map can be adjusted and changed, '/' will always be walkable ground, '#' will always be walls

- No matter what, you can have the walls anywhere and it will work (As long as there is spawn space, and spawns are in the right place)

- You could add several maps by making "doors" on specific coordinates that when you walk through them, it causes the new map to load.
    This could possibly lead to a very large map system.

- Weapons are possible to fight off enemies (Projectiles mostly).
    A simple sprite that goes 2 spaces every turn and stops when it hits a wall, or kills a monster.

- For a melee weapon, do the melee first, then have the monsters move. Melee would be very risky with the randomized movements
    if you were surrounded by monsters.

- The sword was added and now you can attack enemies. It goes in four directions, and only goes one unit in distance.
    If you can figure out how to add the sword graphics, go ahead.

- A loot system is now possible. Do a check if the enemy is dead, then if you step on them and they are in fact dead,
    add to the player's loot. This could possibly lead to a buying system where you can increase the range of your weapon,
    amongst other things such as lives, armor, etc., etc..

- You can make an inventory system with a vector by adding loot, or bought items to it. Then you could add them to a vector
    and iterate through that vector, as well as access the items.

- I recommend you make a class for items as well as entities. This will shorten the code a BUNCH, as well as make
    accessing parts of each entity much easier and compact. It would also allow the creation of more entities.
*/

#include <iostream>
#include <Windows.h>
#include <string>
#include <cstdlib>
#include <ctime>

using namespace std;
void ShowBoard();
void EnemyMove();
void EnemyMove2();
void EnemyMove3();
const char Player = '@';
const char Enemy = '%';
const char Enemy2 = '&';
const char Enemy3 = '^';
const char Wall = '#';
const char SliceUp = '|';
const char SliceDown = '!';
const char SliceLeft = '<';
const char SliceRight = '>';
const int Length = 10;
const int Height = 10;
char board[Height][Length] = { {'#', '#', '#', '#', '#', '#', '#', '#', '#', '#'},
                               {'#', '/', '#', '/', '/', '/', '#', '/', '/', '#'},
                               {'#', '/', '#', '/', '#', '/', '#', '/', '/', '#'},
                               {'#', '/', '#', '/', '#', '/', '#', '/', '/', '#'},
                               {'#', '/', '#', '/', '#', '/', '#', '/', '/', '#'},
                               {'#', '/', '#', '/', '#', '/', '#', '/', '/', '#'},
                               {'#', '/', '#', '/', '#', '/', '#', '/', '/', '#'},
                               {'#', '/', '#', '/', '#', '/', '#', '/', '/', '#'},
                               {'#', '/', '/', '/', '#', '/', '/', '/', '/', '#'},
                               {'#', '#', '#', '#', '#', '#', '#', '#', '#', '#'} };
int Score = 0;
int PlayerX = 1;
int PlayerY = 1;
int EnemyX = 8;
int EnemyY = 8;
int EnemyX2 = 8;
int EnemyY2 = 8;
int EnemyX3 = 8;
int EnemyY3 = 8;
bool EnemyDead = false;
bool Enemy2Dead = false;
bool Enemy3Dead = false;
int EnemyChoice;
int EnemyChoice2;
int EnemyChoice3;
char choice;

int main()
{
    srand(static_cast<unsigned int>(time(0)));

    board[PlayerY][PlayerX] = Player;
    board[EnemyY][EnemyX] = Enemy;

    while (!GetAsyncKeyState(VK_INSERT))
    {
        if (EnemyDead && Enemy2Dead && Enemy3Dead)
        {
            break;
        }



        system("CLS");
        ShowBoard();
        cout << "Where would you like to move your player?\nW - up\nS - down\nA - left\nD - right\n";
        cout << "You can also attack.\nU - up\nJ - down\nH - left\nK - right\n";
        cin >> choice;

        if (choice == 'u')
        {
            int storeX = PlayerX;
            int storeY = PlayerY;
            char storeSymbol = board[PlayerX][PlayerY];

            int Attack = PlayerY - 1;

            if (PlayerX == EnemyX && Attack == EnemyY)
            {
                EnemyDead = true;
            }

            else if (PlayerX == EnemyX2 && Attack == EnemyY2)
            {
                Enemy2Dead = true;
            }

            else if (PlayerX == EnemyX3 && Attack == EnemyY3)
            {
                Enemy3Dead = true;
            }

            PlayerX = storeX;
            PlayerY = storeY;

            EnemyMove();
            EnemyMove2();
            EnemyMove3();
        }

        if (choice == 'j')
        {
            int storeX = PlayerX;
            int storeY = PlayerY;
            char storeSymbol = board[PlayerX][PlayerY];

            int Attack = PlayerY + 1;

            if (PlayerX == EnemyX && Attack == EnemyY)
            {
                EnemyDead = true;
            }

            else if (PlayerX == EnemyX2 && Attack == EnemyY2)
            {
                Enemy2Dead = true;
            }

            else if (PlayerX == EnemyX3 && Attack == EnemyY3)
            {
                Enemy3Dead = true;
            }

            PlayerX = storeX;
            PlayerY = storeY;

            EnemyMove();
            EnemyMove2();
            EnemyMove3();
        }

        if (choice == 'h')
        {
            int storeX = PlayerX;
            int storeY = PlayerY;
            char storeSymbol = board[PlayerX][PlayerY];

            int Attack = PlayerX + 1;

            if (Attack == EnemyX && PlayerY == EnemyY)
            {
                EnemyDead = true;
            }

            else if (Attack == EnemyX2 && PlayerY == EnemyY2)
            {
                Enemy2Dead = true;
            }

            else if (Attack == EnemyX3 && PlayerY == EnemyY3)
            {
                Enemy3Dead = true;
            }

            PlayerX = storeX;
            PlayerY = storeY;

            EnemyMove();
            EnemyMove2();
            EnemyMove3();
        }

        if (choice == 'k')
        {
            int storeX = PlayerX;
            int storeY = PlayerY;
            char storeSymbol = board[PlayerX][PlayerY];

            int Attack = PlayerX - 1;

            if (Attack == EnemyX && PlayerY == EnemyY)
            {
                EnemyDead = true;
            }

            else if (Attack == EnemyX2 && PlayerY == EnemyY2)
            {
                Enemy2Dead = true;
            }

            else if (Attack == EnemyX3 && PlayerY == EnemyY3)
            {
                Enemy3Dead = true;
            }

            PlayerX = storeX;
            PlayerY = storeY;

            EnemyMove();
            EnemyMove2();
            EnemyMove3();
        }

        if (choice == 'w')
        {
            EnemyMove();
            EnemyMove2();
            EnemyMove3();

            if (PlayerY == EnemyY && PlayerX == EnemyX ||
                PlayerY == EnemyY2 && PlayerX == EnemyX2 ||
                PlayerY == EnemyY3 && PlayerX == EnemyX3)
            {
                break;
            }

            else
                ++Score;

            board[PlayerY][PlayerX] = '/';
            --PlayerY;

            if (board[PlayerY][PlayerX] == Wall)
            {
                board[PlayerY][PlayerX] = Wall;
                ++PlayerY;
                board[PlayerY][PlayerX] = Player;
            }
            else
                board[PlayerY][PlayerX] = Player;
        }

        else if (choice == 's')
        {
            EnemyMove();
            EnemyMove2();
            EnemyMove3();

            if (PlayerY == EnemyY && PlayerX == EnemyX ||
                PlayerY == EnemyY2 && PlayerX == EnemyX2 ||
                PlayerY == EnemyY3 && PlayerX == EnemyX3)
            {
                break;
            }

            else
                ++Score;

            board[PlayerY][PlayerX] = '/';
            ++PlayerY;

            if (board[PlayerY][PlayerX] == Wall)
            {
                board[PlayerY][PlayerX] = Wall;
                --PlayerY;
                board[PlayerY][PlayerX] = Player;
            }
            else
                board[PlayerY][PlayerX] = Player;
        }

        else if (choice == 'a')

        {
            EnemyMove();
            EnemyMove2();
            EnemyMove3();

            if (PlayerY == EnemyY && PlayerX == EnemyX ||
                PlayerY == EnemyY2 && PlayerX == EnemyX2 ||
                PlayerY == EnemyY3 && PlayerX == EnemyX3)
            {
                break;
            }

            else
                ++Score;

            board[PlayerY][PlayerX] = '/';
            --PlayerX;

            if (board[PlayerY][PlayerX] == Wall)
            {
                board[PlayerY][PlayerX] = Wall;
                ++PlayerX;
                board[PlayerY][PlayerX] = Player;
            }
            else
                board[PlayerY][PlayerX] = Player;
        }

        else if (choice == 'd')
        {
            EnemyMove();
            EnemyMove2();
            EnemyMove3();

            if (PlayerY == EnemyY && PlayerX == EnemyX ||
                PlayerY == EnemyY2 && PlayerX == EnemyX2 ||
                PlayerY == EnemyY3 && PlayerX == EnemyX3)
            {
                break;
            }

            else
                ++Score;

            board[PlayerY][PlayerX] = '/';
            ++PlayerX;
            if (board[PlayerY][PlayerX] == Wall)
            {
                board[PlayerY][PlayerX] = Wall;
                --PlayerX;
                board[PlayerY][PlayerX] = Player;
            }
            else
                board[PlayerY][PlayerX] = Player;
        }
    }

    if (EnemyDead && Enemy2Dead && Enemy3Dead)
    {
        cout << "You defeated all of the enemies in " << Score << " turns!\n";
        system("PAUSE");
    }

    else
    {
    cout << "\nYou survived " << Score << " turns before being defeated!\n";
    system("PAUSE");
    }
}


void ShowBoard()
{
    for (int i = 0; i < Height; i++)
    {
        for (int j = 0; j < Length; j++)
        {
            cout << board[i][j];
        }
        cout << endl;
    }
}


void EnemyMove()
{
    char Finished = 'P';
    while (Finished != 'R')
    {

        if (EnemyDead == true)
        {
            EnemyX = 0;
            EnemyY = 0;

            break;
        }

        EnemyChoice = (rand() % 4);

        if (EnemyChoice == 0)
            {
                if (EnemyY == 1)
                    continue;

                --EnemyY;

                if (board[EnemyY][EnemyX] == Wall)
                {
                    ++EnemyY;
                    continue;
                }
                ++EnemyY;

                board[EnemyY][EnemyX] = '/';
                --EnemyY;
                board[EnemyY][EnemyX] = Enemy;
                Finished = 'R';

                if (EnemyY == EnemyY2 && EnemyX == EnemyX2 || EnemyY == EnemyY3 && EnemyX == EnemyX3)
                {
                    board[EnemyY][EnemyX] = '/';
                    ++EnemyY;
                    board[EnemyY][EnemyX] = Enemy;
                    continue;
                }
            }

            else if (EnemyChoice == 1)
            {
                if (EnemyY == 8)
                    continue;

                ++EnemyY;

                if (board[EnemyY][EnemyX] == Wall)
                {
                    --EnemyY;
                    continue;
                }
                --EnemyY;

                board[EnemyY][EnemyX] = '/';
                ++EnemyY;
                board[EnemyY][EnemyX] = Enemy;
                Finished = 'R';

                if (EnemyY == EnemyY2 && EnemyX == EnemyX2 || EnemyY == EnemyY3 && EnemyX == EnemyX3)
                {
                    board[EnemyY][EnemyX] = '/';
                    --EnemyY;
                    board[EnemyY][EnemyX] = Enemy;
                    continue;
                }
            }

            else if (EnemyChoice == 2)
            {
                if (EnemyX == 1)
                    continue;

                --EnemyX;

                if (board[EnemyY][EnemyX] == Wall)
                {
                    ++EnemyX;
                    continue;
                }
                ++EnemyX;

                board[EnemyY][EnemyX] = '/';
                --EnemyX;
                board[EnemyY][EnemyX] = Enemy;
                Finished = 'R';

                if (EnemyY == EnemyY2 && EnemyX == EnemyX2 || EnemyY == EnemyY3 && EnemyX == EnemyX3)
                {
                    board[EnemyY][EnemyX] = '/';
                    ++EnemyX;
                    board[EnemyY][EnemyX] = Enemy;
                    continue;
                }
            }

            else if (EnemyChoice == 3)
            {
                if (EnemyX == 8)
                    continue;

                ++EnemyX;

                if (board[EnemyY][EnemyX] == Wall)
                {
                    --EnemyX;
                    continue;
                }
                --EnemyX;

                board[EnemyY][EnemyX] = '/';
                ++EnemyX;
                board[EnemyY][EnemyX] = Enemy;
                Finished = 'R';

                if (EnemyY == EnemyY2 && EnemyX == EnemyX2 || EnemyY == EnemyY3 && EnemyX == EnemyX3)
                {
                    board[EnemyY][EnemyX] = '/';
                    --EnemyX;
                    board[EnemyY][EnemyX] = Enemy;
                    continue;
                }
            }
    }
}


void EnemyMove2()
{
    char Finished = 'P';
    while (Finished != 'R')
    {

        if (Enemy2Dead == true)
        {
            EnemyX2 = 0;
            EnemyY2 = 0;

            break;
        }

        EnemyChoice2 = (rand() % 4);

        if (EnemyChoice2 == 0)
            {
                if (EnemyY2 == 1)
                    continue;

                --EnemyY2;

                if (board[EnemyY2][EnemyX2] == Wall)
                {
                    ++EnemyY2;
                    continue;
                }
                ++EnemyY2;

                board[EnemyY2][EnemyX2] = '/';
                --EnemyY2;
                board[EnemyY2][EnemyX2] = Enemy2;
                Finished = 'R';

                if (EnemyY2 == EnemyY && EnemyX2 == EnemyX || EnemyY2 == EnemyY3 && EnemyX2 == EnemyX3)
                {
                    board[EnemyY2][EnemyX2] = '/';
                    ++EnemyY2;
                    board[EnemyY2][EnemyX2] = Enemy2;
                    continue;
                }
            }

            else if (EnemyChoice2 == 1)
            {
                if (EnemyY2 == 8)
                    continue;

                ++EnemyY2;

                if (board[EnemyY2][EnemyX2] == Wall)
                {
                    --EnemyY2;
                    continue;
                }
                --EnemyY2;

                board[EnemyY2][EnemyX2] = '/';
                ++EnemyY2;
                board[EnemyY2][EnemyX2] = Enemy2;
                Finished = 'R';

                if (EnemyY2 == EnemyY && EnemyX2 == EnemyX || EnemyY2 == EnemyY3 && EnemyX2 == EnemyX3)
                {
                    board[EnemyY2][EnemyX2] = '/';
                    --EnemyY2;
                    board[EnemyY2][EnemyX2] = Enemy2;
                    continue;
                }
            }

            else if (EnemyChoice2 == 2)
            {
                if (EnemyX2 == 1)
                    continue;

                --EnemyX2;

                if (board[EnemyY2][EnemyX2] == Wall)
                {
                    ++EnemyX2;
                    continue;
                }
                ++EnemyX2;

                board[EnemyY2][EnemyX2] = '/';
                --EnemyX2;
                board[EnemyY2][EnemyX2] = Enemy2;
                Finished = 'R';

                if (EnemyY2 == EnemyY && EnemyX2 == EnemyX || EnemyY2 == EnemyY3 && EnemyX2 == EnemyX3)
                {
                    board[EnemyY2][EnemyX2] = '/';
                    ++EnemyX2;
                    board[EnemyY2][EnemyX2] = Enemy2;
                    continue;
                }
            }

            else if (EnemyChoice2 == 3)
            {
                if (EnemyX2 == 8)
                    continue;

                ++EnemyX2;

                if (board[EnemyY2][EnemyX2] == Wall)
                {
                    --EnemyX2;
                    continue;
                }
                --EnemyX2;

                board[EnemyY2][EnemyX2] = '/';
                ++EnemyX2;
                board[EnemyY2][EnemyX2] = Enemy2;
                Finished = 'R';

                if (EnemyY2 == EnemyY && EnemyX2 == EnemyX || EnemyY2 == EnemyY3 && EnemyX2 == EnemyX3)
                {
                    board[EnemyY2][EnemyX2] = '/';
                    --EnemyX2;
                    board[EnemyY2][EnemyX2] = Enemy2;
                    continue;
                }
            }
    }
}


void EnemyMove3()
{
    char Finished = 'P';
    while (Finished != 'R')
    {

        if (Enemy3Dead == true)
        {
            EnemyX3 = 0;
            EnemyY3 = 0;

            break;
        }

        EnemyChoice3 = (rand() % 4);

        if (EnemyChoice3 == 0)
            {
                if (EnemyY3 == 1)
                    continue;

                --EnemyY3;

                if (board[EnemyY3][EnemyX3] == Wall)
                {
                    ++EnemyY3;
                    continue;
                }
                ++EnemyY3;

                board[EnemyY3][EnemyX3] = '/';
                --EnemyY3;
                board[EnemyY3][EnemyX3] = Enemy3;
                Finished = 'R';

                if (EnemyY3 == EnemyY && EnemyX3 == EnemyX || EnemyY3 == EnemyY2 && EnemyX3 == EnemyX2)
                {
                    board[EnemyY3][EnemyX3] = '/';
                    ++EnemyY3;
                    board[EnemyY3][EnemyX3] = Enemy3;
                    continue;
                }
            }

            else if (EnemyChoice3 == 1)
            {
                if (EnemyY3 == 8)
                    continue;

                ++EnemyY3;

                if (board[EnemyY3][EnemyX3] == Wall)
                {
                    --EnemyY3;
                    continue;
                }
                --EnemyY3;

                board[EnemyY3][EnemyX3] = '/';
                ++EnemyY3;
                board[EnemyY3][EnemyX3] = Enemy3;
                Finished = 'R';

                if (EnemyY3 == EnemyY && EnemyX3 == EnemyX || EnemyY3 == EnemyY2 && EnemyX3 == EnemyX2)
                {
                    board[EnemyY3][EnemyX3] = '/';
                    --EnemyY3;
                    board[EnemyY3][EnemyX3] = Enemy3;
                    continue;
                }
            }

            else if (EnemyChoice3 == 2)
            {
                if (EnemyX3 == 1)
                    continue;

                --EnemyX3;

                if (board[EnemyY3][EnemyX3] == Wall)
                {
                    ++EnemyX3;
                    continue;
                }
                ++EnemyX3;

                board[EnemyY3][EnemyX3] = '/';
                --EnemyX3;
                board[EnemyY3][EnemyX3] = Enemy3;
                Finished = 'R';

                if (EnemyY3 == EnemyY && EnemyX3 == EnemyX || EnemyY3 == EnemyY2 && EnemyX3 == EnemyX2)
                {
                    board[EnemyY3][EnemyX3] = '/';
                    ++EnemyX3;
                    board[EnemyY3][EnemyX3] = Enemy3;
                    continue;
                }
            }

            else if (EnemyChoice3 == 3)
            {
                if (EnemyX3 == 8)
                    continue;

                ++EnemyX3;

                if (board[EnemyY3][EnemyX3] == Wall)
                {
                    --EnemyX3;
                    continue;
                }
                --EnemyX3;

                board[EnemyY3][EnemyX3] = '/';
                ++EnemyX3;
                board[EnemyY3][EnemyX3] = Enemy3;
                Finished = 'R';

                if (EnemyY3 == EnemyY && EnemyX3 == EnemyX || EnemyY3 == EnemyY2 && EnemyX3 == EnemyX2)
                {
                    board[EnemyY3][EnemyX3] = '/';
                    --EnemyX3;
                    board[EnemyY3][EnemyX3] = Enemy3;
                    continue;
                }
            }
    }
}