SimpleDungeon.cpp

// SimpleDungeon.cpp : Simplified version of D20 system 


#include "stdafx.h"
#include <iostream>
#include <string>
#include <cstdlib>
#include <random>
#include <ctime>


using namespace std;


//*************************************************************************************
// Functions
//
//*************************************************************************************

// Dice function
int roll(int di) {
	default_random_engine generator((int)time(NULL));
	uniform_int_distribution<int> dice(1, di);
	return dice(generator);
}// end Function(roll)


int getStatMod(int stat) {
	if (stat >= 28)
		return 9;
	else if (stat >= 26 && stat < 28)
		return 8;
	else if (stat >= 24 && stat < 26)
		return 7;
	else if (stat >= 22 && stat < 26)
		return 6;
	else if (stat >= 20 && stat < 22)
		return 5;
	else if (stat >= 18 && stat < 20)
		return 4;
	else if (stat >= 16 && stat < 18)
		return 3;
	else if (stat >= 14 && stat < 16)
		return 2;
	else if (stat >= 12 && stat < 14)
		return 1;
	else if (stat >= 10 && stat < 12)
		return 0;
	else if (stat >= 8 && stat < 10)
		return -1;
	else if (stat >= 6 && stat < 8)
		return -2;
	else if (stat >= 4 && stat < 6)
		return -3;
	else if (stat >= 2 && stat < 4)
		return -4;
	else if (stat >= 0 && stat < 2)
		return -5;
	else if (stat >= -2 && stat < 0)
		return -6;
	else if (stat >= -4 && stat < -2)
		return -8;
	else if (stat >= -6 && stat < -4)
		return -9;
	else 
		return -10;
}// end getStatMod(int)



 //****************************************************************************************
 // User Input Functions
 //
 //****************************************************************************************

int getPositiveInt(string prompt, int maxValue) {
	string userInput;
	int number = 0;
	do {
		cout << prompt;
		cin >> userInput;
		try {
			number = stoi(userInput);
		}// end try
		catch (invalid_argument) {
			cout << "Invalid entry typed.";
		}// end catch
	} while (number < 1 || number > maxValue);
	return number;
}// end getPositiveInt(string, int)


int getPositiveIntOrGoBack(string prompt, int maxValue) {
	string userInput;
	int number = 0;
	do {
		cout << prompt;
		cin >> userInput;
		try {
			number = stoi(userInput);
		}// end try
		catch (invalid_argument) {
			cout << "Invalid entry typed.";
		}// end catch
	} while ((number < 1 && number != -1) || number > maxValue);
	return number;
}// end getPositiveIntOrGoBack(string, int)



//*************************************************************************************
// Equipment Classes
//
//*************************************************************************************

class Item {
protected:
	string name;
	string type;
	long value;
public:
	Item();
	Item(string, long);
	~Item();
	string getName() { return name; }
	string getType() { return type; }
	long getValue() { return value; }
	string toString();
};// end class Item

Item::Item() {

}// end constructor(Item())

Item::~Item() {

}// end destructor(~Item())

Item::Item(string name, long value) {
	this->name = name;
	type = "Item";
	this->value = value;
}// end constructor(Item(string))

string Item::toString() {
	return "Name: " + name + "\nValue: " + to_string(value) + "\n\n";
}// end toString()


// Quest Item
class QuestItem : public Item {
public:
	QuestItem();
	~QuestItem();
	QuestItem(string);
};// end class QuestItem

QuestItem::QuestItem() {
	type = "NULL";
}// end constructor(QuestItem())

QuestItem::~QuestItem() {

}// end destructor(~QuestItem())

QuestItem::QuestItem(string name) : Item(name, 0) {
	type = "Quest";
}// end constructor(QuestItem())


// Armor
// Class Armor(Non-Magic)

class Armor : public Item {
protected :
	int defense;
	bool isMagic;
	string armorType;
	int strBonus;
	int dexBonus;
	int conBonus;
	int defenseBonus;
	int attackBonus;
	int hpBonus;
public :
	Armor();
	Armor(string, int, string, long);
	~Armor();
	int getDefense() { return defense; }
	bool isArmorMagic() { return isMagic; }
	string getArmorType() { return armorType; }
	int getStrBonus() { return strBonus; }
	int getDexBonus() { return dexBonus; }
	int getConBonus() { return conBonus; }
	int getDefenseBonus() { return defenseBonus; }
	int getAttackBonus() { return attackBonus; }
	int getHpBonus() { return hpBonus; }
	string toString();
};// end class Armor

Armor::Armor(string name, int defense, string type, long value) : Item(name, value) {
	this->defense = defense;
	armorType = type;
	isMagic = false;
	strBonus = 0;
	dexBonus = 0;
	conBonus = 0;
	defenseBonus = 0;
	attackBonus = 0;
	hpBonus = 0;
	type = "Armor";
}// end constructor(Armor)

Armor::Armor() {

}// end constructor(Armor())

Armor::~Armor() {

}// end destructor(Armor)

string Armor::toString() {
	return "Name: " + name  + "\nDefense: " + to_string(defense) +
		"\nType: " + armorType + "\n";
}// end toString


// Class MagicArmor(Magic)
class MagicArmor : public Armor {
public:
	MagicArmor::MagicArmor();
	MagicArmor(string, int, string, long, int, int, int, int, int, int);
	~MagicArmor();
};// end class MagicArmor

MagicArmor::MagicArmor() {

}// end constructor(MagicArmor())

MagicArmor::MagicArmor(string name, int defense, string type, long value, int strBonus, int conBonus, int dexBonus,
	int defenseBonus, int attackBonus, int hpBonus) : Armor(name, defense, type, value) {
	this->strBonus = strBonus;
	this->dexBonus = dexBonus;
	this->conBonus = conBonus;
	this->defenseBonus = defenseBonus;
	this->attackBonus = attackBonus;
	this->hpBonus = hpBonus;
	isMagic = true;
}// end constructor(MagicArmor)

MagicArmor::~MagicArmor() {

}// end deconstructor(~MagicArmor())


// Weapons
// Class Weapon(Non-Magic)
class Weapon : public Item {
protected :
	int damage;
	bool isMagic;
	int strBonus;
	int dexBonus;
	int conBonus;
	int defenseBonus;
	int attackBonus;
	int hpBonus;
	string damageType;
public :
	Weapon();
	Weapon(string, int, string, long);
	~Weapon();
	int getDamage() { return damage; }
	bool isWeaponMagic() { return isMagic; }
	string getDamageType() { return damageType; }
	int getStrBonus() { return strBonus; }
	int getDexBonus() { return dexBonus; }
	int getConBonus() { return conBonus; }
	int getDefenseBonus() { return defenseBonus; }
	int getAttackBonus() { return attackBonus; }
	int getHpBonus() { return hpBonus; }
	string toString();
};// end class Weapon

Weapon::Weapon() {

}// end constructor(Weapon())

Weapon::Weapon(string name, int damage, string type, long value) : Item(name, value) {
	this->damage = damage;
	damageType = type;
	isMagic = false;
	strBonus = 0;
	dexBonus = 0;
	conBonus = 0;
	defenseBonus = 0;
	attackBonus = 0;
	hpBonus = 0;
	this->type = "Weapon";
}// end constructor(Weapon(string. int, string))

Weapon::~Weapon() {

}// end destructor(~Weapon())

string Weapon::toString() {
	return "Name: " + name + "\nDamage: " + to_string(damage) +
		"\nType: " + damageType + "\n";
}// end toString


// Class MagicWeapon(Magic)
class MagicWeapon : public Weapon {

public :
	MagicWeapon();
	MagicWeapon(string, int, string, long, int, int, int, int, int, int);
	~MagicWeapon();
};// end class MagicWeapon

MagicWeapon::MagicWeapon() {

}// end constructor(MagicWeapon())

MagicWeapon::MagicWeapon(string name, int damage, string type, long value, int strBonus, int conBonus, int dexBonus,
	int defenseBonus, int attackBonus, int hpBonus) : Weapon(name, damage, type, value) {
	this->strBonus = strBonus;
	this->dexBonus = dexBonus;
	this->conBonus = conBonus;
	this->defenseBonus = defenseBonus;
	this->attackBonus = attackBonus;
	this->hpBonus = hpBonus;
	isMagic = true;
}// end constructor(MagicWeapon)

MagicWeapon::~MagicWeapon() {

}// end destructor(~MagicWeapon)



//*********************************************************************************************
// Potion Class
//
//*********************************************************************************************

class Potion : public Item {
private:
	int amountHealed;
public:
	Potion(string, int, long);
	Potion();
	~Potion();
	int getAmountHealed() { return amountHealed; }
	string toString();
};// end class Potion

Potion::Potion() {

}// end constructor(Potion())

Potion::~Potion() {

}// end destructor(~Potion)

Potion::Potion(string name, int amountHealed, long value) : Item(name, value) {
	this->amountHealed = amountHealed;
	type = "Potion";
}// end constructor(Potion(string int))

string Potion::toString() {
	return "Name: " + name + "\nAmount Healed: " + to_string(amountHealed) + "\n";
}// end toString()



//*********************************************************************************************
// Inventory Class
//
//*********************************************************************************************

