// SamPatrickHarryMonahanDAC416AE1Project.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <iostream>
#include <Windows.h>
#include <iomanip>

#pragma region variables
using namespace std; //eliminates need to write std:: prefix each time
int mainMenuInput; //stores input for the main menu selection
int mainGameInput; //stores input for the main game

//----------------------------------------------------------------------

bool turnComplete = false;
bool playingGame = false;
bool playGame = false;
bool playerTurn = true;
bool playerHasSufficientEnergy = true;
bool playerHealedThisTurn = false;
bool enemyHasSufficientEnergy = true;
bool enemyHealedThisTurn = false;

//----------------------------------------------------------------------

int GenerateRandomNumber(int min, int max)
{
	srand((unsigned int)time(NULL)); //Creates seed base on system clock
	int lower = min, upper = max, range = (upper - lower) + 1; //calculates range
	int random = min + rand() % range; //generate a value within the specified range
	Sleep(1000);

	return random;
};

//----------------------------------------------------------------------

int maxHealth = 100;
int maxEnergy = 100;

float standardAttackValue = GenerateRandomNumber(1, 10);
float specialAttackValue = GenerateRandomNumber(2, 20);

float standardAttackCost = maxEnergy / 10;
float specialAttackCost = maxEnergy / 2;

//----------------------------------------------------------------------

float playerHealth = 100;
float playerEnergy = 50;

int playerHitChanceBase = 90;
int playerHitChanceModifier = 0;
int playerHitChance = playerHitChanceBase - playerHitChanceModifier;

int playerDodgeChanceBase = 50;
int playerDodgeChanceModifier = 0;
int playerDodgeChance = playerDodgeChanceBase - playerDodgeChanceModifier;

int playerRechargeRateBase = 9;
int playerRechargeRateModifier = 0;
int playerRechargeRate = playerRechargeRateBase - playerRechargeRateModifier;

bool playerHitSuccess;
float playerHit;

//----------------------------------------------------------------------

float enemyHealth = 100;
float enemyEnergy = 50;
bool enemyWantsToDodge = GenerateRandomNumber(1,2);

int enemyHitChanceBase = 50;
int enemyHitChanceModifier = 0;
int enemyHitChance = enemyHitChanceBase - enemyHitChanceModifier;

int enemyDodgeChanceBase = 50;
int enemyDodgeChanceModifier = 0;
int enemyDodgeChance = enemyDodgeChanceBase = enemyDodgeChanceModifier;

int enemyRechargeRateBase = 9;
int enemyRechargeRateModifier = 0;
int enemyRechargeRate = enemyRechargeRateBase - enemyRechargeRateModifier;


bool enemyHitSuccess;
float enemyHit;

//----------------------------------------------------------------------

#pragma endregion variables

#pragma region functions

#pragma region playerFunctions
//Calculate value for player healing
void healPlayer() {

	if ((playerEnergy / 2) >= (maxHealth - playerHealth)) {
		playerHealth = 100;
	}
	else {
		playerHealth = playerHealth + (playerEnergy / 2);
	}
}


void playerStandardAttack() {

	unsigned int randomNum = GenerateRandomNumber(0, 100);
	playerHitChanceBase = 80;

	if (playerEnergy < standardAttackCost) {
		playerHasSufficientEnergy = false;
		turnComplete = false;
		return;
	}
	else {
		if (randomNum >= playerHitChance) {
			playerHit = 0;
			playerHitSuccess = false;
			cout << "You missed!";
			Sleep(1000);
			turnComplete = true;
		}
		else {
			playerHit = standardAttackValue;
			playerHitSuccess = true;
			playerEnergy -= standardAttackCost;
			cout << "You hit!";
			Sleep(1000);
			turnComplete = true;
		}
	}

}

void playerSpecialAttack() {
	unsigned int randomNum = GenerateRandomNumber(0, 100);
	playerHitChanceBase = 50;
	if (playerEnergy < specialAttackCost) {
		playerHasSufficientEnergy = false;
		turnComplete = false;
		return;
	}
	else {
		if (randomNum >= playerHitChance) {
			playerHit = 0;
			playerHitSuccess = false;
			cout << "You missed!";
			Sleep(1000);
			turnComplete = true;
		}
		else {
			playerHit = specialAttackCost;
			playerHitSuccess = true;
			playerEnergy -= specialAttackCost;
			cout << "You hit!";
			Sleep(1000);
			turnComplete = true;
		}
	}
}
//Calculate player recharge rate
void playerRecharge() {

	enemyHitChanceModifier = enemyHitChanceBase / 10;

	if (playerEnergy + (playerRechargeRate * 4) >= maxEnergy) {
		playerEnergy = maxEnergy;
	}
	else {
		playerEnergy = playerEnergy + (playerRechargeRate * 4);
	}
	cout << "Recharging!";
	Sleep(1000);
	turnComplete = true;
}

