Entities.h

#include "Functions.h"

class Enemy
{
    bool Random;
    int Choice;

public:
    char Sign;
    int EnemyX, EnemyY;
    int Health;
    bool IsDead;
    void Move(int&, int&, int&);
    void AddToGame();
    void RandomSpawn();

    Enemy (char, int, int, vector<Enemy>&); //There are several different ways to spawn
    Enemy (int, int, vector<Enemy>&);       //enemies now
    Enemy (char, vector<Enemy>&);
    Enemy (vector<Enemy>&);
};

void Enemy::RandomSpawn()   //For the enemy constructors that don't have
{                           //an input for the X and Y coordinates
    bool ValidPosition = false;
    while (ValidPosition == false)
    {
        int randX, randY;
        randX = (rand() % 20);
        randY = (rand() % 20);

        if (randX <= 3 && randY <= 3 || board[randY][randX] == Wall || board[randY][randX] == Goal)
        {
            continue;
        }

        else
        {
            EnemyX = randX;
            EnemyY = randY;

            ValidPosition = true;
        }
    }
}

Enemy::Enemy (char enemySign, int enemyX, int enemyY, vector<Enemy>& Vect)
{
    Sign = enemySign;
    EnemyX = enemyX;
    EnemyY = enemyY;
    Health = 10;
    IsDead = false;

    Vect.push_back(*this);
}