class Inventory {
protected:
	Potion potions[100];
	int potionsIndex;
	Armor armors[100];
	int armorsIndex;
	Weapon weapons[100];
	int weaponsIndex;
	QuestItem questItems[100];
	int questItemsIndex;
public:
	Inventory();
	~Inventory();
	void add(Potion potion) { potions[++potionsIndex] = potion; }
	void remove(Potion);
	int getPotionsIndex() { return potionsIndex; }
	Potion* getPotions() { return potions; }
	Potion selectPotion();
	void add(Armor armor) { armors[++armorsIndex] = armor; }
	int getArmorIndex() { return armorsIndex; }
	Armor* getArmor() { return armors; }
	void remove(Armor);
	Armor selectArmor();
	void add(Weapon weapon) { weapons[++weaponsIndex] = weapon; }
	int getWeaponsIndex() { return weaponsIndex; }
	Weapon* getWeapons() { return weapons; }
	void remove(Weapon);
	Weapon selectWeapon();
	QuestItem* getQuestItems() { return questItems; }
	int getQuestItemsIndex() { return questItemsIndex; }
	void remove(QuestItem);
	void add(QuestItem questItem) { questItems[++questItemsIndex] = questItem; }
	void displayInventory();
	void displayWeapons();
	void displayArmor();
	void displayPotions();
};// end class Inventory

Inventory::Inventory() {
	potionsIndex = -1;
	armorsIndex = -1;
	weaponsIndex = -1;
	questItemsIndex = -1;
}// end constructor(Inventory())

Inventory::~Inventory() {

}// end destructor(~Inventory())

void Inventory::remove(Potion potion) {
	int indexPotionToRemove = -1;
	for (int i = 0; i <= potionsIndex; i++) {
		if (potions[i].getName() == potion.getName())
			indexPotionToRemove = i;
	}// end for
	if (indexPotionToRemove != potionsIndex) {
		for (int i = indexPotionToRemove; i <= potionsIndex; i++) {
			potions[i] = potions[i + 1];
		}// end for
	}// end if
	potionsIndex--;
}// end removePotion(Potion)

void Inventory::displayPotions() {
	for (int i = 0; i <= potionsIndex; i++) {
		cout << "\n" << i + 1 << ".\n" << potions[i].toString();
	}// end for
	cout << endl;
}// end displayPotions()

Potion Inventory::selectPotion() {
	int choice;
	cout << "Choose a potion to use:\n";
	displayPotions();
	choice = getPositiveInt("Enter the number of the potion: ", potionsIndex + 1);
	return potions[choice - 1];
}// end selectPotion

void Inventory::displayArmor() {
	for (int i = 0; i <= armorsIndex; i++) {
		cout << "\n" << i + 1 << ".\n" << armors[i].toString();
	}// end for
	cout << endl;
}// end displayArmor()

Armor Inventory::selectArmor() {
	int choice;
	cout << "Select a set of armor:\n";
	displayArmor();
	choice = getPositiveInt("Enter the number of the set of armor: ", armorsIndex + 1);
	return armors[choice - 1];
}// end selectArmor()

void Inventory::remove(Armor armor) {
	int indexArmorToRemove = -1;
	for (int i = 0; i <= armorsIndex; i++) {
		if (armors[i].getName() == armor.getName())
			indexArmorToRemove = i;
	}// end for
	if (indexArmorToRemove != armorsIndex) {
		for (int i = indexArmorToRemove; i <= armorsIndex; i++) {
			armors[i] = armors[i + 1];
		}// end for
	}// end if
	armorsIndex--;
}// end removeArmor(Armor)

void Inventory::displayWeapons() {
	for (int i = 0; i <= weaponsIndex; i++) {
		cout << "\n" << i + 1 << ".\n" << weapons[i].toString();
	}// end for
	cout << endl;
}// end displayWeapons()

Weapon Inventory::selectWeapon() {
	int choice;
	cout << "Select a weapon:\n";
	displayWeapons();
	choice = getPositiveInt("Enter the number of the weapon: ", weaponsIndex + 1);
	return weapons[choice - 1];
}// end selectWeapon()

void Inventory::remove(Weapon weapon) {
	int indexWeaponToRemove = -1;
	for (int i = 0; i <= weaponsIndex; i++) {
		if (weapons[i].getName() == weapon.getName())
			indexWeaponToRemove = i;
	}// end for
	if (indexWeaponToRemove != weaponsIndex) {
		for (int i = indexWeaponToRemove; i <= weaponsIndex; i++) {
			weapons[i] = weapons[i + 1];
		}// end for
	}// end if
	weaponsIndex--;
}// end removeWeapon(Weapon)

void Inventory::displayInventory() {
	cout << "\nInventory\n\n";
	for (int i = 0; i <= armorsIndex; i++) {
		cout << armors[i].toString() << endl << endl;
	}// end for
	for (int i = 0; i <= weaponsIndex; i++) {
		cout << weapons[i].toString() << endl << endl;
	}// end for
	for (int i = 0; i <= potionsIndex; i++) {
		cout << potions[i].toString() << endl << endl;
	}// end for
	for (int i = 0; i <= questItemsIndex; i++) {
		cout << questItems[i].toString() << endl << endl;
	}// end for
}// end displayInventory()

void Inventory::remove(QuestItem questItem) {
	int indexQuestItemToRemove = -1;
	for (int i = 0; i <= questItemsIndex; i++) {
		if (questItems[i].getName() == questItem.getName())
			indexQuestItemToRemove = i;
	}// end for
	if (indexQuestItemToRemove != questItemsIndex) {
		for (int i = indexQuestItemToRemove; i <= questItemsIndex; i++) {
			questItems[i] = questItems[i + 1];
		}// end for
	}// end if
	questItemsIndex--;
}// end removeQuestItem(QuestItem)



//******************************************************************************************
// Monster Types (Classes)
//
//******************************************************************************************

// Monster Class
class Monster {
protected :
	string race;
	int hitPoints;
	int maxHitPoints;
	int strength;
	int dexterity;
	int constitution;
	int level;
	int hitPointMod;
	Weapon weapon;
	Armor armor;
public :
	Monster();
	Monster(int, int, int, int, int, Armor armor, Weapon weapon);
	~Monster();
	int getHitPoints() { return hitPoints; }
	int getMaxHitPoints() { return maxHitPoints; }
	virtual string getRace() { return race; }
	int getAttack() {
		return level + getStatMod(getFullStrength()) + getItemsAttackBonus();
	}// end getAttack()
	int getDefense() {
		return 10 + getStatMod(getFullDexterity()) + armor.getDefense() + getItemsDefenseBonus();
	}// end getDefense()
	int getDexMod() { return dexterity; }
	int getStrength() { return strength; }
	int getConstitution() { return constitution; }
	int getLevel() { return level; }
	int getHitPointMod() { return hitPointMod; }
	Weapon getWeapon() { return weapon; }
	Armor getArmor() { return armor; }
	string toString();
	void takeDamage(int dmg) { hitPoints -= dmg; }
	bool isAlive() { return hitPoints > 0; }
	void heal(int);
	string getStatus();
	int getFullStrength() { return strength + armor.getStrBonus() + weapon.getStrBonus(); }
	int getFullConstitution() { return constitution + armor.getConBonus() + weapon.getConBonus(); }
	int getFullDexterity() { return dexterity + armor.getDexBonus() + weapon.getDexBonus(); }
	int getItemsHitPointBonus() { return weapon.getHpBonus() + armor.getHpBonus(); }
	int getItemsDefenseBonus() { return weapon.getDefenseBonus() + armor.getDefenseBonus(); }
	int getItemsAttackBonus() { return weapon.getAttackBonus() + armor.getAttackBonus(); }
};// end class Monster

string Monster::getStatus() {
	return race + "\nLevel: " + to_string(level) + "\nHit Points: " + to_string(hitPoints);
}// end getStatus()

string Monster::toString() {
	return race + "\nHit Points: " + to_string(maxHitPoints) + "\nArmor Class: " +
		to_string(getDefense()) + "\nLevel: " + to_string(level) + "\nStrength: " +
		to_string(getFullStrength()) + "\nConstitution: " + to_string(getFullConstitution()) +
		"\nDexterity: " + to_string(getFullDexterity()) + "\n\nArmor\n" + armor.toString() + 
		"\n\nWeapon\n" + weapon.toString() + "\n";
}// end toString()

Monster::~Monster() {

}// end destructor(~Monster)

Monster::Monster() {
	
}// end constructor(Monster)

Monster::Monster(int hitPointMod, int strength, int dexterity, int constitution, int level,
	Armor armor, Weapon weapon) {
	this->hitPointMod = hitPointMod;
	this->strength = strength;
	this->dexterity = dexterity;
	this->constitution = constitution;
	this->level = level;
	this->armor = armor;
	this->weapon = weapon;
	maxHitPoints = hitPointMod + getStatMod(getFullConstitution());
	// Generate a random number between 1 and the hitPointMod and add it to the 
	// monsters hitpoints for every level.
	for (int i = 1; i < level; i++) {
		maxHitPoints += roll(hitPointMod) + getStatMod(getFullConstitution());
	}// end for
	maxHitPoints += getItemsHitPointBonus();
	hitPoints = maxHitPoints;
}// end constructor(Monster)

void Monster::heal(int health) {
	if (hitPoints + health <= maxHitPoints)
		hitPoints += health;
	else
		hitPoints = maxHitPoints;
}// end heal(int)


// Class Goblin
class Goblin : public Monster {
public:
	Goblin(int, Armor, Weapon);
};// end class Goblin

Goblin::Goblin(int level, Armor armor, Weapon weapon) : Monster(6, 10, 10, 10, level, armor, weapon) {
	race = "Goblin";
}// end constructor(Goblin(int, Armor, Weapon))



 //*********************************************************************************************
 // Character Races
 //
 //********************************************************************************************

 // Race Base Class
class Race {
protected:
	string name;
	int strBonus;
	int dexBonus;
	int conBonus;
	int defenseBonus;
	int attackBonus;
public:
	Race();
	~Race();
	string getName() { return name; }
	int getStrBonus() { return strBonus; }
	int getDexBonus() { return dexBonus; }
	int getConBonus() { return conBonus; }
	int getDefenseBonus() { return defenseBonus; }
	int getAttackBonus() { return attackBonus; }
};// end class Race