void playerPassiveRecharge() {
	if (playerEnergy + (playerRechargeRate) >= maxEnergy) {
		playerEnergy = maxEnergy;
	}
	else {
		playerEnergy = playerEnergy + (playerRechargeRate);
	}
}

void playerDodge() {
	enemyHitChanceModifier = ((enemyHitChanceBase / 100) * 30);
	playerRechargeRateModifier = playerRechargeRateBase / 2;

}

#pragma endregion playerFunctions

#pragma region enemyFunctions

void enemyStandardAttack() {

	unsigned int randomNum = GenerateRandomNumber(0, 100);
	enemyHitChanceBase = 80;

	if (enemyEnergy < standardAttackCost) {
		enemyHasSufficientEnergy = false;
		turnComplete = false;
		return;
	}
	else {
		if (randomNum >= playerHitChance) {
			enemyHit = 0;
			enemyHitSuccess = false;
			cout << "They missed!";
			Sleep(1000);
			turnComplete = true;
		}
		else {
			enemyHit = standardAttackValue;
			enemyHitSuccess = true;
			enemyEnergy -= standardAttackCost;
			cout << "They hit!";
			Sleep(1000);
			turnComplete = true;
		}
	}

}

void enemySpecialAttack() {
	unsigned int randomNum = GenerateRandomNumber(0, 100);
	enemyHitChanceBase = 50;

	if (enemyEnergy < specialAttackCost) {
		enemyHasSufficientEnergy = false;
		turnComplete = false;
		return;
	}
	else {
		if (randomNum >= enemyHitChance) {
			enemyHit = 0;
			enemyHitSuccess = false;
			cout << "You missed!";
			Sleep(1000);
			turnComplete = true;
		}
		else {
			enemyHit = specialAttackCost;
			enemyHitSuccess = true;
			enemyEnergy -= specialAttackCost;
			cout << "You hit!";
			Sleep(1000);
			turnComplete = true;
		}
	}
}

//Calculate enemy recharge rate
void enemyRecharge() {
	playerHitChanceModifier = playerHitChanceBase / 10;
	if (enemyEnergy + (enemyRechargeRate * 4) >= maxEnergy) {
		enemyEnergy = maxEnergy;
	}
	else {
		enemyEnergy = enemyEnergy + (enemyRechargeRate * 4);
	}
	cout << "Enemy recharging!";
	Sleep(1000);
	turnComplete = true;
}

//Calculate value for enemy healing
void healEnemy() {

	if ((enemyEnergy / 2) >= (maxHealth - enemyHealth)) {
		enemyHealth = 100;
	}
	else {
		enemyHealth = enemyHealth + (enemyEnergy / 2);
	}
	cout << "Enemy healing!";
}

void enemyPassiveRecharge() {
	if (enemyEnergy + (enemyRechargeRate) >= maxEnergy) {
		enemyEnergy = maxEnergy;
	}
	else {
		enemyEnergy = enemyEnergy + (enemyRechargeRate);
	}
}

void enemyDodge() {
	playerHitChanceModifier = ((playerHitChanceBase / 100) * 30);
	enemyRechargeRateModifier = enemyRechargeRateBase / 2;

}
#pragma endregion enemyFunctions

#pragma endregion functions