Enemy::Enemy (int enemyX, int enemyY, vector<Enemy>& Vect)
{
    char Signs[] = {'!', '$', '%', '^', '&', '*', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
    char randomSign = (rand() % 32);

    Sign = Signs[randomSign];

    EnemyX = enemyX;
    EnemyY = enemyY;
    Health = 10;
    IsDead = false;

    Vect.push_back(*this);
}

Enemy::Enemy (char enemySign, vector<Enemy>& Vect)
{
    Sign = enemySign;
    RandomSpawn();
    Health = 10;
    IsDead = false;

    Vect.push_back(*this);
}

Enemy::Enemy(vector<Enemy>& Vect)
{
    char Signs[] = {'!', '$', '%', '^', '&', '*', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
    char randomSign = (rand() % 32);

    Sign = Signs[randomSign];
    Health = 10;
    IsDead = false;

    RandomSpawn();

    Vect.push_back(*this);
}

void Enemy::AddToGame() //More so to show them on the first round
{
    board[EnemyY][EnemyX] = Sign;
}

void Enemy::Move(int& pX, int& pY, int& pHealth)
{
    char Finished = 'P';

    bool UpTrue = true;
    bool DownTrue = true;
    bool LeftTrue = true;
    bool RightTrue = true;
    bool Picked = false;

    //Can't have dead enemies moving, can we?
    //"this" refers to the enemy currently using this member function
    while (Finished != 'R' && this->IsDead != true)
    {

        for (int i = 0; i < 10; i++)
        {
            if (board[this->EnemyY + i][this->EnemyX] == Wall || board[this->EnemyY + i][this->EnemyX] == Goal)
                DownTrue = false;

            if (board[this->EnemyY][this->EnemyX + i] == Wall || board[this->EnemyY][this->EnemyX + i] == Goal)
                RightTrue = false;

            if (board[this->EnemyY - i][this->EnemyX] == Wall || board[this->EnemyY - i][this->EnemyX] == Goal)
                UpTrue = false;

            if (board[this->EnemyY][this->EnemyX - i] == Wall || board[this->EnemyY][this->EnemyX - i] == Goal)
                LeftTrue = false;

            //Check if to move up
            if (this->EnemyY - i == pY && this->EnemyX == pX && UpTrue)
            {
                Choice = 0;
                Picked = true;
            }

            //Check if to move down
            if (this->EnemyY + i == pY && this->EnemyX == pX && DownTrue)
            {
                Choice = 1;
                Picked = true;
            }

            //Check if to move right
            if (this->EnemyY == pY && this->EnemyX + i == pX && RightTrue)
            {
                Choice = 2;
                Picked = true;
            }

            //Check if to move left
            if (this->EnemyY == pY && this->EnemyX - i == pX && LeftTrue)
            {
                Choice = 3;
                Picked = true;
            }
        }

        if (Picked == false)
            Choice = (rand() % 4);

        //up
        if (Choice == 0)
        {
            //A series of checks to see if the move is valid.
            //Same for all moves that the enemy takes
            --EnemyY;
            if (board[EnemyY][EnemyX] == Wall && Picked == true || board[EnemyY][EnemyX] == Goal && Picked == true)
            {
                ++EnemyY;
                break;
            }
            ++EnemyY;

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

            --EnemyY;
            if (EnemyY == pY && EnemyX == pX)
            {
                ++EnemyY;
                pHealth -= 1;
                break;
            }
            ++EnemyY;

            board[EnemyY][EnemyX] = Ground;
            --EnemyY;

            board[EnemyY][EnemyX] = Sign;
            Finished = 'R';
        }

        //down
        else if (Choice == 1)
        {
            ++EnemyY;
            if (board[EnemyY][EnemyX] == Wall && Picked == true || board[EnemyY][EnemyX] == Goal && Picked == true)
            {
                --EnemyY;
                break;
            }
            --EnemyY;


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

            ++EnemyY;
            if (EnemyY == pY && EnemyX == pX)
            {
                --EnemyY;
                pHealth -= 1;
                break;
            }
            --EnemyY;

            board[EnemyY][EnemyX] = Ground;
            ++EnemyY;

            board[EnemyY][EnemyX] = Sign;
            Finished = 'R';
        }

        //Right
        else if (Choice == 2)
        {
            ++EnemyX;
            if (board[EnemyY][EnemyX] == Wall && Picked == true || board[EnemyY][EnemyX] == Goal && Picked == true)
            {
                --EnemyX;
                break;
            }
            --EnemyX;

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

            ++EnemyX;
            if (EnemyY == pY && EnemyX == pX)
            {
                --EnemyX;
                pHealth -= 1;
                break;
            }
            --EnemyX;

            board[EnemyY][EnemyX] = Ground;
            ++EnemyX;

            board[EnemyY][EnemyX] = Sign;
            Finished = 'R';
        }

        //Left
        else if (Choice == 3)
        {
            --EnemyX;
            if (board[EnemyY][EnemyX] == Wall && Picked == true || board[EnemyY][EnemyX] == Goal && Picked == true)
            {
                ++EnemyX;
                break;
            }
            ++EnemyX;

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

            --EnemyX;
            if (EnemyY == pY && EnemyX == pX)
            {
                ++EnemyX;
                pHealth -= 1;
                break;
            }
            ++EnemyX;

            board[EnemyY][EnemyX] = Ground;
            --EnemyX;

            board[EnemyY][EnemyX] = Sign;
            Finished = 'R';
        }
    }
}

//=======================================================================================================================================================
//Player Class===========================================================================================================================================
//=======================================================================================================================================================

class Player
{
public:
    void Move();
    void AddToGame();
    void Attack(vector<Enemy>& Vect, vector<Enemy>::iterator& Iter);
    void GetLoot();
    char Choice;
    char Sign;

    int Gold;
    int Damage;
    int Range;
    int Health;
    int PlayerX, PlayerY;

    Player (char, int, int);
};

Player::Player (char a, int b, int c)
{
    Sign = a;
    PlayerX = b;
    PlayerY = c;
    Gold = 0;
    Health = 100;
    Range = 1;
    Damage = 1;
}

void Player::GetLoot()
{
    Gold += 500;
}

void Player::Attack(vector<Enemy>& Vect, vector<Enemy>::iterator& Iter)
{
    bool invalid = true;

    while (invalid)
    {
        //Up
        if (Choice == 'u')
        {
            //Pretty much the same as the move function, except it loops through
            //the enemy vector and sees if they are in the space in the attack
            //direction. If they are, set them to dead.
            for (int q = 1; q <= this->Range; q++)
            {
                if (board[PlayerY - q][PlayerX] == Wall)
                    break;

                if (board[PlayerY - q][PlayerX] != Wall)
                {
                    for (Iter = Vect.begin(); Iter != Vect.end(); Iter++)
                    {
                        if (this->PlayerY - q == Iter->EnemyY && this->PlayerX == Iter->EnemyX)
                        {
                            Iter->Health -= this->Damage;

                            if (Iter->Health <= 0)
                            {
                                Iter->IsDead = true;
                                this->GetLoot();
                                board[Iter->EnemyY][Iter->EnemyX] = ' ';
                                Iter->EnemyX = 0;
                                Iter->EnemyY = 0;
                            }
                        }
                    }
                }
            }
            break;
        }

        //Down
        else if (Choice == 'j')
        {
            for (int q = 1; q <= this->Range; q++)
            {
                if (board[PlayerY + q][PlayerX] == Wall)
                    break;

                if (board[PlayerY + q][PlayerX] != Wall)
                {
                    for (Iter = Vect.begin(); Iter != Vect.end(); Iter++)
                    {
                        if (this->PlayerY + q == Iter->EnemyY && this->PlayerX == Iter->EnemyX)
                        {
                            Iter->Health -= this->Damage;

                            if (Iter->Health <= 0)
                            {
                                Iter->IsDead = true;
                                this->GetLoot();
                                board[Iter->EnemyY][Iter->EnemyX] = ' ';
                                Iter->EnemyX = 0;
                                Iter->EnemyY = 0;
                            }
                        }
                    }
                }
            }
            break;
        }

        //Left
        else if (Choice == 'h')
        {
            for (int q = 1; q <= this->Range; q++)
            {
                if (board[PlayerY][PlayerX - q] == Wall)
                    break;

                if (board[PlayerY][PlayerX - q] != Wall)
                {
                    for (Iter = Vect.begin(); Iter != Vect.end(); Iter++)
                    {
                        if (this->PlayerY == Iter->EnemyY && this->PlayerX - q == Iter->EnemyX)
                        {
                            Iter->Health -= this->Damage;

                            if (Iter->Health <= 0)
                            {
                                Iter->IsDead = true;
                                this->GetLoot();
                                board[Iter->EnemyY][Iter->EnemyX] = ' ';
                                Iter->EnemyX = 0;
                                Iter->EnemyY = 0;
                            }
                        }
                    }
                }
            }
            break;
        }

        //Right
        else if (Choice == 'k')
        {
            for (int q = 1; q <= this->Range; q++)
            {
                if (board[PlayerY][PlayerX + q] == Wall)
                    break;

                if (board[PlayerY][PlayerX + q] != Wall)
                {
                    for (Iter = Vect.begin(); Iter != Vect.end(); Iter++)
                    {
                        if (this->PlayerY == Iter->EnemyY && this->PlayerX + q == Iter->EnemyX)
                        {
                            Iter->Health -= this->Damage;

                            if (Iter->Health <= 0)
                            {
                                Iter->IsDead = true;
                                this->GetLoot();
                                board[Iter->EnemyY][Iter->EnemyX] = ' ';
                                Iter->EnemyX = 0;
                                Iter->EnemyY = 0;
                            }
                        }
                    }
                }
            }
            break;
        }
    }
}

void Player::AddToGame()//More so that your character is visible on the first round
{
    board[PlayerY][PlayerX] = Sign;
}


void Player::Move()
{
    bool invalid = true;

    while (invalid)
    {
        //up
        if (Choice == 'w')
        {
            //A series of checks to see if the move is valid.
            --PlayerY;
            if (board[PlayerY][PlayerX] == Wall)
            {
                ++PlayerY;
                break;
            }
            ++PlayerY;

            --PlayerY;
            if (board[PlayerY][PlayerX] == Goal)
            {
                ++PlayerY;
                Win = true;
                break;
            }
            ++PlayerY;

            board[PlayerY][PlayerX] = Ground;
            --PlayerY;

            board[PlayerY][PlayerX] = Sign;
            invalid = false;
        }

        //down
        else if (Choice == 's')
        {
            ++PlayerY;
            if (board[PlayerY][PlayerX] == Wall)
            {
                --PlayerY;
                break;
            }
            --PlayerY;

            ++PlayerY;
            if (board[PlayerY][PlayerX] == Goal)
            {
                --PlayerY;
                Win = true;
                break;
            }
            --PlayerY;

            board[PlayerY][PlayerX] = Ground;
            ++PlayerY;

            board[PlayerY][PlayerX] = Sign;
            invalid = false;
        }

        //Right
        else if (Choice == 'd')
        {
            ++PlayerX;
            if (board[PlayerY][PlayerX] == Wall)
            {
                --PlayerX;
                break;
            }
            --PlayerX;

            ++PlayerX;
            if (board[PlayerY][PlayerX] == Goal)
            {
                --PlayerX;
                Win = true;
                break;
            }
            --PlayerX;

            board[PlayerY][PlayerX] = Ground;
            ++PlayerX;

            board[PlayerY][PlayerX] = Sign;
            invalid = false;
        }

        //Left
        else if (Choice == 'a')
        {
            --PlayerX;
            if (board[PlayerY][PlayerX] == Wall)
            {
                ++PlayerX;
                break;
            }
            ++PlayerX;

            --PlayerX;
            if (board[PlayerY][PlayerX] == Goal)
            {
                ++PlayerX;
                Win = true;
                break;
            }
            ++PlayerX;

            board[PlayerY][PlayerX] = Ground;
            --PlayerX;

            board[PlayerY][PlayerX] = Sign;
            invalid = false;
        }
    }
}