Race::Race() {

}// end constructor(Race())

Race::~Race() {

}// end destructor(~Race())


// Human
class Human : public Race {
public:
	Human();
	~Human();
};// end class Human

Human::Human() {
	name = "Human";
	strBonus = 2;
	dexBonus = 0;
	conBonus = 2;
	defenseBonus = 0;
	attackBonus = 0;
}// end constructor(Human())

Human::~Human() {

}// end destructor(~Human())


  // Dwarf
class Dwarf : public Race {
public:
	Dwarf();
	~Dwarf();
};// end class Dwarf

Dwarf::Dwarf() {
	name = "Dwarf";
	strBonus = 0;
	dexBonus = 0;
	conBonus = 2;
	defenseBonus = 1;
	attackBonus = 0;
}// end constructor(Human())

Dwarf::~Dwarf() {

}// end destructor(~Dwarf())


// Half-Orc
class HalfOrc : public Race {
public:
	HalfOrc();
	~HalfOrc();
};// end class HalfOrc

HalfOrc::HalfOrc() {
	name = "Half-Orc";
	strBonus = 2;
	conBonus = 1;
	dexBonus = -2;
	defenseBonus = 0;
	attackBonus = 1;
}// end constructor(HalfOrc())

HalfOrc::~HalfOrc() {

}// end destructor(~HalfOrc())


// Halfling
class Halfling : public Race {
public:
	Halfling();
	~Halfling();
};// end class Halfling

Halfling::Halfling() {
	name = "Halfling";
	strBonus = 0;
	conBonus = 0;
	dexBonus = 2;
	defenseBonus = 0;
	attackBonus = 1;
}// end constructor(Halfling())

Halfling::~Halfling() {

}// end destructor(~Halfling())


// Gnome
class Gnome : public Race {
public:
	Gnome();
	~Gnome();
};// end class Gnome

Gnome::Gnome() {
	name = "Gnome";
	strBonus = -1;
	conBonus = 2;
	dexBonus = 2;
	defenseBonus = 0;
	attackBonus = 0;
}// end constructor(Gnome())

Gnome::~Gnome() {

}// end destructor(~Gnome())


// Drow
class Drow : public Race {
public:
	Drow();
	~Drow();
};// end class Drow

Drow::Drow() {
	name = "Drow";
	strBonus = -1;
	conBonus = -1;
	dexBonus = 2;
	defenseBonus = 0;
	attackBonus = 1;
}// end constructor(Drow())

Drow::~Drow() {

}// end destructor(~Drow())


// Elf
class Elf : public Race {
public:
	Elf();
	~Elf();
};// end class Elf

Elf::Elf() {
	name = "Elf";
	strBonus = -1;
	conBonus = -1;
	dexBonus = 2;
	defenseBonus = 0;
	attackBonus = 1;
}// end constructor(Elf())

Elf::~Elf() {

}// end destructor(~Elf())


// Half-Elf
class HalfElf : public Race {
public:
	HalfElf();
	~HalfElf();
};// end class HalfElf

HalfElf::HalfElf() {
	name = "HalfElf";
	strBonus = 1;
	conBonus = 1;
	dexBonus = 1;
	defenseBonus = 0;
	attackBonus = 0;
}// end constructor(HalfElf())

HalfElf::~HalfElf() {

}// end destructor(~HalfElf())



 //**********************************************************************************************
 // Reward Class
 //
 //**********************************************************************************************

class Reward {
protected:
	Weapon weapon1;
	bool hasWeapon1;
	Weapon weapon2;
	bool hasWeapon2;
	Armor armor1;
	bool hasArmor1;
	Armor armor2;
	bool hasArmor2;
	Potion potion;
	bool hasPotion;
	int numberOfPotions;
	int gold;
	bool hasRewardBeenGiven;
public:
	Reward();
	~Reward();
	Weapon getWeapon1() { return weapon1; }
	Weapon getWeapon2() { return weapon2; }
	Armor getArmor1() { return armor1; }
	Armor getArmor2() { return armor2; }
	Potion getPotion() { return potion; }
	bool getHasWeapon1() { return hasWeapon1; }
	bool getHasWeapon2() { return hasWeapon2; }
	bool getHasArmor1() { return hasArmor1; }
	bool getHasArmor2() { return hasArmor2;	}
	bool getHasPotion() { return hasPotion; }
	int getNumberOfPotions() { return numberOfPotions; }
	int getGold() { return gold; }
	bool getHasRewardBeenGiven() { return hasRewardBeenGiven; }
	void setHasRewardBeenGivenTrue() { hasRewardBeenGiven = true; }
	void addGold(int gold) { this->gold += gold; }
	void removePotion() { hasPotion = false; }
	void changePotion(Potion potion) { this->potion = potion; }
	void changeArmor1(Armor armor) { armor1 = armor; }
	void changeArmor2(Armor armor) { armor2 = armor; }
	void changeWeapon1(Weapon weapon) { weapon1 = weapon; }
	void changeWeapon2(Weapon weapon) { weapon2 = weapon; }
	void removeWeapon1() { hasWeapon1 = false; }
	void removeWeapon2() { hasWeapon2 = false; }
	void removeArmor1() { hasArmor1 = false; }
	void removeArmor2() { hasArmor2 = false; }
	void addWeapon(Weapon);
	void addArmor(Armor);
	void addPotion(Potion);
	string toString();
};// end class Reward

Reward::Reward() {
	hasArmor1 = false;
	hasArmor2 = false;
	hasWeapon1 = false;
	hasWeapon2 = false;
	hasPotion = false;
	numberOfPotions = 0;
	gold = 0;
	hasRewardBeenGiven = false;
}// end constructor(Reward())

Reward::~Reward() {

}// end destructor(~Reward())

void Reward::addWeapon(Weapon weapon) {
	if (!hasWeapon1) {
		this->weapon1 = weapon;
		hasWeapon1 = true;
	}// end if
	else if (!hasWeapon2) {
		this->weapon2 = weapon;
		hasWeapon2 = true;
	}// end else if
}// end addWeapon(Weapon)

void Reward::addArmor(Armor armor) {
	if (!hasArmor1) {
		armor1 = armor;
		hasArmor1 = true;
	}// end if
	else if (!hasArmor2) {
		armor2 = armor;
		hasArmor2 = true;
	}// end else if
}// end addArmor(Armor)

void Reward::addPotion(Potion potion) {
	if (!hasPotion) {
		this->potion = potion;
		numberOfPotions++;
		hasPotion = true;
	}// end if
	else if (this->potion.getName() == potion.getName()) {
		numberOfPotions++;
	}// end else if
}// end addPotion()

string Reward::toString() {
	string output;
	output += "\nReward:\n\nGold: " + to_string(gold) + "\n\n";
	if (hasWeapon1 && hasWeapon2)
		output += "Weapon:\n" + weapon1.toString() + "OR\n" + weapon2.toString() + "\n";
	else if (hasWeapon1)
		output += "Weapon:\n" + weapon1.toString() + "\n";
	else if (hasWeapon2)
		output += "Weapon:\n" + weapon2.toString() + "\n";

	if (hasArmor1 && hasArmor2)
		output += "Armor:\n" + armor1.toString() + "OR\n" + armor2.toString() + "\n";
	else if (hasArmor1)
		output += "Armor:\n" + armor1.toString() + "\n";
	else if (hasArmor2)
		output += "Armor:\n" + armor2.toString() + "\n";

	if (hasPotion)
		output += "Number of Potions: " + to_string(numberOfPotions) + "\nPotion:\n" + potion.toString() + "\n";
	return output;
}// end toString()



 //**********************************************************************************************
 // Quest Class
 //
 //**********************************************************************************************

class Quest {
protected:
	bool isQuestKill;
	bool isQuestCollect;
	string dialogue;
	int killNumber;
	int killCount;
	QuestItem itemToCollect;
	int numberOfItemsToCollect;
	int itemCount;
	Monster monsterToKill;
	bool isQuestComplete;
	Reward reward;
public:
	Quest();
	~Quest();
	Quest(string, int, Monster&, Reward);
	Quest(string, QuestItem, Reward);
	Quest(string, int, QuestItem, Reward);
	Reward& getReward() { return reward; }
	void setIsQuestCompleteTrue() { isQuestComplete = true; }
	bool getIsQuestKill() { return isQuestKill; }
	bool getIsQuestCollect() { return isQuestCollect; }
	string getDialogue() { return dialogue; }
	int getKillNumber() { return killNumber; }
	int getKillCount() { return killCount; }
	bool getIsQuestComplete() { return isQuestComplete; }
	QuestItem& getItemToCollect() { return itemToCollect; }
	int getItemCount() { return itemCount; }
	Monster& getMonsterToKill() { return monsterToKill; }
	int getNumberOfItemsToCollect() { return numberOfItemsToCollect; }
	void updateKillCount();
	void updateItemCount();
	void checkMonsterKilled(Monster&);
	void checkQuestItem(QuestItem);
};// end class Quest

Quest::Quest() {
	isQuestKill = false;
	isQuestCollect = false;
	isQuestComplete = false;
}// end constructor(Quest())

Quest::~Quest() {

}// end destructor(~Quest())

Quest::Quest(string dialogue, int killNumber, Monster& monsterToKill, Reward reward) {
	this->dialogue = dialogue;
	this->killNumber = killNumber;
	this->monsterToKill = monsterToKill;
	this->reward = reward;
	isQuestKill = true;
	isQuestCollect = false;
	killCount = 0;
	isQuestComplete = false;
}// end constructor(Quest(string, int, Monster&, Reward))