int main()
{

	//game loop
	while (!playGame) {

		cout << "Welcome to the Not Pokemon - Please choose an option" << endl;
		cout << "1 - Play Game" << "\n" << "2 - Quit" << endl;

		cin >> mainMenuInput;



		if (mainMenuInput == 1) { //playing the game

			system("CLS");

			cout << "You chose to play" << "\n" << "\n" << "\n";
			while (!playingGame) {
				system("CLS");


				cout << setw(14) << "Player" << setw(50) << "Enemy" << endl;
				cout << "Health - " << setw(2) << playerHealth << setw(51) << enemyHealth << endl;
				cout << "Energy - " << setw(2) << playerEnergy << setw(51) << enemyEnergy << "\n" << endl;

				cout << "Attack Options - 1: Attack		2: Special Attack	 3: Recharge	 4: Heal	 5:Dodge" << "\n";
				if (playerTurn) {
					cout << "Its the players turn! Make your move." << "\n" << endl;
					turnComplete = false;
					playerTurn = false;
					enemyHealedThisTurn = false;

					while (!turnComplete) {


						cin >> mainGameInput;

						if (mainGameInput == 1) {//Player standard attack

							playerStandardAttack();
							enemyHealth = enemyHealth - playerHit;

							if ((playerEnergy - standardAttackCost) <= 0) {
								cout << "Insufficient energy, Try again!" << endl;
							}

						}
						if (mainGameInput == 2) {//Player special attack

							playerSpecialAttack();
							enemyHealth = enemyHealth - playerHit;

							if ((playerEnergy - specialAttackCost) <= 0) {
								cout << "Insufficient energy, Try again!" << endl;
							}

						}
						else if (mainGameInput == 3) { //Player recharge

							playerRecharge();
							enemyHitChance -= +10;

						}
						else if (mainGameInput == 4) { //Player healing
							if (playerHealedThisTurn == true) {
								cout << "You have already healed this turn!";
							}
							else {
								cout << "You are healing!";
								healPlayer();
								playerHealedThisTurn = true;
							}

						}
						else if (mainGameInput == 5) {
							playerDodge();
							cout << "Getting ready to dodge...";
							Sleep(1000);
							turnComplete = true;
						}
						playerPassiveRecharge();
					}
				}

				else {
					playerHealedThisTurn = false;
					//ENEMY TURN
					cout << "It is the enemies turn!" << endl;
					Sleep(1000);

					//ENEMY TURN LOGIC HERE
#pragma region enemyAI
				int lastEnemyInput;
					int enemyGameInput;

					if (enemyEnergy >= 50 && enemyHealth >= 10) {
						enemyGameInput = 2;
						cout << "A special attack!" << endl;
						Sleep(1000);
						}
						else if (enemyEnergy >= 10 && enemyHealth > 10) {
							enemyGameInput = 1;
						}
						else if (enemyEnergy < 10 && enemyHealth > 10) {
							enemyGameInput = 3;
						}
						else if (enemyHealth <= 10) {
							enemyGameInput = 4;
						}

						else if (enemyHealth <= 10 && enemyWantsToDodge == true) {
							enemyGameInput = 5;
						}
						else {
							cout << "oops";
						}

					if (lastEnemyInput = enemyGameInput && enemyHealedThisTurn == false) {
							enemyGameInput = 4;
						}
						else if (lastEnemyInput = enemyGameInput && enemyHealedThisTurn == true) {
							enemyGameInput = 3;
					}
					//----------------------------------------------------------------------
					lastEnemyInput = enemyGameInput;

#pragma endregion enemyAI

					//----------------------------------------------------------------------

#pragma region enemyInput
					if (enemyGameInput == 1) {//Enemy standard attack

						enemyStandardAttack();
						playerHealth = playerHealth - enemyHit;

						if (enemyHitSuccess == true && enemyHasSufficientEnergy == true) {
							cout << "You landed a hit! - Player Health at " << playerHealth << "\n";
							playerTurn = true;
							turnComplete = false;

						}
						else if (enemyHitSuccess == false && enemyHasSufficientEnergy == true) {
							cout << "You missed! - Player Health at " << playerHealth << "\n";
							playerTurn = true;
							turnComplete = false;

						}
						else {
							cout << "You dont have sufficient energy, please try again." << endl;
						}

					}
					else if(enemyGameInput == 2) {//Enemy special attack

					playerHealth = playerHealth - enemyHit;

						if ((enemyEnergy - specialAttackCost) <= 0) {
							cout << "Insufficient energy, Try again!" << endl;
						}


					}
					else if (mainGameInput == 3) { //Enemy recharge
						cout << "Enemy recharging!";
						enemyRecharge();
						playerHitChance -= +10;
						turnComplete = true;
						playerTurn = false;
					}
					else if (mainGameInput == 4) { //Enemy healing
						if (enemyHealedThisTurn == true) {
							cout << "Enemy already healed this turn!";
						}
						else {
							cout << "You are healing!";
							healEnemy();
							enemyHealedThisTurn = true;
						}

					}
					else if (mainGameInput == 5) {
						enemyDodge();
						cout << "The enemy attempts to dodge you!";
						Sleep(1000);
					}
					enemyPassiveRecharge();
					playerTurn = true;
				}
#pragma endregion enemyInput


			}

		}
else if (mainMenuInput == 2) {
	cout << "Thank you for playing" << endl;
	exit(0);
}
else {
	"There has been an error. Please give a valid input";
}
	}
	return 0;
	}