Quest::Quest(string dialogue, QuestItem itemToCollect, Reward reward) {
	this->dialogue = dialogue;
	this->itemToCollect = itemToCollect;
	this->reward = reward;
	numberOfItemsToCollect = 1;
	itemCount = 0;
	isQuestCollect = true;
	isQuestKill = false;
	isQuestComplete = false;
}// end constructor(Quest(string, QuestItem, Reward))

Quest::Quest(string dialogue, int numberOfItemsToCollect, QuestItem item, Reward reward) {
	this->dialogue = dialogue;
	this->numberOfItemsToCollect = numberOfItemsToCollect;
	this->reward = reward;
	itemToCollect = item;
	itemCount = 0;
	isQuestComplete = false;
	isQuestCollect = true;
	isQuestKill = false;
}// end constructor(Quest(string, int, QuestItem, Reward))

void Quest::checkMonsterKilled(Monster& monster) {
	if (monster.getRace() == monsterToKill.getRace())
		updateKillCount();
}// end checkMonsterKilled(Monster&)

void Quest::checkQuestItem(QuestItem questItem) {
	if (questItem.getName() == itemToCollect.getName())
		updateItemCount();
}// end checkQuestItem(QuestItem)

void Quest::updateKillCount() {
	if (killCount < killNumber)
		killCount++;
	if (killCount == killNumber)
		isQuestComplete = true;
}// end updateKillCount()

void Quest::updateItemCount() {
	if (itemCount < numberOfItemsToCollect)
		itemCount++;
	
}// end updateItemCount()



//*************************************************************************************
// Player Classes
//
//*************************************************************************************

class Character {
protected:
	string name;
	int level;
	Armor armor;
	Weapon weapon;
	long gold;
	int hitPoints;
	int strength;
	int constitution;
	int dexterity;
	int hitPointMod;
	Race race;
	//Quest quest;
	//bool onQuest;
public:
	Character();
	~Character();
	Character(string, int, int, int, int, int, long, Armor, Weapon, Race);
	string getName() { return name; }
	int getLevel() { return level; }

	Armor getArmor() { return armor; }
	Weapon getWeapon() { return weapon; }
	long getGold() { return gold; }
	int getHitPoints() { return hitPoints; }
	int getStrength() { return strength; }
	int getDexMod() { return dexterity; }
	int getHitPointMod() { return hitPointMod; }
	int getItemsHitPointBonus() { return weapon.getHpBonus() + armor.getHpBonus(); }
	void takeDamage(int dmg) { hitPoints -= dmg; }
	bool isAlive() { return hitPoints > 0; }
	void heal(int);
	int getAttack();
	int getDefense();
	int getMaxHitPoints();
	int getFullDefenseBonus();
	int getFullAttackBonus();
	int getFullStrength();
	int getFullConstitution();
	int getFullDexterity();
	string getStatus();
	string toString();
};// end class Character

Character::Character() {

}// end constructor(Character())

Character::~Character() {

}// end destructor(~Character())

Character::Character(string name, int hitPointMod, int level, int strength, int constitution, int dexterity,
	long gold, Armor armor, Weapon weapon, Race race) {
	this->name = name;
	this->hitPointMod = hitPointMod;
	this->level = level;
	this->strength = strength;
	this->constitution = constitution;
	this->dexterity = dexterity;
	this->gold = gold;
	this->armor = armor;
	this->weapon = weapon;
	this->race = race;
	hitPoints = ((level * hitPointMod) + (level * getStatMod(getFullConstitution())))
		+ getItemsHitPointBonus();
}// end constructor(Character(string))

void Character::heal(int health) {
	if (hitPoints + health <= getMaxHitPoints())
		hitPoints += health;
	else
		hitPoints = getMaxHitPoints();
}// end heal(int)

string Character::toString() {
	return "Name: " + name + "\nLevel: " + to_string(level) + "\nHit Points: " + to_string(getMaxHitPoints()) +
		"\nArmor Class: " + to_string(getDefense()) + "\nStrength: " + to_string(getFullStrength()) +
		"\nConstitution: " + to_string(getFullConstitution()) + "\nDexterity: " + to_string(getFullDexterity()) +
		"\nGold: " + to_string(gold) + "\n\nArmor\n" + armor.toString() +
		"\n\nWeapon\n" + weapon.toString() + "\n";
}// end toString()

string Character::getStatus() {
	return "Name: " + name + "\nLevel: " + to_string(level) + "\nHit Points: " + to_string(hitPoints);
}// end getStatus()

int Character::getAttack() {
	return level + getStatMod(strength) + getItemsHitPointBonus();
}// end getAttack()

int Character::getDefense() {
	return 10 + getStatMod(getFullDexterity()) + armor.getDefense() + getFullDefenseBonus();
}// end getDefense()

int Character::getMaxHitPoints() {
	return ((level * hitPointMod) + (level * getStatMod(getFullConstitution())))
		+ getItemsHitPointBonus();
}// end getMaxHitPoints()

int Character::getFullStrength() {
	return strength + armor.getStrBonus() + weapon.getStrBonus() + race.getStrBonus();
}// end getFullStrength()

int Character::getFullConstitution() {
	return constitution + armor.getConBonus() + weapon.getConBonus() + race.getConBonus();
}// end getFullConstitution()

int Character::getFullDexterity() {
	return dexterity + armor.getDexBonus() + weapon.getDexBonus() + race.getDexBonus();
}// end getFullDexterity()

int Character::getFullDefenseBonus() {
	return weapon.getDefenseBonus() + armor.getDefenseBonus() + race.getDefenseBonus();
}// end getFullDefenseBonus()

int Character::getFullAttackBonus() {
	return weapon.getAttackBonus() + armor.getAttackBonus() + race.getAttackBonus();
}// end getFullAttackBonus()



//**********************************************************************************************************
// Player
//
//***********************************************************************************************************

class Player : public Character {
protected:
	long experience;
	Inventory inventory;
	Quest quest1;
	Quest quest2;
	Quest quest3;
	bool hasQuest1;
	bool hasQuest2;
	bool hasQuest3;
public:
	Player();
	~Player();
	Player(string, int, int, int, int, int, long, Armor, Weapon, Race);
	bool getHasQuest1() { return hasQuest1; }
	bool getHasQuest2() { return hasQuest2; }
	bool getHasQuest3() { return hasQuest3; }
	Quest& getQuest1() { return quest1; }
	Quest& getQuest2() { return quest2; }
	Quest& getQuest3() { return quest3; }
	long getExperience() { return experience; }
	void gainLevel();
	bool hasGainedLevel();
	void addExperience(long exp) { experience += exp; }
	void setUpExperience();
	void checkLevel();
	void setArmor(Armor armor) { this->armor = armor; }
	void setWeapon(Weapon weapon) { this->weapon = weapon; }
	Inventory& getInventory() { return inventory; }
	void usePotion(Potion potion) { heal(potion.getAmountHealed()); inventory.remove(potion); }
	string toString();
	void equipWeapon();
	void equipArmor();
	void spendGold(long gold);
	void gainGold(long gold) { this->gold += gold; }
	void addQuest(Quest);
	void addToInventory(Weapon weapon) { inventory.add(weapon); }
	void addToInventory(Armor armor) { inventory.add(armor); }
	void addToInventory(Potion potion) { inventory.add(potion); }
	void addToInventory(QuestItem);
	void checkMonsterKilled(Monster&);
	void checkQuestItemLooted(QuestItem);
	bool hasRoomForQuest();
};// end class Player

Player::Player(string name, int hitPointMod, int level, int strength, int constitution, int dexterity, long gold,
	Armor armor, Weapon weapon, Race race) : Character(name, hitPointMod, level, strength, constitution,
		dexterity, gold, armor, weapon, race) {
	setUpExperience();
	hasQuest1 = false;
	hasQuest2 = false;
	hasQuest3 = false;
}// end constructor(Player(string, int, int, int, int, long, Armor, Weapon))

Player::Player() {

}// end constructor(Player)

Player::~Player() {

}// end destructor(~Player)

void Player::setUpExperience() {
	experience = level * 1000;
}// end setUpExperience()

bool Player::hasGainedLevel() {
	if (experience == (level * 1000) + 1000)
		return true;
	else
		return false;
}// end hasGainedLevel()

void Player::checkLevel() {
	if (hasGainedLevel())
		gainLevel();
}// end checkLevel()

void Player::gainLevel() {
	level++;
	heal(hitPointMod + getStatMod(getFullConstitution()));
}// end gainlevel()

string Player::toString() {
	return "Name: " + name + "\nLevel: " + to_string(level) + "\nHit Points: " + to_string(getMaxHitPoints()) +
		"\nArmor Class: " + to_string(getDefense()) + "\nStrength: " + to_string(getFullStrength()) +
		"\nConstitution: " + to_string(getFullConstitution()) + "\nDexterity: " + to_string(getFullDexterity()) +
		"\nGold: " + to_string(gold) + "\nExperience: " + to_string(experience) + "\n\nArmor\n" + armor.toString() +
		"\n\nWeapon\n" + weapon.toString() + "\n";
}// end toString()

void Player::equipWeapon() {
	if (inventory.getWeaponsIndex() > -1) {
		Weapon temp1 = this->weapon;
		Weapon temp2 = inventory.selectWeapon();
		this->weapon = temp2;
		inventory.remove(temp2);
		inventory.add(temp1);
	}// end if
	else {
		cout << "You do not currently have any weapons in your inventory.\n";
	}// end else
}// end equipWeapon(Weapon)

void Player::equipArmor() {
	if (inventory.getArmorIndex() > -1) {
		Armor temp1 = this->armor;
		Armor temp2 = inventory.selectArmor();
		this->armor = temp2;
		inventory.remove(temp2);
		inventory.add(temp1);
	}// end if
	else {
		cout << "You do not currently have any armor in your inventory.\n";
	}// end else
}// end equipArmor(Armor)

void Player::spendGold(long gold) {
	if (this->gold - gold > 0)
		this->gold -= gold;
}// end spendGold(long)

void Player::addQuest(Quest quest) {
	if (!hasQuest1 || (quest1.getIsQuestComplete() && quest1.getReward().getHasRewardBeenGiven())) {
		quest1 = quest;
		hasQuest1 = true;
	}// end if
	else if (!hasQuest2 || (quest2.getIsQuestComplete() && quest2.getReward().getHasRewardBeenGiven())) {
		quest2 = quest;
		hasQuest2 = true;
	}// end else if
	else if (!hasQuest3 || (quest3.getIsQuestComplete() && quest3.getReward().getHasRewardBeenGiven())) {
		quest3 = quest;
		hasQuest3 = true;
	}// end else if	
}// end addQuest(Quest)

void Player::addToInventory(QuestItem questItem) {
	inventory.add(questItem);
	checkQuestItemLooted(questItem);
}// end addToInventory(QuestItem)

void Player::checkMonsterKilled(Monster& monster) {
	if (quest1.getIsQuestKill())
		quest1.checkMonsterKilled(monster);
	if (quest2.getIsQuestKill())
		quest2.checkMonsterKilled(monster);
	if (quest3.getIsQuestKill())
		quest3.checkMonsterKilled(monster);
}// end checkMonsterKilled(Monster&)

void Player::checkQuestItemLooted(QuestItem questItem) {
	// add to a loot function later
	if (quest1.getIsQuestCollect())
		quest1.checkQuestItem(questItem);
	if (quest2.getIsQuestCollect())
		quest2.checkQuestItem(questItem);
	if (quest3.getIsQuestCollect())
		quest3.checkQuestItem(questItem);
}// end checkQuestItemLooted(QuestItem)

bool Player::hasRoomForQuest() {
	if (!hasQuest1 || (quest1.getIsQuestComplete() && quest1.getReward().getHasRewardBeenGiven()))
		return true;
	else if (!hasQuest2 || (quest2.getIsQuestComplete() && quest2.getReward().getHasRewardBeenGiven()))
		return true;
	else if (!hasQuest3 || (quest3.getIsQuestComplete() && quest3.getReward().getHasRewardBeenGiven()))
		return true;
	else
		return false;
}// end hasRoomForQuest()

//*************************************************************************************
// Non-Player Character (NPC)
//
//*************************************************************************************

class NonPlayerCharacter {
protected:
	string name;
	string dialogue;
public:
	~NonPlayerCharacter();
	NonPlayerCharacter();
	NonPlayerCharacter(string);
	NonPlayerCharacter(string, string);
	string getName() { return name; }
	void greeting(Player);
};// end class NonPlayerCharacter

NonPlayerCharacter::NonPlayerCharacter() {

}// end constructor(NonPlayerCharacter())

NonPlayerCharacter::NonPlayerCharacter(string name) {
	this->name = name;
	dialogue = " ";
}// end constructor(NonPlayerCharacter(string))

NonPlayerCharacter::~NonPlayerCharacter() {

}// end destructor(~NonPlayerCharacter())

NonPlayerCharacter::NonPlayerCharacter(string name, string dialogue) {
	this->name = name;
	this->dialogue = dialogue;
}// end constructor(NonPlayerCharacter(string, string))

void NonPlayerCharacter::greeting(Player player) {
	if (!(dialogue == " "))
		cout << "Hello, " << player.getName() << ". " << dialogue << "\n";
	else
		cout << "Hello, I am " << name << ". Lovely weather, isn't it?\n";
}// end greeting(Player)



//************************************************************************************
// Quest NPC
//
//************************************************************************************

class QuestNPC : public NonPlayerCharacter {
protected:
	Quest quest1;
	bool hasQuest1;
	bool hasQuest1BeenAccepted;
	Quest quest2;
	bool hasQuest2;
	bool hasQuest2BeenAccepted;
	Quest quest3;
	bool hasQuest3;
	bool hasQuest3BeenAccepted;
	
public:
	QuestNPC();
	~QuestNPC();
	QuestNPC(string);
	Quest& getQuest1() { return quest1; }
	void addQuest(Quest);
	void triggerQuest(Player&);
	void bestowQuest(Quest&, Player&);
	bool acceptQuest();
	void updateStatus(Player&, Quest&);
	void updateQuestStatus(Player&);
	void interactWithPC(Player&);
	bool removeQuestItems(Player&, Quest&);
	void updateAndReward(Player&);
	Weapon selectWeapon(Player, Quest);
	Armor selectArmor(Player, Quest);
	void bestowReward(Player&, Quest&);
};// end class QuestNPC

QuestNPC::QuestNPC() {
	hasQuest1 = false;
	hasQuest1BeenAccepted = false;
	hasQuest2 = false;
	hasQuest2BeenAccepted = false;
	hasQuest3 = false;
	hasQuest3BeenAccepted = false;
}// end constructor(QuestNPC())

QuestNPC::~QuestNPC() {

}// end destructor(~QuestNPC())

QuestNPC::QuestNPC(string dialogue) : NonPlayerCharacter(dialogue) {
	hasQuest1 = false;
	hasQuest1BeenAccepted = false;
	hasQuest2 = false;
	hasQuest2BeenAccepted = false;
	hasQuest3 = false;
	hasQuest3BeenAccepted = false;
}// end constructor(QuestNPC(string))

void QuestNPC::addQuest(Quest quest) {
	if (!hasQuest1) {
		quest1 = quest;
		hasQuest1 = true;
	}// end if
	else if (!hasQuest2) {
		quest2 = quest;
		hasQuest2 = true;
	}// end else if
	else if (!hasQuest3) {
		quest3 = quest;
		hasQuest3 = true;
	}// end else if
}// end addQuest(Quest, Reward)

void QuestNPC::triggerQuest(Player& player) {
	if (player.hasRoomForQuest()) {
		if (hasQuest1 && !hasQuest1BeenAccepted) {
			cout << "\n" << quest1.getDialogue() << "\n";
			cout << quest1.getReward().toString() << "\n";
			if (acceptQuest()) {
				hasQuest1BeenAccepted = true;
				bestowQuest(quest1, player);
			}// end if
		}// end if
		else if (hasQuest2 && !hasQuest2BeenAccepted) {
			cout << "\n" << quest2.getDialogue() << "\n";
			cout << quest2.getReward().toString() << "\n";
			if (acceptQuest()) {
				hasQuest2BeenAccepted = true;
				bestowQuest(quest2, player);
			}// end if
		}// end else if
		else if (hasQuest3 && !hasQuest3BeenAccepted) {
			cout << "\n" << quest3.getDialogue() << "\n";
			cout << quest3.getReward().toString() << "\n";
			if (acceptQuest()) {
				hasQuest3BeenAccepted = true;
				bestowQuest(quest3, player);
			}// end if
		}// end else if
	}// end if
	else {
		cout << "\nReturn to me later when you are less busy.\n\n";
	}// end else
}// end triggerQuest(Player&)

bool QuestNPC::acceptQuest() {
	int choice;
	choice = getPositiveInt("Do you accept the quest?\nType 1 for yes and 2 for no.\n", 2);
	if (choice == 1)
		return true;
	else
		return false;
}// end acceptQuest()

void QuestNPC::bestowQuest(Quest& quest, Player& player) {
	player.addQuest(quest);
}// end bestowQuest(Quest, Player&)

 // Remove Quest Items From Player Inventory
bool QuestNPC::removeQuestItems(Player& player, Quest& quest) {
	int count = 0;
	for (int i = 0; i <= player.getInventory().getQuestItemsIndex(); i++) {
		if (quest.getItemToCollect().getName() == player.getInventory().getQuestItems()[i].getName())
			count++;
	}// end for
	if (count == quest.getNumberOfItemsToCollect()) {
		for (int i = 0; i < quest.getNumberOfItemsToCollect(); i++) {
			player.getInventory().remove(quest.getItemToCollect());
		}// end for
		return true;
	}// end if
	else {
		return false;
	}// end else
}// end removeQuestItems(Player&, Quest&)

void QuestNPC::updateAndReward(Player& player) {
	updateQuestStatus(player);
	if (player.getQuest1().getIsQuestComplete())
		bestowReward(player, player.getQuest1());
	if (player.getQuest2().getIsQuestComplete())
		bestowReward(player, player.getQuest2());
	if (player.getQuest3().getIsQuestComplete())
		bestowReward(player, player.getQuest3());
}// end updateAndReward(Player&)

void QuestNPC::updateStatus(Player& player, Quest& quest) {
	if (quest.getItemCount() == quest.getNumberOfItemsToCollect()) {
		bool questItemsRemoved = removeQuestItems(player, quest);
		if (questItemsRemoved)
			quest.setIsQuestCompleteTrue();
	}// end if
}// end checkQuest1Status(Player)

void QuestNPC::updateQuestStatus(Player& player) {
	if (!player.getQuest1().getIsQuestComplete() && player.getQuest1().getIsQuestCollect())
		updateStatus(player, player.getQuest1());
	if (!player.getQuest2().getIsQuestComplete() && player.getQuest2().getIsQuestCollect())
		updateStatus(player, player.getQuest2());
	if (!player.getQuest3().getIsQuestComplete() && player.getQuest3().getIsQuestCollect())
		updateStatus(player, player.getQuest3());
}// end checkQuestStatus(Player)

Weapon QuestNPC::selectWeapon(Player player, Quest quest) {
	string output;
	int choice;
	output = "Which weapon do you want as a reward?\n\n1.\n" + quest.getReward().getWeapon1().toString() +
		"\n2.\n" + quest.getReward().getWeapon2().toString() + "\n";
	choice = getPositiveInt(output, 2);
	if (choice == 1)
		return quest.getReward().getWeapon1();
	else
		return quest.getReward().getWeapon2();
}// end selectWeapon(Player)

 // Assumes that the quest has been completed.
void QuestNPC::bestowReward(Player& player, Quest& quest) {
	// Reward Gold
	player.gainGold(quest.getReward().getGold());
	//Reward weapon
	if (quest.getReward().getHasWeapon1() && quest.getReward().getHasWeapon2())
		player.getInventory().add(selectWeapon(player, quest));
	else if (quest.getReward().getHasWeapon1())
		player.getInventory().add(quest.getReward().getWeapon1());
	else if (quest.getReward().getHasWeapon2())
		player.getInventory().add(quest.getReward().getWeapon2());
	// Reward armor
	if (quest.getReward().getHasArmor1() && quest.getReward().getHasArmor2())
		player.getInventory().add(selectArmor(player, quest));
	else if (quest.getReward().getHasArmor1())
		player.getInventory().add(quest.getReward().getArmor1());
	else if (quest.getReward().getHasArmor2())
		player.getInventory().add(quest.getReward().getArmor2());
	// Reward potion
	if (quest.getReward().getHasPotion()) {
		for (int i = 0; i < quest.getReward().getNumberOfPotions(); i++) {
			player.getInventory().add(quest.getReward().getPotion());
		}// end for
	}// end if
	quest.getReward().setHasRewardBeenGivenTrue();
}// end bestowReward(Player&)

Armor QuestNPC::selectArmor(Player player, Quest quest) {
	string output;
	int choice;
	output = "Which set of armor do you want as a reward?\n\n1.\n" + quest.getReward().getArmor1().toString() + 
		"\n2.\n" + quest.getReward().getArmor2().toString() + "\n";
	choice = getPositiveInt(output, 2);
	if (choice == 1)
		return quest.getReward().getArmor1();
	else
		return quest.getReward().getArmor2();
}// end selectArmor(Player)

void QuestNPC::interactWithPC(Player& player) {
	updateAndReward(player);
	triggerQuest(player);
}// end interactWithPC(Player&)



 //******************************************************************************************
 // Merchant Class
 //
 //******************************************************************************************

class Merchant {
protected:
	string name;
	Inventory inventory;
	double priceMod;
public:
	Merchant();
	~Merchant();
	Merchant(string, Inventory, double);
	string getName() { return name; }
	Inventory& getInventory() { return inventory; }
	double getPriceMod() { return priceMod; }
	void greeting(Player&);
	void armorMenu(Player&);
	void weaponsMenu(Player&);
	void potionsMenu(Player&);
	void sell(Player&, Armor);
	void sell(Player&, Potion);
	void sell(Player&, Weapon);
	void displayArmor();
	void displayWeapons();
	void displayPotions();
	void menu(Player&);
	void buyMenu(Player&);
	void buyArmorMenu(Player&);
	void buyWeaponsMenu(Player&);
	void buyPotionsMenu(Player&);
	void displayPlayersArmor(Player&);
	void displayPlayersWeapons(Player&);
	void displayPlayersPotions(Player&);
	void buy(Player& player, Armor armor);
	void buy(Player& player, Weapon weapon);
	void buy(Player& player, Potion potion);
};// end class Merchant

Merchant::Merchant() {

}// end constructor(Merchant())

Merchant::~Merchant() {

}// end constructor(~Merchant())

Merchant::Merchant(string name, Inventory inventory, double priceMod) {
	this->name = name;
	this->inventory = inventory;
	this->priceMod = priceMod;
}// end constructor(Merchant(string, Inventory))

void Merchant::menu(Player& player) {
	int choice = 0;
	bool loop = true;
	do {
		choice = getPositiveInt("Would you like to:\n1. Browse Armor\n2. Browse Weapons\n"
			"3. Browse Potions\n4. Sell\n5. Leave\n", 5);
		switch (choice) {
		case 1:
			if (inventory.getArmorIndex() > -1)
				armorMenu(player);
			else
				cout << "\nI am not currently selling any armor. Please check again at a later date.\n\n";
			break;
		case 2:
			if (inventory.getWeaponsIndex() > -1)
				weaponsMenu(player);
			else
				cout << "\nI am not current selling any weapons. Please check again at a later date.\n\n";
			break;
		case 3:
			if (inventory.getPotionsIndex() > -1)
				potionsMenu(player);
			else
				cout << "\nI am not currently selling any potions. Please check again at a later date.\n\n";
			break;
		case 4:
			buyMenu(player);
			break;
		case 5:
			loop = false;
			break;
		default: break;
		}// end switch(choice)
	} while (loop);
}// end menu()

void Merchant::greeting(Player& player) {
	int choice = 0;
	cout << "\nHello, I am Merchant " << name << ".\n\n";
	menu(player);
}// end greeting()


// Methods for selling to a player.
void Merchant::armorMenu(Player& player) {
	int indexOfArmorChosen = -2;
	do {
		displayArmor();
		cout << "\nGold: " << player.getGold() << "\n";
		indexOfArmorChosen = getPositiveIntOrGoBack("Enter the number of the armor that you wish to"
			" buy or type -1 to return to the previous menu.\n", inventory.getArmorIndex() + 1);
		if (indexOfArmorChosen != -1) {
			if (player.getGold() >=
				(long)(inventory.getArmor()[indexOfArmorChosen - 1].getValue() * priceMod + 0.43)) {
				sell(player, inventory.getArmor()[indexOfArmorChosen - 1]);
			}// end if
			else {
				cout << "\nYou do not have enough gold to purchase the armor.\n\n";
			}// end else
		}// end if
	} while (indexOfArmorChosen != -1 && inventory.getArmorIndex() != -1);
}// end armorMenu(Player&)

void Merchant::displayArmor() {
	cout << "\nArmor that I have available for purchase:\n\n";
	for (int i = 0; i <= inventory.getArmorIndex(); i++) {
		cout << (i + 1) << ".\n" << inventory.getArmor()[i].toString() << "Price: " <<
			to_string((long)(inventory.getArmor()[i].getValue() * priceMod + 0.43)) << "\n\n";
	}// end for
}// end displayArmor()

void Merchant::sell(Player& player, Armor armor) {
	player.spendGold((long)(armor.getValue() * priceMod + 0.43));
	player.getInventory().add(armor);
	inventory.remove(armor);
	cout << endl << armor.getName() << " successfully purchased.\n\n";
}// end sellArmor(Player, Armor)

void Merchant::weaponsMenu(Player& player) {
	int indexOfWeaponChosen = -2;
	do {
		displayWeapons();
		cout << "\nGold: " << player.getGold() << "\n";
		indexOfWeaponChosen = getPositiveIntOrGoBack("Enter the number of the weapon that you wish to"
			" buy or type -1 to return to the previous menu.\n", inventory.getWeaponsIndex() + 1);
		if (indexOfWeaponChosen != -1) {
			if (player.getGold() >=
				(long)(inventory.getWeapons()[indexOfWeaponChosen - 1].getValue() * priceMod + 0.43)) {
				sell(player, inventory.getWeapons()[indexOfWeaponChosen - 1]);
			}// end if
			else {
				cout << "\nYou do not have enough gold to purchase the weapon.\n\n";
			}// end else
		}// end if
	} while (indexOfWeaponChosen != -1 && inventory.getWeaponsIndex() != -1);
}// end displayWeapons(Player)

void Merchant::displayWeapons() {
	cout << "\nWeapons that I have available for purchase:\n\n";
	for (int i = 0; i <= inventory.getWeaponsIndex(); i++) {
		cout << (i + 1) << ".\n" << inventory.getWeapons()[i].toString() << "Price: " <<
			to_string((long)(inventory.getWeapons()[i].getValue() * priceMod + 0.43)) << "\n\n";
	}// end for
}// end displayWeapons()

void Merchant::sell(Player& player, Weapon weapon) {
	player.spendGold((long)(weapon.getValue() * priceMod + 0.43));
	player.getInventory().add(weapon);
	inventory.remove(weapon);
	cout << endl << weapon.getName() << " successfully purchased.\n\n";
}// end sellWeapon(Player, Weapon)

void Merchant::potionsMenu(Player& player) {
	int indexOfPotionChosen = -2;
	do {
		displayPotions();
		cout << "\nGold: " << player.getGold() << "\n";
		indexOfPotionChosen = getPositiveIntOrGoBack("Enter the number of the potion that you wish to"
			" buy or type -1 to return to the previous menu.\n", inventory.getPotionsIndex() + 1);
		if (indexOfPotionChosen != -1) {
			if (player.getGold() >=
				(long)(inventory.getPotions()[indexOfPotionChosen - 1].getValue() * priceMod + 0.43)) {
				sell(player, inventory.getPotions()[indexOfPotionChosen - 1]);
			}// end if
			else {
				cout << "\nYou do not have enough gold to purchase the potion.\n\n";
			}// end else
		}// end if
	} while (indexOfPotionChosen != -1 && inventory.getPotionsIndex() != -1);
}// end displayPotions(Player)

void Merchant::displayPotions() {
	cout << "\nPotions that I have available for purchase:\n\n";
	for (int i = 0; i <= inventory.getPotionsIndex(); i++) {
		cout << (i + 1) << ".\n" << inventory.getPotions()[i].toString() << "Price: " <<
			to_string((long)(inventory.getPotions()[i].getValue() * priceMod + 0.43)) << "\n\n";
	}// end for
}// end displayPotions()

void Merchant::sell(Player& player, Potion potion) {
	player.spendGold((long)(potion.getValue() * priceMod + 0.43));
	player.getInventory().add(potion);
	inventory.remove(potion);
	cout << endl << potion.getName() << " successfully purchased.\n\n";
}// end sellPotion(Player, Potion)


// Methods for buying from a player.
void Merchant::buyMenu(Player& player) {
	int sellChoice = -5;
	bool loop = true;
	do {
		sellChoice = getPositiveInt("\nWould you like to sell\n1. Armor\n2. Weapons"
			"\n3. Potions\n4. Return to the previous menu.\n", 4);
		switch (sellChoice) {
		case 1:
			if (player.getInventory().getArmorIndex() > -1)
				buyArmorMenu(player);
			else
				cout << "\n\nYou do not have any armor in your inventory to sell.\n\n";
			break;
		case 2:
			if (player.getInventory().getWeaponsIndex() > -1)
				buyWeaponsMenu(player);
			else
				cout << "\n\nYou do not have any weapons in your inventory to sell.\n\n";
			break;
		case 3:
			if (player.getInventory().getPotionsIndex() > -1)
				buyPotionsMenu(player);
			else
				cout << "\n\nYou do not have any potions in your inventory to sell.\n\n";
			break;
		case 4:
			loop = false;
			break;
		default: break;
		}// end switch(sellChoice)
	} while (loop);
}// end buyMenu(Player&)

void Merchant::buyArmorMenu(Player& player) {
	int indexOfArmorToBuy = -2;
	do {
		displayPlayersArmor(player);
		cout << "\nGold: " << player.getGold() << "\n";
		indexOfArmorToBuy = getPositiveIntOrGoBack("Enter the number of the armor that you wish to sell or"
			" type -1 to return to the previous menu.\n", player.getInventory().getArmorIndex() + 1);
		if (indexOfArmorToBuy != -1)
			buy(player, player.getInventory().getArmor()[indexOfArmorToBuy - 1]);
	} while (indexOfArmorToBuy != -1 && player.getInventory().getArmorIndex() > -1);
}// end buyArmorMenu(Player&)

void Merchant::buy(Player& player, Armor armor) {
	player.getInventory().remove(armor);
	inventory.add(armor);
	player.gainGold((long)(((armor.getValue() / 2) * (priceMod + 0.25))));
}// end buyArmor(Player&, Armor)

void Merchant::displayPlayersArmor(Player& player) {
	cout << "\nArmor that you have available to sell:\n\n";
	for (int i = 0; i <= player.getInventory().getArmorIndex(); i++) {
		cout << (i + 1) << ".\n" << player.getInventory().getArmor()[i].toString() << "Price: "<< 
			to_string((long)((player.getInventory().getArmor()[i].getValue() / 2) * (priceMod + 0.25)))
			<< "\n\n";
	}// end for
}// end displayPlayersArmor(Player&)

void Merchant::buyWeaponsMenu(Player& player) {
	int indexOfWeaponToBuy = -2;
	do {
		displayPlayersWeapons(player);
		cout << "\nGold: " << player.getGold() << "\n";
		indexOfWeaponToBuy = getPositiveIntOrGoBack("Enter the number of the weapon that you wish to sell or"
			" type -1 to return to the previous menu.\n", player.getInventory().getWeaponsIndex() + 1);
		if (indexOfWeaponToBuy != -1)
			buy(player, player.getInventory().getWeapons()[indexOfWeaponToBuy - 1]);
	} while (indexOfWeaponToBuy != -1 && player.getInventory().getWeaponsIndex() > -1);
}// end buyWeaponsMenu(Player&)

void Merchant::buy(Player& player, Weapon weapon) {
	player.getInventory().remove(weapon);
	inventory.add(weapon);
	player.gainGold((long)(((weapon.getValue() / 2) * (priceMod + 0.25))));
}// end buyWeapon(Player&, Weapon)

void Merchant::displayPlayersWeapons(Player& player) {
	cout << "\nWeapons that you have available to sell:\n\n";
	for (int i = 0; i <= player.getInventory().getWeaponsIndex(); i++) {
		cout << (i + 1) << ".\n" << player.getInventory().getWeapons()[i].toString() << "Price: " <<
			to_string((long)((player.getInventory().getWeapons()[i].getValue() / 2) * (priceMod + 0.25)))
			<< "\n\n";
	}// end for
}// end displayPlayersWeapons(Player&)

void Merchant::buyPotionsMenu(Player& player) {
	int indexOfPotionToBuy = -2;
	do {
		displayPlayersPotions(player);
		cout << "\nGold: " << player.getGold() << "\n";
		indexOfPotionToBuy = getPositiveIntOrGoBack("Enter the number of the potion that you wish to sell or"
			" type -1 to return to the previous menu.\n", player.getInventory().getPotionsIndex() + 1);
		if (indexOfPotionToBuy != -1)
			buy(player, player.getInventory().getPotions()[indexOfPotionToBuy - 1]);
	} while (indexOfPotionToBuy != -1 && player.getInventory().getPotionsIndex() > -1);
}// end buyPotionsMenu(Player&)

void Merchant::buy(Player& player, Potion potion) {
	player.getInventory().remove(potion);
	inventory.add(potion);
	player.gainGold((long)(((potion.getValue() / 2) * (priceMod + 0.25))));
}// end buyPotion(Player&, Potion)

void Merchant::displayPlayersPotions(Player& player) {
	cout << "\nPotions that you have available to sell:\n\n";
	for (int i = 0; i <= player.getInventory().getPotionsIndex(); i++) {
		cout << (i + 1) << ".\n" << player.getInventory().getPotions()[i].toString() << "Price: " <<
			to_string((long)((player.getInventory().getPotions()[i].getValue() / 2) *(priceMod + 0.25)))
			<< "\n\n";
	}// end for
}// end displayPlayersPotions(Player&)



//*************************************************************************************
// Functions
//
//*************************************************************************************

 // Generate Weapon Function
void fillWeaponArray(Weapon weaponry[], int& weaponryIndex) {
	weaponry[++weaponryIndex] = Weapon("Khatar", 4, "Martial", 10);
	weaponry[++weaponryIndex] = Weapon("Dagger", 4, "Piercing", 15);
	weaponry[++weaponryIndex] = Weapon("Short Sword", 6, "Slashing", 25);
	weaponry[++weaponryIndex] = Weapon("Long Sword", 8, "Slashing", 35);
}// end Function(fillWeaponArray(Weapon[], int&))


// Generate Armor Function
void fillArmorArray(Armor armory[], int& armoryIndex) {
	armory[++armoryIndex] = Armor("Cloth Shirt", 0, "Cloth", 2);
	armory[++armoryIndex] = Armor("Padded Armor", 1, "Cloth", 20);
	armory[++armoryIndex] = Armor("Hide Armor", 2, "Leather", 30);
	armory[++armoryIndex] = Armor("Studded Hide Armor", 3, "Leather", 55);
	armory[++armoryIndex] = Armor("Ring Mail", 4, "Chain", 85);
	armory[++armoryIndex] = Armor("Chain Mail", 4, "Chain", 65);
	armory[++armoryIndex] = Armor("Scale Mail", 5, "Plate", 75);
	armory[++armoryIndex] = Armor("Banded Mail", 5, "Plate", 55);
	armory[++armoryIndex] = Armor("Plate Mail", 6, "Plate", 105);
}// end Function(fillArmorArray(Armor[], int&))


// Generate Potions Function
void fillPotionsArray(Potion potions[], int& potionsIndex) {
	potions[++potionsIndex] = Potion("Potion of Minor Healing", 4, 15);
	potions[++potionsIndex] = Potion("Potion of Lesser Healing", 8, 30);
}// end Function(fillPotionsArray(Potion[], int&))



//****************************************************************************************
// Battle Functions
//
//****************************************************************************************

// Player Attacks a Monster
void attack(Player& player, Monster& monster) {
	if ((roll(20) + player.getAttack()) >= monster.getDefense())
		monster.takeDamage(roll(player.getWeapon().getDamage()) + getStatMod(player.getFullStrength()));
}//end attack(Player&, Monster&)


void attack(Player& player, Monster& monster1, Monster& monster2) {
	int npcToAttack;
	if (monster1.isAlive() && monster2.isAlive()) {
		cout << "Do you wish to attack...\n1.  " << monster1.getStatus() << 
			"\n\n2.  " << monster2.getStatus() << endl;
		npcToAttack = getPositiveInt("", 2);
		if (npcToAttack == 1)
			attack(player, monster1);
		else
			attack(player, monster2);
	}// end if
	else if (monster1.isAlive()) {
		attack(player, monster1);
	}// end else if
	else {
		attack(player, monster2);
	}// end else
}// end attack(Player, Monster, Monster)


 // Monster attacks a player.
void attack(Monster& monster, Player& player) {
	if ((roll(20) + monster.getAttack()) >= player.getDefense())
		player.takeDamage(roll(monster.getWeapon().getDamage()) + getStatMod(monster.getFullStrength()));
}// end attack(Monster&, Player&)


// battle switch
void battleSwitch(Player& player, Monster& monster, bool& run) {
	int choice;
	bool loop = true;
	int result = 0;
	do {
		choice = getPositiveInt("Choose an option.\n\n1. Attack\n2. Drink a potion\n3. Run\n", 3);
		switch (choice) {
		case 1: attack(player, monster); loop = false; break;
		case 2: if (player.getInventory().getPotionsIndex() >= 0) {
			player.usePotion(player.getInventory().selectPotion());
			loop = false;
			}// end if
			else {
				cout << "You do not have any potions.\n";
			}// end else
			break;
		case 3: result = roll(10);
			if (result < 9) { run = true; }
			loop = false;
			break;
		default: loop = false; break;
		}// end switch
	} while (loop);
}// end battleSwitch(Player&, Monster&)


void battleSwitch(Player& player, Monster& monster1, Monster& monster2, bool& run) {
	int choice;
	bool loop = true;
	int result = 0;
	do {
		choice = getPositiveInt("Choose an option.\n\n1. Attack\n2. Drink a potion\n3. Run\n", 3);
		switch (choice) {
		case 1: 
			if (monster1.isAlive() && monster2.isAlive()) {
				attack(player, monster1, monster2);
			}// end if
			else if (monster1.isAlive()) {
				attack(player, monster1);
			}// end else if
			else {
				attack(player, monster2);
			}// end else
			loop = false; break;
		case 2: 
			if (player.getInventory().getPotionsIndex() >= 0) {
				player.usePotion(player.getInventory().selectPotion());
				loop = false;
			}// end if
			else {
				cout << "You do not have any potions.\n";
			}// end else
			break;
		case 3:	result = roll(10);
			if (result < 9) { run = true; }
			loop = false;
			break;
		default: loop = false; break;
		}// end switch
	} while (loop);
}// end battleSwitch(Player&, Monster&, Monster&)


// Fight until the death.
void battle(Player& player, Monster& monster1, Monster& monster2) {
	bool run = false;
	do {
		battleSwitch(player, monster1, monster2, run);
		if (monster1.isAlive() && player.isAlive() && !run) attack(monster1, player);
		if (monster2.isAlive() && player.isAlive() && !run) attack(monster2, player);
		cout << player.getStatus() << endl << endl;
		cout << monster1.getStatus() << endl << endl;
		cout << monster2.getStatus() << endl << endl;
	} while ( (player.isAlive() && (monster1.isAlive() || monster2.isAlive()) ) && !run);
	if (run) cout << "You were sucessful in your attempt to run.\n\n";
}// end battle(Player&, Monster&, Monster&)


void battle(Player& player, Monster& monster) {
	bool run = false;
	do {
		battleSwitch(player, monster, run);
		if (monster.isAlive() && !run) attack(monster, player);
		cout << player.getStatus() << endl << endl;
		cout << monster.getStatus() << endl << endl;
	} while ((player.isAlive() && monster.isAlive()) && !run);
	if (run) cout << "You were sucessful in your attempt to run.\n\n";
}// end battle(Player&, Monster&)


string btos(bool value) {
	return value ? "true" : "false";
}// end btos(bool)



//************************************************************************************
// Main
//
//************************************************************************************

int main()
{



	
	//*********************************************************************
	// TESTING
	//
	//*********************************************************************

	// Test fillArmorArray
	Armor armory[25];
	int armorArrayIndex = -1;
	int& armoryIndex = armorArrayIndex;
	fillArmorArray(armory, armoryIndex);

	//for (int i = 0; i <= armoryIndex; i++) {
	//	cout << armory[i].toString();
	//}// end for
	//cout << endl;

	// Test fillWeaponArray
	Weapon weaponry[25];
	int weaponryArrayIndex = -1;
	int& weaponryIndex = weaponryArrayIndex;
	fillWeaponArray(weaponry, weaponryIndex);

	//for (int i = 0; i <= weaponryIndex; i++ ) {
	//	cout << weaponry[i].toString();
	//}// end for
	//cout << endl;

	// Test fillPotionsArray
	Potion potions[15];
	int potionsArrayIndex = -1;
	int& potionsIndex = potionsArrayIndex;
	fillPotionsArray(potions, potionsIndex);

	//for (int i = 0; i <= potionsIndex; i++) {
	//	cout << potions[i].toString();
	//}// end for
	//cout << endl;

	// Test Races
	Human h1 = Human();
	HalfOrc h2 = HalfOrc();
	Halfling h3 = Halfling();
	Gnome gn1 = Gnome();
	Elf e1 = Elf();
	HalfElf h4 = HalfElf();
	Dwarf d1 = Dwarf();
	Drow d2 = Drow();


	// Test Player
	Player p1("Ndayin", 10, 3, 15, 15, 15, 300, armory[4], weaponry[3], d1);

	Player p2("Talin", 10, 3, 15, 15, 15, 100, armory[6], weaponry[3], d2);

	// Test Monster
	Goblin g1(3, armory[0], weaponry[0]);

	Goblin g2(3, armory[0], weaponry[0]);

	// Test add potions to player inventory
	p1.getInventory().add(potions[0]);
	p1.getInventory().add(potions[0]);
	p1.getInventory().add(potions[1]);
	p1.getInventory().add(potions[1]);

	p2.getInventory().add(potions[0]);
	p2.getInventory().add(potions[0]);
	p2.getInventory().add(potions[0]);
	p2.getInventory().add(potions[1]);
	p2.getInventory().add(potions[1]);


	// Test adding weapons and armor to player inventory
	p1.getInventory().add(armory[0]);
	p1.getInventory().add(armory[0]);
	p1.getInventory().add(armory[0]);
	p1.getInventory().add(armory[7]);
	p1.getInventory().add(weaponry[0]);
	p1.getInventory().add(weaponry[0]);
	p1.getInventory().add(weaponry[3]);

	// Test Player.equipArmor()
	//p1.equipArmor();
	//p1.getInventory().displayInventory();

	// Test Player.equipWeapon()
	//p1.equipWeapon();
	//p1.getInventory().displayInventory();

	// Test Battle 1
	//cout << p1.toString() << endl << endl << endl << endl;
	//cout << g1.toString() << endl << endl << endl << endl;

	//battle(p1, g1);

	// Test Battle 2
	//cout << p2.toString() << endl << endl << endl << endl;
	//cout << g2.toString() << endl << endl << endl << endl;

	//battle(p2, g1, g2);

	// Inventory
	Inventory i1 = Inventory();
	i1.add(armory[1]);
	i1.add(armory[2]);
	i1.add(armory[3]);
	i1.add(armory[4]);
	i1.add(armory[5]);
	i1.add(armory[6]);
	i1.add(armory[7]);
	i1.add(armory[8]);

	i1.add(weaponry[0]);
	i1.add(weaponry[1]);
	i1.add(weaponry[2]);
	i1.add(weaponry[3]);

	i1.add(potions[0]);
	i1.add(potions[0]);
	i1.add(potions[0]);
	i1.add(potions[0]);
	i1.add(potions[1]);
	i1.add(potions[1]);
	i1.add(potions[1]);
	i1.add(potions[1]);


	// Test Merchant
	//Merchant m1 = Merchant("Tekram", i1, 1.08);
	
	//m1.greeting(p1);

	//p1.getInventory().displayInventory();



	// Test Reward
	Reward r1 = Reward();

	r1.addPotion(potions[0]);
	r1.addPotion(potions[0]);
	r1.addPotion(potions[0]);
	r1.addPotion(potions[0]);
	r1.addPotion(potions[0]);
 
	r1.addArmor(armory[1]);
	r1.addArmor(armory[2]);

	r1.addWeapon(weaponry[1]);
	r1.addWeapon(weaponry[0]);

	// Test Reward.bestowReward()
	//p1.getInventory().displayInventory();
	//r1.bestowReward(p1);
	//p1.getInventory().displayInventory();

	//cout<<r1.toString();

	// QuestItem
	QuestItem qI1 = QuestItem("Amulet of Undead Turning");
	//p1.getInventory().add(qI1);


	// Test Quest
	Quest q1 = Quest("Testing Quest Class 1", 10, g1, r1);

	//cout << "\n" << q1.getKillCount();
	//cout << q1.getIsQuestComplete() << "\n";

	Quest q2 = Quest("Testing Quest Class 2", 1, qI1, r1);
	//q2.updateCollectMissionStatus(qI1);
	//q2.updateCollectMissionStatus(qI);
	//cout << q2.getItemCount() << "\n";
	//cout << q2.getIsQuestComplete() << "\n";


	// Test Quest NPC
	QuestNPC qNPC1 = QuestNPC("The local population has suffered long enough from the goblin bandits.");

	qNPC1.addQuest(q1);
	qNPC1.addQuest(q2);

	qNPC1.interactWithPC(p1);
	//cout << btos(p1.getQuest1().getIsQuestCollect()) << endl << endl;

	p1.checkMonsterKilled(g1);
	p1.checkMonsterKilled(g1);
	p1.checkMonsterKilled(g1);
	p1.checkMonsterKilled(g1);
	p1.checkMonsterKilled(g1);
	p1.checkMonsterKilled(g1);
	p1.checkMonsterKilled(g1);
	p1.checkMonsterKilled(g1);
	p1.checkMonsterKilled(g1);
	p1.checkMonsterKilled(g1);
	//cout << p1.getQuest1().getKillCount() << "\n\n";
	
	//qNPC1.bestowReward(p1, qNPC1.getQuest1());
	//cout << btos(p1.getQuest1().getIsQuestComplete()) << endl;
	
	//cout << btos(p1.getHasQuest2()) << endl << endl;
	qNPC1.interactWithPC(p1);
	p1.addToInventory(qI1);

	//cout << btos(p1.getHasQuest2()) << endl;

	//p1.getInventory().displayInventory();A

	//p1.getInventory().displayInventory();
	qNPC1.interactWithPC(p1);

	cout << btos(p1.getQuest1().getReward().getHasRewardBeenGiven()) << endl;

	//cout << btos(p1.getQuest2().getReward().getHasRewardBeenGiven()) << endl;





	system("PAUSE");




    return 0;

}// end main

Updated 1/4/2016 at 11:23pm *** Quest System in progress