#include "C:\L\Avatars\Character.h"
Character::Character()
{
	Reset();
}
Character* Character::getThis()
{
	return this;
};
const Character& Character::operator= (const Character &other)
{
	int Counter = 0;
	if(this != &other)
	{
		sprintf(chrFirstName, "%s", other.chrFirstName);
		sprintf(chrLastName, "%s", other.chrLastName);
		Title			= other.Title;
		Sex				= other.Sex;
		Race			= other.Race;
		PortNumber		= other.PortNumber;
		Height			= other.Height;
		Weight			= other.Weight;
		Class			= other.Class;
		Str				= other.Str;
		Dex				= other.Dex;
		Con				= other.Con;
		Int				= other.Int;
		Wis				= other.Wis;
		Cha				= other.Cha;
		BirthDay		= other.BirthDay;
		BirthMonth		= other.BirthMonth;
		BirthYear		= other.BirthYear;
		Age				= other.Age;
		Health			= other.Health;
		CurrentHealth	= other.CurrentHealth;
		X = other.X; Y = other.Y; Z = other.Z;

		for(Counter = 0; Counter < NUM_EQUIP_SLOTS; Counter++)		Body[Counter]		= other.Body[Counter];
		for(Counter = 0; Counter < 4; Counter++)					mCoinPurse[Counter] = other.mCoinPurse[Counter];
		for(Counter = 0; Counter < MAX_PLAYER_SKILLS; Counter++)	Skills[Counter]		= other.Skills[Counter];

		if(getItemWorn(Backpack) > itNegOne) 
			for(Counter = 0; Counter < 12; Counter++)				mBackPack[Counter]		= other.mBackPack[Counter];
		if(getItemWorn(Transport) > itNegOne)
			for(Counter = 0; Counter < 28; Counter++)				mTransport[Counter]		= other.mTransport[Counter];
		if(getItemWorn(Pouch_01) > itNegOne)
			for(Counter = 0; Counter < 6; Counter++)				mPouches[0][Counter]	= other.mPouches[0][Counter];
		if(getItemWorn(Pouch_02) > itNegOne)
			for(Counter = 0; Counter < 6; Counter++)				mPouches[1][Counter]	= other.mPouches[1][Counter];
		if(getItemWorn(Pouch_03) > itNegOne)
			for(Counter = 0; Counter < 6; Counter++)				mPouches[2][Counter]	= other.mPouches[2][Counter];
		if(getItemWorn(Pouch_04) > itNegOne)
			for(Counter = 0; Counter < 6; Counter++)				mPouches[3][Counter]	= other.mPouches[3][Counter];
		if(getItemWorn(Pouch_05) > itNegOne)
			for(Counter = 0; Counter < 6; Counter++)				mPouches[4][Counter]	= other.mPouches[4][Counter];
		if(getItemWorn(Pouch_06) > itNegOne)
			for(Counter = 0; Counter < 6; Counter++)				mPouches[5][Counter]	= other.mPouches[5][Counter];

		LastSkillLeft	= other.LastSkillLeft;
		LastSkillRight	= other.LastSkillRight;

		Level			= other.Level;
		NumSkills		= other.NumSkills;
	
		facing			= other.facing;
		PVP_Status		= other.PVP_Status;

		Mounted			= other.Mounted;
		NPC_Mode		= other.NPC_Mode;
		WarMode			= other.WarMode;
		Standing		= other.Standing;

		textRed			= other.textRed;
		textGreen		= other.textGreen;
		textBlue		= other.textBlue;

		Created			= other.Created;

		//Targeting stuff--------------
		TargetWMX		= other.TargetWMX;
		TargetWMY		= other.TargetWMY;
		TargetAnimate	= other.TargetAnimate;
		TargetType		= other.TargetType;
		//-----------------------------
		
		ID				= other.ID;
		RunTimer		= other.RunTimer;
		CurRunTimer		= other.CurRunTimer;

		numStatRolls	= other.numStatRolls;
	}//end: if(this != &other)

	return *this;
}
const Character* Character::operator= (const Character *other)
{
	int Counter;
	if(this != other)
	{
		Title			= other->Title;
		Sex				= other->Sex;
		Race			= other->Race;
		PortNumber		= other->PortNumber;
		Weight			= other->Weight;
		Height			= other->Height;
		Class			= other->Class;
		Str				= other->Str;
		Dex				= other->Dex;
		Con				= other->Con;
		Int				= other->Int;
		Wis				= other->Wis;
		Cha				= other->Cha;
		BirthDay		= other->BirthDay;
		BirthMonth		= other->BirthMonth;
		BirthYear		= other->BirthYear;
		Age				= other->Age;
		Health			= other->Health;
		CurrentHealth	= other->CurrentHealth;
		X = other->X; Y = other->Y; Z = other->Z;

		for(Counter = 0; Counter < NUM_EQUIP_SLOTS; Counter++)		Body[Counter]		= other->Body[Counter];
		for(Counter = 0; Counter < 4; Counter++)					mCoinPurse[Counter] = other->mCoinPurse[Counter];
		for(Counter = 0; Counter < MAX_PLAYER_SKILLS; Counter++)	Skills[Counter]		= other->Skills[Counter];
		
		if(getItemWorn(Backpack) > itNegOne) 
			for(Counter = 0; Counter < 12; Counter++)				mBackPack[Counter]		= other->mBackPack[Counter];
		if(getItemWorn(Transport) > itNegOne)
			for(Counter = 0; Counter < 28; Counter++)				mTransport[Counter]		= other->mTransport[Counter];
		if(getItemWorn(Pouch_01) > itNegOne)
			for(Counter = 0; Counter < 6; Counter++)				mPouches[0][Counter]	= other->mPouches[0][Counter];
		if(getItemWorn(Pouch_02) > itNegOne)
			for(Counter = 0; Counter < 6; Counter++)				mPouches[1][Counter]	= other->mPouches[1][Counter];
		if(getItemWorn(Pouch_03) > itNegOne)
			for(Counter = 0; Counter < 6; Counter++)				mPouches[2][Counter]	= other->mPouches[2][Counter];
		if(getItemWorn(Pouch_04) > itNegOne)
			for(Counter = 0; Counter < 6; Counter++)				mPouches[3][Counter]	= other->mPouches[3][Counter];
		if(getItemWorn(Pouch_05) > itNegOne)
			for(Counter = 0; Counter < 6; Counter++)				mPouches[4][Counter]	= other->mPouches[4][Counter];
		if(getItemWorn(Pouch_06) > itNegOne)
			for(Counter = 0; Counter < 6; Counter++)				mPouches[5][Counter]	= other->mPouches[5][Counter];

		LastSkillLeft	= other->LastSkillLeft;
		LastSkillRight	= other->LastSkillRight;

		Level		= other->Level;
		NumSkills	= other->NumSkills;

		facing		= other->facing;
		PVP_Status	= other->PVP_Status;

		Mounted		= other->Mounted;
		NPC_Mode	= other->NPC_Mode;
		WarMode		= other->WarMode;
		Standing	= other->Standing;

		textRed		= other->textRed;
		textGreen	= other->textGreen;
		textBlue	= other->textBlue;

		Created		= other->Created;

		//Targeting stuff--------------
		TargetWMX		= other->TargetWMX;
		TargetWMY		= other->TargetWMY;
		TargetAnimate	= other->TargetAnimate;
		TargetType		= other->TargetType;
		//-----------------------------
		
		ID				= other->ID;
		RunTimer		= other->RunTimer;
		CurRunTimer		= other->CurRunTimer;

		numStatRolls	= other->numStatRolls;
	}

	return this;
}
bool Character::operator== (const Character &other)
{
	if(ID == other.ID) return true; else return false;
}
void Character::Reset()
{
	int Counter = 0;

	Created	= false;
	sprintf(chrFirstName, "Type to Create Name");
	sprintf(chrLastName, "");
	transferString = "";
	Title = 0;
	Class = Warrior;
	Height = 0;
	Weight = 0;
	BirthDay = 0;
	BirthMonth = 0;
	BirthYear = 0;
	Age = 0;
	Sex = FEMALE;//Want the game to appeal to more female players as they'll be the 'long term' players - M. White 9 April, 2019
	Race = rHuman;
	PortNumber = 1;
	X = Y = Z = 0;
	MyOffSetX = MyOffSetY = Tick = facing = 0;
	Speed = 4;	//should never be below '1' (0)
	Str = Dex = Con = Wis = Cha = Com = tStr = tDex = tCon = tInt = tWis = tCha = tCom = 1;
	Int = 1;//Int set to 3 to allow for default two skills
	textRed	= textGreen	= textBlue = 0;
	resetSkills();
	LastSkillLeft = -1;
	LastSkillRight = -1;

	for(Counter = 0; Counter < NUM_EQUIP_SLOTS; Counter++) Body[Counter].Reset();	//Reset Worn Items
	Body[HandLeft].SetWhat(itHeld); Body[HandRight].SetWhat(itHeld);	
	for(Counter = 0; Counter < 28; Counter++) mTransport[Counter].Reset();			//Reset the Transport
	for(Counter = 0; Counter < 12; Counter++) mBackPack[Counter].Reset();			//Reset the Backpack
	//Reset the Pouches (x6)
	for(Counter = 0; Counter < 6; Counter++) for(int i = 0; i < 6; i++) mPouches[Counter][i].Reset();
	//reset the Coin Purse
	for(Counter = 0; Counter < 4; Counter++) { mCoinPurse[Counter].SetWhat(-1); mCoinPurse[Counter].SetNumber(0); }
	WarMode	= false;
	NPC_Mode = false;
	Moving = false;
	Status = OldStatus = STAND_NORMAL;
	Standing = true;
	Mounted = 0;
	CastingSpell = false;
	SittingTable = false;
	UsingSkill = false;
	RepeatSkill	= false;
	Health = CurrentHealth = 0;
	PVP_Status = 0;
	ID = -1;
	RunTimer = 0;
	//Targeting stuff--------------
	TargetOccupant = NULL;
	TargetItem = NULL;
	TargetWMX = -1;
	TargetWMY = -1;
	TargetAnimate = 0;
	TargetType = -1;
	//-----------------------------

	numStatRolls	= 0;
	intXP_BonusMod	= 0;
	dblXP_BonusMod	= 0;
}//end: Reset()
void Character::setCreated(bool data)
{
	Created = data;
}
bool Character::getCreated() const
{
	return Created;
}
void Character::setTitle(int data)
{
	if(data < 0 || data > 100) Title = 0; else Title = data;
}
int Character::getTitle() const
{
	return Title;
};
void Character::setStrFirstName(string data)
{
	transferString = data;
	if(transferString.length() > 0) sprintf(chrFirstName, "%s", transferString.c_str());
	else							sprintf(chrFirstName, "");
}
string Character::getStrFirstName()
{
	if(int(strlen(chrFirstName)) > 0) { transferString = chrFirstName; return transferString; }
	else return "";
}
void Character::setStrLastName(string data)
{
	transferString = data;
	if(transferString.length() > 0) sprintf(chrLastName, "%s", transferString.c_str());
}
string Character::getStrLastName()
{
	if(int(strlen(chrLastName)) > 0) { transferString = chrLastName; return transferString; }
	else return "";
}
void Character::setID(int data)
{
	ID = data;
}
int Character::getID() const
{
	return ID;
}
void Character::setRace(int i)
{
	Race = i;
}
int Character::getRace() const
{
	return int(Race);
}
string Character::getRaceName(int ir) const
{
	//These values declared at the top of Character.h
	if		(ir < rGoat)//34
	{
		if(ir < rCat)//12
		{
			if(ir < rBeaver)//7
			{
				if		(ir == rAntelope)		return "Antelope";			// 1
				else if	(ir == rBadger)			return "Badger";			// 2
				else if	(ir == rBanshee)		return "Banshee";			// 3
				else if	(ir == rBasilisk)		return "Basilisk";			// 4
				else if	(ir == rBat)			return "Bat";				// 5
				else if	(ir == rBear)			return "Bear";				// 6
			}
			else
			{
				if		(ir == rBeaver)			return "Beaver";			// 7
				else if	(ir == rBird)			return "Bird";				// 8
				else if	(ir == rBrownie)		return "Brownie";			// 9
				else if	(ir == rBuffalo)		return "Buffalo";			// 10
				else if	(ir == rBugbear)		return "Bugbear";			// 11
			}
		}
		else if (ir < rDwarf)//23
		{
			if(ir < rCrocodile)//18
			{
				if		(ir == rCat)			return "Cat";				// 12
				else if	(ir == rCattle)			return "Cattle";			// 13
				else if	(ir == rCentaur)		return "Centaur";			// 14
				else if	(ir == rChimera)		return "Chimera";			// 15
				else if	(ir == rChipmunk)		return "Chipmunk";			// 16
				else if	(ir == rCockatrice)		return "Cockatrice";		// 17
			}
			else
			{
				if		(ir == rCrocodile)		return "Crocodile";			// 18
				else if	(ir == rDog)			return "Dog";				// 19
				else if	(ir == rDolphin)		return "Dolphin";			// 20
				else if	(ir == rDragon)			return "Dragon";			// 21
				else if	(ir == rDryad)			return "Dryad";				// 22
			}
		}
		else
		{
			if(ir < rGenie)//29
			{
				if		(ir == rDwarf)			return "Dwarf";				// 23
				else if	(ir == rElf)			return "Elf";				// 24
				else if	(ir == rErmine)			return "Ermine";			// 25
				else if	(ir == rFerret)			return "Ferret";			// 26
				else if	(ir == rFox)			return "Fox";				// 27
				else if	(ir == rGargoyle)		return "Gargoyle";			// 28
			}
			else
			{
				if		(ir == rGenie)			return "Genie";				// 29
				else if	(ir == rGhost)			return "Ghost";				// 30
				else if	(ir == rGhoul)			return "Ghoul";				// 31
				else if	(ir == rGiant)			return "Giant";				// 32
				else if	(ir == rGnome)			return "Gnome";				// 33
			}
		}
	}//end: if (ir < rGoat)//34
	else if (ir < rPorcupine)//67
	{
		if(ir < rHuman)//45
		{
			if(ir < rHag)//40
			{
				if		(ir == rGoat)			return "Goat";				// 34
				else if	(ir == rGoblin)			return "Goblin";			// 35
				else if	(ir == rGopher)			return "Gopher";			// 36
				else if	(ir == rGorilla)		return "Gorilla";			// 37
				else if	(ir == rGremlin)		return "Gremlin";			// 38
				else if	(ir == rGriffon)		return "Griffon";			// 39
			}
			else
			{
				if		(ir == rHag)			return "Hag";				// 40
				else if	(ir == rHalfElf)		return "Half Elf";			// 41
				else if	(ir == rHalfling)		return "Halfling";			// 42
				else if	(ir == rHarpy)			return "Harpy";				// 43
				else if	(ir == rHedgehog)		return "Hedgehog";			// 44
				else if	(ir == rHobgoblin)		return "Hobgoblin";			// 45
				else if	(ir == rHorse)			return "Horse";				// 46
			}
		}
		else if (ir < rNymph)//56
		{
			if(ir < rMinotaur)//51
			{
				if		(ir == rHuman)			return "Human";				// 47
				else if	(ir == rHydra)			return "Hydra";				// 48
				else if	(ir == rImp)			return "Imp";				// 49
				else if	(ir == rLeprechaun)		return "Leprechaun";		// 50
				else if	(ir == rMermaid)		return "Mermaid";			// 51
				else if	(ir == rMink)			return "Mink";				// 52
			}
			else
			{
				if		(ir == rMinotaur)		return "Minotaur";			// 53
				else if	(ir == rMole)			return "Mole";				// 54
				else if	(ir == rMouse)			return "Mouse";				// 55
				else if	(ir == rMummy)			return "Mummy";				// 56
				else if	(ir == rMuskrat)		return "Muskrat";			// 57
			}
		}
		else
		{
			if(ir < rPhantom)//62
			{
				if		(ir == rNymph)			return "Nymph";				// 58
				else if	(ir == rOctopus)		return "Octopus";			// 59
				else if	(ir == rOgre)			return "Ogre";				// 60
				else if	(ir == rOpossum)		return "Opossum";			// 61
				else if	(ir == rOtter)			return "Otter";				// 62
				else if	(ir == rOtterSea)		return "Sea Otter";			// 63
			}
			else
			{
				if		(ir == rPhantom)		return "Phantom";			// 64
				else if	(ir == rPhoenix)		return "Phoenix";			// 65
				else if	(ir == rPigDom)			return "Domestic Pig";		// 66
				else if	(ir == rPigWild)		return "Wild Pig";			// 67
				else if	(ir == rPoltergeist)	return "Poltergeist";		// 68
			}
		}
	}//end: else if (ir < rPorcupine)//67
	else
	{
		if(ir < rSphinx)//78
		{
			if(ir < rSiren)//73
			{
				if		(ir == rPorcupine)		return "Porcupine";			// 69
				else if	(ir == rRabbit)			return "Rabbit";			// 70
				else if	(ir == rRaccoon)		return "Raccoon";			// 71
				else if	(ir == rRat)			return "Rat";				// 72
				else if	(ir == rScorpion)		return "Scorpion";			// 73
				else if	(ir == rSheep)			return "Sheep";				// 74
			}
			else
			{
				if		(ir == rSiren)			return "Siren";				// 75
				else if	(ir == rSkeleton)		return "Skeleton";			// 76
				else if	(ir == rSkunk)			return "Skunk";				// 77
				else if	(ir == rSnake)			return "Snake";				// 78
				else if	(ir == rSpectre)		return "Spectre";			// 79
			}
		}
		else if (ir < rWeasel)
		{
			if(ir < rTitan)//84
			{
				if		(ir == rSphinx)			return "Sphinx";			// 80
				else if	(ir == rSpider)			return "Spider";			// 81
				else if	(ir == rSprite)			return "Sprite";			// 82
				else if	(ir == rSquid)			return "Squid";				// 83
				else if	(ir == rSquirrel)		return "Squirrel";			// 84
				else if	(ir == rSquirrelFly)	return "Flying Squirrel";	// 85
			}
			else
			{
				if		(ir == rTitan)			return "Titan";				// 86
				else if	(ir == rTroll)			return "Troll";				// 87
				else if	(ir == rUnicorn)		return "Unicorn";			// 88
				else if	(ir == rVampire)		return "Vampire";			// 89
				else if	(ir == rWarthog)		return "Warthog";			// 90
			}
		}
		else
		{
			if(ir < rWolf)//95
			{
				if		(ir == rWeasel)			return "Weasel";			// 91
				else if	(ir == rWildBoar)		return "Wild Boar";			// 92
				else if	(ir == rWildStag)		return "Wild Stag";			// 93
				else if	(ir == rWillWisp)		return "Will o'wisp";		// 94
				else if	(ir == rWolverine)		return "Wolverine";			// 95
				else if	(ir == rWoodchuck)		return "Woodchuck";			// 96
			}
			else
			{
				if		(ir == rWolf)			return "Wolf";				// 97
				else if	(ir == rWraith)			return "Wraith";			// 98
				else if	(ir == rYeti)			return "Yeti";				// 99
				else if	(ir == rZombie)			return "Zombie";			// 100
			}
		}
	}//end: else
	return "MobNameError";
}
string Character::getRaceBaseID() const
{
	//Don't break this if-else checks down from the current format. It's imparitive 
	//that these don't have an error as this function is used to save data to file. 
	//Isn't time sensitive as this is primarily used during Server Shut Down.
	if		(Race == rAntelope)		return "rAntelope";			else if	(Race == rBadger)		return "rBadger";
	else if	(Race == rBanshee)		return "rBanshee";			else if	(Race == rBasilisk)		return "rBasilisk";
	else if	(Race == rBat)			return "rBat";				else if	(Race == rBear)			return "rBear";
	else if	(Race == rBeaver)		return "rBeaver";			else if	(Race == rBird)			return "rBird";
	else if	(Race == rBrownie)		return "rBrownie";			else if	(Race == rBuffalo)		return "rBuffalo";
	else if	(Race == rBugbear)		return "rBugbear";			else if	(Race == rCat)			return "rCat";
	else if	(Race == rCattle)		return "rCattle";			else if	(Race == rCentaur)		return "rCentaur";
	else if	(Race == rChimera)		return "rChimera";			else if	(Race == rChipmunk)		return "rChipmunk";
	else if	(Race == rCockatrice)	return "rCockatrice";		else if	(Race == rCrocodile)	return "rCrocodile";
	else if	(Race == rDog)			return "rDog";				else if	(Race == rDolphin)		return "rDolphin";
	else if	(Race == rDragon)		return "rDragon";			else if	(Race == rDryad)		return "rDryad";
	else if	(Race == rDwarf)		return "rDwarf";			else if	(Race == rElf)			return "rElf";
	else if	(Race == rErmine)		return "rErmine";			else if	(Race == rFerret)		return "rFerret";
	else if	(Race == rFox)			return "rFox";				else if	(Race == rGargoyle)		return "rGargoyle";
	else if	(Race == rGenie)		return "rGenie";			else if	(Race == rGhost)		return "rGhost";
	else if	(Race == rGhoul)		return "rGhoul";			else if	(Race == rGiant)		return "rGiant";
	else if	(Race == rGnome)		return "rGnome";			else if	(Race == rGoat)			return "rGoat";
	else if	(Race == rGoblin)		return "rGoblin";			else if	(Race == rGopher)		return "rGopher";
	else if	(Race == rGorilla)		return "rGorilla";			else if	(Race == rGremlin)		return "rGremlin";
	else if	(Race == rGriffon)		return "rGriffon";			else if	(Race == rHag)			return "rHag";
	else if	(Race == rHarpy)		return "rHarpy";			else if	(Race == rHedgehog)		return "rHedgehog";
	else if	(Race == rHorse)		return "rHorse";			else if	(Race == rHuman)		return "rHuman";
	else if	(Race == rHydra)		return "rHydra";			else if	(Race == rImp)			return "rImp";
	else if	(Race == rLeprechaun)	return "rLeprechaun";		else if	(Race == rMermaid)		return "rMermaid";
	else if	(Race == rMink)			return "rMink";				else if	(Race == rMinotaur)		return "rMinotaur";
	else if	(Race == rMole)			return "rMole";				else if	(Race == rMouse)		return "rMouse";
	else if	(Race == rMummy)		return "rMummy";			else if	(Race == rMuskrat)		return "rMuskrat";
	else if	(Race == rNymph)		return "rNymph";			else if	(Race == rOctopus)		return "rOctopus";
	else if	(Race == rOgre)			return "rOgre";				else if	(Race == rOpossum)		return "rOpossum";
	else if	(Race == rOtter)		return "rOtter";			else if	(Race == rOtterSea)		return "rOtterSea";
	else if	(Race == rPhantom)		return "rPhantom";			else if	(Race == rPhoenix)		return "rPhoenix";
	else if	(Race == rPigDom)		return "rPigDom";			else if	(Race == rPigWild)		return "rPigWild";
	else if	(Race == rPoltergeist)	return "rPoltergeist";		else if	(Race == rPorcupine)	return "rPorcupine";
	else if	(Race == rRabbit)		return "rRabbit";			else if	(Race == rRaccoon)		return "rRaccoon";
	else if	(Race == rRat)			return "rRat";				else if	(Race == rScorpion)		return "rScorpion";
	else if	(Race == rSheep)		return "rSheep";			else if	(Race == rSiren)		return "rSiren";
	else if	(Race == rSkeleton)		return "rSkeleton";			else if	(Race == rSkunk)		return "rSkunk";
	else if	(Race == rSnake)		return "rSnake";			else if	(Race == rSpectre)		return "rSpectre";
	else if	(Race == rSphinx)		return "rSphinx";			else if	(Race == rSpider)		return "rSpider";
	else if	(Race == rSprite)		return "rSprite";			else if	(Race == rSquid)		return "rSquid";
	else if	(Race == rSquirrel)		return "rSquirrel";			else if	(Race == rSquirrelFly)	return "rSquirrelFly";
	else if	(Race == rTitan)		return "rTitan";			else if	(Race == rTroll)		return "rTroll";
	else if	(Race == rUnicorn)		return "rUnicorn";			else if	(Race == rVampire)		return "rVampire";
	else if	(Race == rWarthog)		return "rWarthog";			else if	(Race == rWeasel)		return "rWeasel";
	else if	(Race == rWildBoar)		return "rWildBoar";			else if	(Race == rWildStag)		return "rWildStag";
	else if	(Race == rWillWisp)		return "rWillWisp";			else if	(Race == rWolverine)	return "rWolverine";
	else if	(Race == rWoodchuck)	return "rWoodchuck";		else if	(Race == rWolf)			return "rWolf";
	else if	(Race == rWraith)		return "rWraith";			else if	(Race == rYeti)			return "rYeti";
	else if	(Race == rZombie)		return "rZombie";			else							return "rNone";
}
void Character::SERVsetRaceViaID(string ir)
{
	Body[Backpack].SetWhat(itBP_02);
	if		(ir == "rAntelope")
	{ 
		Race = rAntelope; 
		mBackPack[0].SetWhat(itAnteHorn);	mBackPack[0].SetNumber(2);
		mBackPack[1].SetWhat(itAnteHide);	mBackPack[1].SetNumber(1);
		mBackPack[2].SetWhat(itAnteMeat);	mBackPack[2].SetNumber((rand() % 3) + 1);
	} 
	else if	(ir == "rBadger")
	{
		Race = rBadger; 
		mBackPack[0].SetWhat(itBadgClaw);	mBackPack[0].SetNumber(2);
		mBackPack[1].SetWhat(itBadgHide);	mBackPack[1].SetNumber(1);
		mBackPack[2].SetWhat(itBadgMeat);	mBackPack[2].SetNumber(1);
	} 
	else if	(ir == "rBanshee")
	{
		Race = rBanshee;//Nothing carried
	} 
	else if	(ir == "rBasilisk")
	{
		Race = rBasilisk;
		mBackPack[0].SetWhat(itBasiClaw);	mBackPack[0].SetNumber(2);
		mBackPack[1].SetWhat(itBasiHide);	mBackPack[1].SetNumber(1);
		mBackPack[2].SetWhat(itBasiMeat);	mBackPack[2].SetNumber((rand() % 5) + 1);
		mBackPack[3].SetWhat(itBasiTeet);	mBackPack[3].SetNumber(1);
	} 
	else if	(ir == "rBat")	
	{
		Race = rBat;
		mBackPack[0].SetWhat(itBatWing);	mBackPack[0].SetNumber(2);
		mBackPack[1].SetWhat(itBatHide);	mBackPack[1].SetNumber(1);
		mBackPack[2].SetWhat(itBatEar);		mBackPack[2].SetNumber(2);
	}
	else if	(ir == "rBear")	
	{
		Race = rBear;
		mBackPack[0].SetWhat(itBearClaw);	mBackPack[0].SetNumber(2);
		mBackPack[1].SetWhat(itBearHide);	mBackPack[1].SetNumber(1);
		mBackPack[2].SetWhat(itBearMeat);	mBackPack[2].SetNumber((rand() % 3) + 1);
	}
	else if	(ir == "rBeaver")
	{
		Race = rBeaver;
		mBackPack[0].SetWhat(itBeavTail);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itBeavHide);	mBackPack[1].SetNumber(1);
		mBackPack[2].SetWhat(itBeavMeat);	mBackPack[2].SetNumber(1);	
	} 
	else if	(ir == "rBird")
	{
		Race = rBird;
		mBackPack[0].SetWhat(itBirdBeak);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itBirFeath);	mBackPack[1].SetNumber((rand() % 10) + 1);
		mBackPack[2].SetWhat(itBirdMeat);	mBackPack[2].SetNumber(1);	
	}
	else if	(ir == "rBrownie")
	{
		Race = rBrownie;
		mBackPack[0].SetWhat(itBrowHair);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itBrowEar);	mBackPack[1].SetNumber(2);
	}
	else if	(ir == "rBuffalo")
	{
		Race = rBuffalo;
		mBackPack[0].SetWhat(itBuffHorn);	mBackPack[0].SetNumber(2);
		mBackPack[1].SetWhat(itBuffHide);	mBackPack[1].SetNumber(1);
		mBackPack[2].SetWhat(itBuffMeat);	mBackPack[2].SetNumber((rand() % 4) + 1);
	} 
	else if	(ir == "rBugbear")
	{
		Race = rBugbear;
		mBackPack[0].SetWhat(itBugbHair);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itBugbEar);	mBackPack[1].SetNumber(2);
	}
	else if	(ir == "rCat")	
	{
		Race = rCat;
		mBackPack[0].SetWhat(itCatEye);		mBackPack[0].SetNumber(2);
		mBackPack[1].SetWhat(itCatHide);	mBackPack[1].SetNumber(1);
		mBackPack[2].SetWhat(itCatMeat);	mBackPack[2].SetNumber(1);
		mBackPack[3].SetWhat(itCatEar);		mBackPack[3].SetNumber(2);	
	} 
	else if	(ir == "rCattle")
	{
		Race = rCattle;
		mBackPack[0].SetWhat(itCattHorn);	mBackPack[0].SetNumber(2);
		mBackPack[1].SetWhat(itCattHide);	mBackPack[1].SetNumber(1);
		mBackPack[2].SetWhat(itCattMeat);	mBackPack[2].SetNumber((rand() % 4) + 1);
	}
	else if	(ir == "rCentaur")
	{
		Race = rCentaur;
		mBackPack[0].SetWhat(itCentTail);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itCentHide);	mBackPack[1].SetNumber(1);
		mBackPack[2].SetWhat(itCentHair);	mBackPack[2].SetNumber(1);
		mBackPack[3].SetWhat(itCentEar);	mBackPack[3].SetNumber(2);
	}
	else if	(ir == "rChimera")
	{
		Race = rChimera;
		mBackPack[0].SetWhat(itChimWing);	mBackPack[0].SetNumber(2);
		mBackPack[1].SetWhat(itChimHide);	mBackPack[1].SetNumber(1);
		mBackPack[2].SetWhat(itChimTail);	mBackPack[2].SetNumber(1);	
	} 
	else if	(ir == "rChipmunk")	
	{
		Race = rChipmunk;
		mBackPack[0].SetWhat(itChipMeat);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itChipHide);	mBackPack[1].SetNumber(1);
	} 
	else if	(ir == "rCockatrice")
	{
		Race = rCockatrice;
		mBackPack[0].SetWhat(itCocFeath);	mBackPack[0].SetNumber((rand() % 5) + 1);
		mBackPack[1].SetWhat(itCockBeak);	mBackPack[1].SetNumber(1);
		mBackPack[2].SetWhat(itCockMeat);	mBackPack[2].SetNumber((rand() % 3) + 1);	
	} 
	else if	(ir == "rCrocodile")
	{
		Race = rCrocodile;
		mBackPack[0].SetWhat(itCrocTeet);	mBackPack[0].SetNumber(2);
		mBackPack[1].SetWhat(itCrocHide);	mBackPack[1].SetNumber(1);
		mBackPack[2].SetWhat(itCrocMeat);	mBackPack[2].SetNumber((rand() % 4) + 1);
	} 
	else if	(ir == "rDog")		
	{
		Race = rDog;
		mBackPack[0].SetWhat(itDogHide);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itDogMeat);	mBackPack[1].SetNumber(2);
	} 
	else if	(ir == "rDolphin")
	{
		Race = rDolphin;	
		mBackPack[0].SetWhat(itDolpHide);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itDolpSnout);	mBackPack[1].SetNumber(1);
		mBackPack[2].SetWhat(itDolpMeat);	mBackPack[2].SetNumber((rand() % 3) + 1);
	}
	else if	(ir == "rDragon")	
	{
		Race = rDragon;	
		mBackPack[0].SetWhat(itDragClaw);	mBackPack[0].SetNumber(2);
		mBackPack[1].SetWhat(itDragHide);	mBackPack[1].SetNumber(1);
		mBackPack[2].SetWhat(itDragHorn);	mBackPack[2].SetNumber(2);
		mBackPack[3].SetWhat(itDragEye);	mBackPack[3].SetNumber(2);
	} 
	else if	(ir == "rDryad")
	{
		Race = rDryad;	
		mBackPack[0].SetWhat(itDryadHai);	mBackPack[0].SetNumber(1);
		mBackPack[0].SetWhat(itWoodSpir);	mBackPack[0].SetNumber(1);
	} 
	else if	(ir == "rDwarf")
	{
		Race = rDwarf;
		mBackPack[0].SetWhat(itDwarfHai);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itDwarfEar);	mBackPack[1].SetNumber(2);
		mBackPack[2].SetWhat(itDwarfArm);	mBackPack[2].SetNumber(2);
	} 
	else if	(ir == "rElf")	
	{
		Race = rElf;	
		mBackPack[0].SetWhat(itElfHair);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itElfEar);		mBackPack[1].SetNumber(2);
		mBackPack[2].SetWhat(itElfEye);		mBackPack[2].SetNumber(2);
		mBackPack[3].SetWhat(itElfArms);	mBackPack[3].SetNumber(2);
		mBackPack[4].SetWhat(itElfLeg);		mBackPack[4].SetNumber(2);
	} 
	else if	(ir == "rErmine")
	{
		Race = rErmine;	
		mBackPack[0].SetWhat(itErmiHide);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itErmiMeat);	mBackPack[1].SetNumber(1);
	} 
	else if	(ir == "rFerret")
	{
		Race = rFerret;	
		mBackPack[0].SetWhat(itFerrHide);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itFerrMeat);	mBackPack[1].SetNumber(1);
	} 
	else if	(ir == "rFox")	
	{
		Race = rFox;	
		mBackPack[0].SetWhat(itFoxHide);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itFoxMeat);	mBackPack[1].SetNumber(1);
	}
	else if	(ir == "rGargoyle")	
	{
		Race = rGargoyle;
		mBackPack[0].SetWhat(itGargHide);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itGargWing);	mBackPack[1].SetNumber(2);
	} 
	else if	(ir == "rGenie")	
	{
		Race = rGenie;
		mBackPack[0].SetWhat(itAirEssen);	mBackPack[0].SetNumber(1);
	}	
	else if	(ir == "rGhost")
	{
		Race = rGhost;//Nothing
	} 
	else if	(ir == "rGhoul")
	{
		Race = rGhoul;	
		mBackPack[0].SetWhat(itGhouHair);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itGhouHide);	mBackPack[1].SetNumber(1);
	} 
	else if	(ir == "rGiant")
	{
		Race = rGiant;	
		mBackPack[0].SetWhat(itGianHair);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itGianEar);	mBackPack[1].SetNumber(2);
		mBackPack[2].SetWhat(itGianHide);	mBackPack[2].SetNumber(1);
	}
	else if	(ir == "rGnome")
	{
		Race = rGnome;
		mBackPack[0].SetWhat(itGnomHair);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itGnomNose);	mBackPack[1].SetNumber(1);
	} 
	else if	(ir == "rGoat")	
	{
		Race = rGoat;	
		mBackPack[0].SetWhat(itGoatHorn);	mBackPack[0].SetNumber(2);
		mBackPack[1].SetWhat(itGoatHide);	mBackPack[1].SetNumber(2);
		mBackPack[2].SetWhat(itGoatMeat);	mBackPack[2].SetNumber((rand() % 2) + 1);
	}
	else if	(ir == "rGoblin")
	{
		Race = rGoblin;	
		mBackPack[0].SetWhat(itGoblHair);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itGoblEar);	mBackPack[1].SetNumber(2);
	}
	else if	(ir == "rGopher")
	{
		Race = rGopher;	
		mBackPack[0].SetWhat(itGophHide);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itGophMea);	mBackPack[1].SetNumber(1);
	} 
	else if	(ir == "rGorilla")
	{
		Race = rGorilla;
		mBackPack[0].SetWhat(itGoriArm);	mBackPack[0].SetNumber(2);
		mBackPack[1].SetWhat(itGoriHide);	mBackPack[1].SetNumber(1);
		mBackPack[2].SetWhat(itGoriHair);	mBackPack[2].SetNumber(1);
		mBackPack[3].SetWhat(itGoriMeat);	mBackPack[3].SetNumber((rand() % 2) + 1);
	}
	else if	(ir == "rGremlin")
	{
		Race = rGremlin;
		mBackPack[0].SetWhat(itGremHide);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itGremClaw);	mBackPack[1].SetNumber(2);
	} 
	else if	(ir == "rGriffon")
	{
		Race = rGriffon;
		mBackPack[0].SetWhat(itGrifHide);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itGrifFeath);	mBackPack[1].SetNumber((rand() % 10) + 1);
		mBackPack[2].SetWhat(itGrifTail);	mBackPack[2].SetNumber(1);
	} 
	else if	(ir == "rHag")	
	{
		Race = rHag;
		mBackPack[0].SetWhat(itHagHand);	mBackPack[0].SetNumber(2);
	} 
	else if	(ir == "rHarpy")
	{
		Race = rHarpy;
		mBackPack[0].SetWhat(itHarpFeath);	mBackPack[0].SetNumber(2);
		mBackPack[1].SetWhat(itHarpyClaw);	mBackPack[1].SetNumber((rand() % 4) + 2);
		mBackPack[2].SetWhat(itHarpyHead);	mBackPack[2].SetNumber(2);
	} 
	else if	(ir == "rHedgehog")	
	{
		Race = rHedgehog;
		mBackPack[0].SetWhat(itHedgeHide);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itHedgeMeat);	mBackPack[1].SetNumber(1);
	} 
	else if	(ir == "rHobgoblin")
	{
		Race = rHobgoblin;
		mBackPack[0].SetWhat(itHobgoHair);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itHobgoEar);	mBackPack[1].SetNumber(2);
	}
	else if	(ir == "rHorse")
	{
		Race = rHorse;
		mBackPack[0].SetWhat(itHorseHide);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itHorseMeat);	mBackPack[1].SetNumber((rand() % 4) + 1);
		mBackPack[2].SetWhat(itHorseTail);	mBackPack[2].SetNumber(1);
	} 
	else if	(ir == "rHuman")
	{
		Race = rHuman;
		mBackPack[0].SetWhat(itHumanHair);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itHumanEar);	mBackPack[1].SetNumber(2);
		mBackPack[2].SetWhat(itHumanHead);	mBackPack[2].SetNumber(1);
	} 
	else if	(ir == "rHydra")	
	{
		Race = rHydra;
		mBackPack[0].SetWhat(itHydraHide);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itHydraTail);	mBackPack[1].SetNumber(1);
	} 
	else if	(ir == "rImp")		
	{
		Race = rImp;
		mBackPack[0].SetWhat(itImpHide);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itImpWing);	mBackPack[1].SetNumber(2);
	} 
	else if	(ir == "rLeprechaun")
	{
		Race = rLeprechaun;
		mBackPack[0].SetWhat(itLepreHair);	mBackPack[0].SetNumber(1);		
	}
	else if	(ir == "rMermaid")
	{
		Race = rMermaid;
		mBackPack[0].SetWhat(itMermaHair);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itMermaScal);	mBackPack[1].SetNumber((rand() % 3) + 1);
	} 
	else if	(ir == "rMink")	
	{
		Race = rMink;
		mBackPack[0].SetWhat(itMinkHide);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itMinkMeat);	mBackPack[1].SetNumber(1);
	} 
	else if	(ir == "rMinotaur")	
	{
		Race = rMinotaur;
		mBackPack[0].SetWhat(itMinotHorn);	mBackPack[0].SetNumber(2);
		mBackPack[1].SetWhat(itMinotHead);	mBackPack[1].SetNumber(2);
	} 
	else if	(ir == "rMole")		
	{
		Race = rMole;
		mBackPack[0].SetWhat(itMoleHide);	mBackPack[0].SetNumber(1);
	} 
	else if	(ir == "rMouse")	
	{
		Race = rMouse;
		mBackPack[0].SetWhat(itMouseHide);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itMouseTail);	mBackPack[1].SetNumber(1);
	} 
	else if	(ir == "rMummy")	
	{
		Race = rMummy;
		mBackPack[0].SetWhat(itMummyRag);	mBackPack[0].SetNumber((rand() % 3) + 1);
		mBackPack[1].SetWhat(itMummyFles);	mBackPack[1].SetNumber(1);
	} 
	else if	(ir == "rMuskrat")	
	{
		Race = rMuskrat;
		mBackPack[0].SetWhat(itMuskrHide);	mBackPack[0].SetNumber(1);		
	} 
	else if	(ir == "rNymph")	
	{
		Race = rNymph;
		mBackPack[0].SetWhat(itNymphHair);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itNymphHear);	mBackPack[1].SetNumber(1);
	} 
	else if	(ir == "rOctopus")	
	{
		Race = rOctopus;
		mBackPack[0].SetWhat(itOctopTent);	mBackPack[0].SetNumber((rand() % 8) + 1);
	} 
	else if	(ir == "rOgre")		
	{
		Race = rOgre;
		mBackPack[0].SetWhat(itOgreHide);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itOgreHair);	mBackPack[1].SetNumber(2);
		mBackPack[2].SetWhat(itOgreEar);	mBackPack[2].SetNumber(2);
	} 
	else if	(ir == "rOpossum")
	{
		Race = rOpossum;
		mBackPack[0].SetWhat(itOposHide);	mBackPack[0].SetNumber(1);		
	} 
	else if	(ir == "rOtter")	
	{
		Race = rOtter;
		mBackPack[0].SetWhat(itOtteHide);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itOtteMeat);	mBackPack[1].SetNumber((rand() % 2) + 1);
	}
	else if	(ir == "rOtterSea")
	{
		Race = rOtterSea;
		mBackPack[0].SetWhat(itOttSeHide);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itOttSeMeat);	mBackPack[1].SetNumber((rand() % 3) + 1);
	} 
	else if	(ir == "rPhantom")	
	{
		Race = rPhantom;//Nothing
	} 
	else if	(ir == "rPhoenix")	
	{
		Race = rPhoenix;
		mBackPack[0].SetWhat(itFireCoal);	mBackPack[0].SetNumber((rand() % 5) + 1);
	}
	else if	(ir == "rPigDom")	
	{
		Race = rPigDom;
		mBackPack[0].SetWhat(itPigDoHide);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itPigDoMeat);	mBackPack[1].SetNumber((rand() % 2) + 1);
	} 
	else if	(ir == "rPigWild")	
	{ 
		Race = rPigWild;
		mBackPack[0].SetWhat(itPigWiHide);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itPigWiMeat);	mBackPack[1].SetNumber((rand() % 3) + 1);
	}
	else if	(ir == "rPoltergeist")	
	{
		Race = rPoltergeist;//Nothing
	} 
	else if	(ir == "rPorcupine")
	{
		Race = rPorcupine;
		mBackPack[0].SetWhat(itPorcQuill);	mBackPack[0].SetNumber((rand() % 5) + 1);
	} 
	else if	(ir == "rRabbit")
	{
		Race = rRabbit;
		mBackPack[0].SetWhat(itRabbiHide);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itRabbiMeat);	mBackPack[1].SetNumber(1);
	} 
	else if	(ir == "rRaccoon")
	{
		Race = rRaccoon;
		mBackPack[0].SetWhat(itRaccoHide);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itRaccoMeat);	mBackPack[1].SetNumber(2);
	} 
	else if	(ir == "rRat")
	{
		Race = rRat;
		mBackPack[0].SetWhat(itRatHide);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itRatMeat);	mBackPack[1].SetNumber(1);
		mBackPack[2].SetWhat(itRatTail);	mBackPack[2].SetNumber(1);
	}
	else if	(ir == "rScorpion")	
	{
		Race = rScorpion;
		mBackPack[0].SetWhat(itScorpStin);	mBackPack[0].SetNumber(1);
	} 
	else if	(ir == "rSheep")
	{
		Race = rSheep;
		mBackPack[0].SetWhat(itSheepHide);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itSheepWool);	mBackPack[1].SetNumber((rand() % 3) + 1);
		mBackPack[2].SetWhat(itSheepMeat);	mBackPack[2].SetNumber((rand() % 3) + 1);
	} 
	else if	(ir == "rSiren")
	{
		Race = rSiren;
		mBackPack[0].SetWhat(itSirenHair);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itWaterSpir);	mBackPack[1].SetNumber(1);
	} 
	else if	(ir == "rSkeleton")	
	{
		Race = rSkeleton;
		mBackPack[0].SetWhat(itSkeleBone);	mBackPack[0].SetNumber((rand() % 5) + 1);
	} 
	else if	(ir == "rSkunk")	
	{
		Race = rSkunk;
		mBackPack[0].SetWhat(itSkunkHide);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itSkunGland);	mBackPack[1].SetNumber(1);
	} 
	else if	(ir == "rSnake")	
	{
		Race = rSnake;
		mBackPack[0].SetWhat(itSnakeHide);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itSnakeMeat);	mBackPack[1].SetNumber(1);
		mBackPack[2].SetWhat(itSnakeFang);	mBackPack[2].SetNumber(2);
	} 
	else if	(ir == "rSpectre")
	{
		Race = rSpectre;//Nothing
	} 
	else if	(ir == "rSphinx")	
	{
		Race = rSphinx;
		mBackPack[0].SetWhat(itSphinHide);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itSphinWing);	mBackPack[1].SetNumber(2);
		mBackPack[2].SetWhat(itSphinTail);	mBackPack[2].SetNumber(1);
	} 
	else if	(ir == "rSpider")
	{
		Race = rSpider;
		mBackPack[0].SetWhat(itSpiderLeg);	mBackPack[0].SetNumber((rand() % 8) + 1);
		mBackPack[1].SetWhat(itSpideFang);	mBackPack[1].SetNumber(2);
	} 
	else if	(ir == "rSprite")
	{
		Race = rSprite;
		mBackPack[0].SetWhat(itSpritHair);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itSpriteEar);	mBackPack[1].SetNumber(2);
		mBackPack[2].SetWhat(itSpriteEye);	mBackPack[2].SetNumber(2);
	} 
	else if	(ir == "rSquid")
	{
		Race = rSquid;
		mBackPack[0].SetWhat(itSquidTent);	mBackPack[0].SetNumber((rand() % 4) + 1);
	} 
	else if	(ir == "rSquirrel")
	{
		Race = rSquirrel;
		mBackPack[0].SetWhat(itSquirHide);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itSquirMeat);	mBackPack[1].SetNumber(1);
	} 
	else if	(ir == "rSquirrelFly")
	{
		Race = rSquirrelFly;
		mBackPack[0].SetWhat(itSqFlyHide);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itSqFlyMeat);	mBackPack[1].SetNumber(1);
	} 
	else if	(ir == "rTitan")
	{
		Race = rTitan;
		mBackPack[0].SetWhat(itTitanHair);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itTitanEye);	mBackPack[1].SetNumber(2);
		mBackPack[2].SetWhat(itTitanEar);	mBackPack[2].SetNumber(2);
		mBackPack[3].SetWhat(itTitanArm);	mBackPack[3].SetNumber(2);
		mBackPack[4].SetWhat(itTitanLeg);	mBackPack[4].SetNumber(2);
	}	
	else if	(ir == "rTroll")
	{
		Race = rTroll;
		mBackPack[0].SetWhat(itTrolHead);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itTrolHair);	mBackPack[1].SetNumber(1);
		mBackPack[2].SetWhat(itTrolHide);	mBackPack[2].SetNumber(1);
		mBackPack[3].SetWhat(itTrolClaw);	mBackPack[3].SetNumber(2);
	} 
	else if	(ir == "rUnicorn")
	{
		Race = rUnicorn;
		mBackPack[0].SetWhat(itUnicHorn);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itUnicHide);	mBackPack[1].SetNumber(1);
		mBackPack[2].SetWhat(itUnicMeat);	mBackPack[2].SetNumber((rand() % 4) + 1);
	} 
	else if	(ir == "rVampire")
	{
		Race = rVampire;
		mBackPack[0].SetWhat(itVampFang);	mBackPack[0].SetNumber(2);
		mBackPack[1].SetWhat(itVampHair);	mBackPack[1].SetNumber(1);
	} 
	else if	(ir == "rWarthog")
	{
		Race = rWarthog;
		mBackPack[0].SetWhat(itWartHide);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itWartMeat);	mBackPack[1].SetNumber(1);
	} 
	else if	(ir == "rWeasel")
	{
		Race = rWeasel;
		mBackPack[0].SetWhat(itWeasHide);	mBackPack[0].SetNumber(2);
		mBackPack[1].SetWhat(itWeasMeat);	mBackPack[1].SetNumber(2);
	} 
	else if	(ir == "rWildBoar")
	{
		Race = rWildBoar;
		mBackPack[0].SetWhat(itWBoaHide);	mBackPack[0].SetNumber(2);
		mBackPack[1].SetWhat(itWBoaMeat);	mBackPack[1].SetNumber(2);
		mBackPack[2].SetWhat(itWBoaTusk);	mBackPack[2].SetNumber((rand()%2) + 1);
	} 
	else if	(ir == "rWildStag")
	{
		Race = rWildStag;
		mBackPack[0].SetWhat(itWStaHorn);	mBackPack[0].SetNumber(2);
		mBackPack[1].SetWhat(itWStaHide);	mBackPack[1].SetNumber(1);
		mBackPack[2].SetWhat(itWStaMeat);	mBackPack[2].SetNumber((rand() % 5) + 1);
	} 
	else if	(ir == "rWillWisp")	
	{
		Race = rWillWisp;
		mBackPack[0].SetWhat(itSwampEss);	mBackPack[0].SetNumber(1);
	} 
	else if	(ir == "rWolverine")
	{ 
		Race = rWolverine;
		mBackPack[0].SetWhat(itWolvHide);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itWolvMeat);	mBackPack[1].SetNumber((rand() % 2) + 1);
		mBackPack[2].SetWhat(itWolvClaw);	mBackPack[2].SetNumber(2);
	}
	else if	(ir == "rWoodchuck")
	{
		Race = rWoodchuck;
		mBackPack[0].SetWhat(itWdchHide);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itWdchMeat);	mBackPack[1].SetNumber(1);
	} 
	else if	(ir == "rWolf")	
	{
		Race = rWolf;
		mBackPack[0].SetWhat(itWolfHide);	mBackPack[0].SetNumber(1);
		mBackPack[1].SetWhat(itWolfMeat);	mBackPack[1].SetNumber((rand() % 3) + 1);
	} 
	else if	(ir == "rWraith")	
	{
		Race = rWraith;//Nothing
	} 
	else if	(ir == "rYeti")	
	{
		Race = rYeti;
		mBackPack[0].SetWhat(itYetiHide);	mBackPack[0].SetNumber(1);
	} 
	else if	(ir == "rZombie")
	{
		Race = rZombie;
		mBackPack[0].SetWhat(itZomFlesh);	mBackPack[0].SetNumber(1);
	}
	else Race = rNone;
}
void Character::setRaceViaID(string ir)
{
	//This method receives an ID using a 'word' to describe them, which
	//is then assigned accordingly - M. White 17 March, 2019
	Reset();
	if		(ir == "rAntelope")		Race = rAntelope;		else if	(ir == "rBadger")		Race = rBadger; 
	else if	(ir == "rBanshee")		Race = rBanshee;		else if	(ir == "rBasilisk")		Race = rBasilisk; 
	else if	(ir == "rBat")			Race = rBat;			else if	(ir == "rBear")			Race = rBear;
	else if	(ir == "rBeaver")		Race = rBeaver;			else if	(ir == "rBird")			Race = rBird;
	else if	(ir == "rBrownie")		Race = rBrownie;		else if	(ir == "rBuffalo")		Race = rBuffalo; 
	else if	(ir == "rBugbear")		Race = rBugbear;		else if	(ir == "rCat")			Race = rCat;
	else if	(ir == "rCattle")		Race = rCattle;			else if	(ir == "rCentaur")		Race = rCentaur;
	else if	(ir == "rChimera")		Race = rChimera;		else if	(ir == "rChipmunk")		Race = rChipmunk;
	else if	(ir == "rCockatrice")	Race = rCockatrice;		else if	(ir == "rCrocodile")	Race = rCrocodile;
	else if	(ir == "rDog")			Race = rDog;			else if	(ir == "rDolphin")		Race = rDolphin;
	else if	(ir == "rDragon")		Race = rDragon;			else if	(ir == "rDryad")		Race = rDryad;	
	else if	(ir == "rDwarf")		Race = rDwarf;			else if	(ir == "rElf")			Race = rElf;
	else if	(ir == "rErmine")		Race = rErmine;			else if	(ir == "rFerret")		Race = rFerret;	
	else if	(ir == "rFox")			Race = rFox;			else if	(ir == "rGargoyle")		Race = rGargoyle;
	else if	(ir == "rGenie")		Race = rGenie;			else if	(ir == "rGhost")		Race = rGhost;
	else if	(ir == "rGhoul")		Race = rGhoul;			else if	(ir == "rGiant")		Race = rGiant;
	else if	(ir == "rGnome")		Race = rGnome;			else if	(ir == "rGoat")			Race = rGoat;	
	else if	(ir == "rGoblin")		Race = rGoblin;			else if	(ir == "rGopher")		Race = rGopher;	
	else if	(ir == "rGorilla")		Race = rGorilla;		else if	(ir == "rGremlin")		Race = rGremlin;
	else if	(ir == "rGriffon")		Race = rGriffon;		else if	(ir == "rHag")			Race = rHag;
	else if	(ir == "rHarpy")		Race = rHarpy;			else if	(ir == "rHedgehog")		Race = rHedgehog;
	else if	(ir == "rHobgoblin")	Race = rHobgoblin;		else if	(ir == "rHorse")		Race = rHorse;
	else if	(ir == "rHuman")		Race = rHuman;			else if	(ir == "rHydra")		Race = rHydra;
	else if	(ir == "rImp")			Race = rImp;			else if	(ir == "rLeprechaun")	Race = rLeprechaun;		
	else if	(ir == "rMermaid")		Race = rMermaid;		else if	(ir == "rMink")			Race = rMink;
	else if	(ir == "rMinotaur")		Race = rMinotaur;		else if	(ir == "rMole")			Race = rMole;
	else if	(ir == "rMouse")		Race = rMouse;			else if	(ir == "rMummy")		Race = rMummy;
	else if	(ir == "rMuskrat")		Race = rMuskrat;		else if	(ir == "rNymph")		Race = rNymph;
	else if	(ir == "rOctopus")		Race = rOctopus;		else if	(ir == "rOgre")			Race = rOgre;
	else if	(ir == "rOpossum")		Race = rOpossum;		else if	(ir == "rOtter")		Race = rOtter;
	else if	(ir == "rOtterSea")		Race = rOtterSea;		else if	(ir == "rPhantom")		Race = rPhantom;
	else if	(ir == "rPhoenix")		Race = rPhoenix;		else if	(ir == "rPigDom")		Race = rPigDom;
	else if	(ir == "rPigWild")		Race = rPigWild;		else if	(ir == "rPoltergeist")	Race = rPoltergeist;
	else if	(ir == "rPorcupine")	Race = rPorcupine;		else if	(ir == "rRabbit")		Race = rRabbit;
	else if	(ir == "rRaccoon")		Race = rRaccoon;		else if	(ir == "rRat")			Race = rRat;
	else if	(ir == "rScorpion")		Race = rScorpion;		else if	(ir == "rSheep")		Race = rSheep;
	else if	(ir == "rSiren")		Race = rSiren;			else if	(ir == "rSkeleton")		Race = rSkeleton;
	else if	(ir == "rSkunk")		Race = rSkunk;			else if	(ir == "rSnake")		Race = rSnake;
	else if	(ir == "rSpectre")		Race = rSpectre;		else if	(ir == "rSphinx")		Race = rSphinx;
	else if	(ir == "rSpider")		Race = rSpider;			else if	(ir == "rSprite")		Race = rSprite;
	else if	(ir == "rSquid")		Race = rSquid;			else if	(ir == "rSquirrel")		Race = rSquirrel;
	else if	(ir == "rSquirrelFly")	Race = rSquirrelFly;	else if	(ir == "rTitan")		Race = rTitan;
	else if	(ir == "rTroll")		Race = rTroll;			else if	(ir == "rUnicorn")		Race = rUnicorn;
	else if	(ir == "rVampire")		Race = rVampire;		else if	(ir == "rWarthog")		Race = rWarthog;
	else if	(ir == "rWeasel")		Race = rWeasel;			else if	(ir == "rWildBoar")		Race = rWildBoar;
	else if	(ir == "rWildStag")		Race = rWildStag;		else if	(ir == "rWillWisp")		Race = rWillWisp;
	else if	(ir == "rWolverine")	Race = rWolverine;		else if	(ir == "rWoodchuck")	Race = rWoodchuck;
	else if	(ir == "rWolf")			Race = rWolf;			else if	(ir == "rWraith")		Race = rWraith;
	else if	(ir == "rYeti")			Race = rYeti;			else if	(ir == "rZombie")		Race = rZombie;
	else							Race = rNone;
}
void Character::setSex(int data)
{
	Sex = data;
}
int	Character::getSex() const
{
	return Sex;
}
void Character::setHeight(int data)
{
	Height = data;
}
int	Character::getHeight() const
{
	return Height;
}
void Character::setWeight(int data)
{
	Weight = data;
}
int	Character::getWeight() const
{
	return Weight;
}
void Character::setStr(int data)
{
	Str = data;
}
int	Character::getStr() const
{
	return Str;
}
void Character::setDex(int data)
{
	Dex = data;
}
int	Character::getDex() const
{
	return Dex;
}
void Character::setCon(int data)
{
	Con = data;
}
int	Character::getCon() const
{
	return Con;
}
void Character::setInt(int data)
{
	Int = data;
}
int	Character::getInt() const
{
	return Int;
}
void Character::setWis(int data)
{
	Wis = data;
}
int	Character::getWis() const	
{
	return Wis;
}
void Character::setCha(int data)
{
	Cha = data;
}
int	Character::getCha() const	
{
	return Cha;
}
void Character::setCom(int data)
{
	Com = data;
}
int	Character::getCom() const	
{
	return Com;
}
void Character::setTStr(int i)	
{
	tStr = i;
}
int	Character::getTStr() const	
{
	return tStr;
}
void Character::setTDex(int i)
{
	tDex = i;
}
int	Character::getTDex() const	
{
	return tDex;
}
void Character::setTCon(int i)
{
	tCon = i;
}
int Character::getTCon() const
{
	return tCon;
}
void Character::setTInt(int i)
{
	tInt = i;
}
int Character::getTInt() const
{
	return tInt;
}
void Character::setTWis(int i)
{
	tWis = i;
}
int Character::getTWis() const
{
	return tWis;
}
void Character::setTCha(int i)
{
	tCha = i;
}
int Character::getTCha() const
{
	return tCha;
}
void Character::setHealth(int data)	
{
	Health = data;
}
int Character::getHealth() const
{
	return Health;
}
void Character::setCurHealth(int data)
{
	CurrentHealth = data;
}
int Character::getCurHealth() const
{
	return CurrentHealth;
}
void Character::setClass(int data)
{
	Class = data;
}
int Character::getClass() const
{
	return Class;
}
int Character::getLevel() const
{
	return Level;
}
void Character::setLevel(int i)
{
	Level = i;
}
void Character::setItemsWorn(int Index, int newItem)
{
	if(Index >= 0 && Index < NUM_EQUIP_SLOTS) Body[Index].SetWhat(newItem);
}
int Character::getItemWorn(int Index)
{
	if(Index >= 0 && Index < NUM_EQUIP_SLOTS) return Body[Index].GetWhat();
	else return -1;
}
void Character::setCountItemW(int Index, int Quantity)
{
	if(Index >= Brow && Index < NUM_EQUIP_SLOTS)
	{
		if(Quantity > -1)	Body[Index].SetNumber(Quantity);
		else				Body[Index].SetNumber(0);
	}
}
int Character::getCountItemW(int Index) const
{
	if(Index >= Brow && Index < NUM_EQUIP_SLOTS) return Body[Index].GetNumber();
	else return -1;
}
void Character::setCountRHand(int d)
{
	Body[HandRight].SetNumber(d);
}
int Character::getCountRHand()
{
	return Body[HandRight].GetNumber();
}
void Character::setCountLHand(int d)
{
	Body[HandLeft].SetNumber(d);
}
int Character::getCountLHand()
{
	return Body[HandLeft].GetNumber();
}
void Character::setItemsBP(string data)
{
	int	i = 0, What = -1, Num = 0;
	string			DataSucker;
	istringstream	DATA(data.c_str());
	if(DATA.fail()) return;
	//This will always be capped at 12, so we're gaurenteed to return
	for(i = 0; i < 12; i++)
	{
		mBackPack[i].Reset();//Default it out
		if(!DATA.eof()) 
		{ 
			DATA >> DataSucker; What = atoi(DataSucker.c_str());
			if(!DATA.eof())	
			{
				DATA >> DataSucker; Num = atoi(DataSucker.c_str());	
				//Using NegOne because it will ensure a cleared item is replaced. This will
				//also alleviate the need to test how large the player's backpack is.
				if(What >= itNegOne && What < TOTAL_ITEMS)
				{ mBackPack[i].SetWhat(What); mBackPack[i].SetNumber(Num); }
			}
		}
	}
}
void Character::setItemBP(int i, int w, int q)
{
	if(i >= 0 && i < 12) { mBackPack[i].SetWhat(w); mBackPack[i].SetNumber(q); }
}
bool Character::addItem_BP(int what, int num)
{
	//Don't let things outside of range get in...
	if(what < 0)							return false;
	if(Body[Backpack].GetWhat() < itBP_01)	return false;
	//Search to see if the same type item is present
	for(int i = 0; i < 12; i++)
		if(mBackPack[i].GetWhat() == what)
		{
			if		(Body[Backpack].GetWhat() == itBP_02)
			{				
				if(mBackPack[i].GetNumber() + num <= 99)
				{
					mBackPack[i].SetNumber(mBackPack[i].GetNumber() + num);
					return true;
				}
				else break;
			}
			else if	(Body[Backpack].GetWhat() == itBP_01)
			{
				if(mBackPack[i].GetNumber() + num <= 99)
				{
					mBackPack[i].SetNumber(mBackPack[i].GetNumber() + num);
					return true;
				}
				else break;
			}
			else if	(Body[Backpack].GetWhat() == itBack)
			{
				if(mBackPack[i].GetNumber() + num <= 99)
				{
					mBackPack[i].SetNumber(mBackPack[i].GetNumber() + num);
					return true;
				}
				else break;
			}
		}
	//If item was not already in list check to see if there is a slot open
	for(i = 0; i < 12; i++)
		if(mBackPack[i].GetWhat() == itNegOne)
		{ mBackPack[i].SetWhat(what); mBackPack[i].SetNumber(num); return true; }
	return false;
}
int	Character::getItem_BP(int index)
{
	int limit = 0;
	if		(Body[Backpack].GetWhat() == itBP_02)	limit = 12;
	else if	(Body[Backpack].GetWhat() == itBP_01)	limit = 10;
	else if	(Body[Backpack].GetWhat() == itBack)	limit = 8;
	else											limit = itNegOne;//Fails

	if(index >= 0 && index < limit)	return mBackPack[index].GetWhat();
	else							return -1;
}
int Character::getAmount_BP(int index)
{
	int limit = 0;
	if		(Body[Backpack].GetWhat() == itBP_02)	limit = 12;
	else if	(Body[Backpack].GetWhat() == itBP_01)	limit = 10;
	else if	(Body[Backpack].GetWhat() == itBack)	limit = 8;
	else											limit = -1;//Fails
	if(index >= 0 && index < limit)	return mBackPack[index].GetNumber();
	else							return -1;
}
void Character::setAmount_BP(int index, int quant)
{
	if(index >= 0 && index < 12) mBackPack[index].SetNumber(quant);
}
void Character::deleteItemBP(int i)
{
	if(Body[Backpack].GetWhat() >= itBP_01 && (i >= 0 && i < 12))
	{ mBackPack[i].SetWhat(-1); mBackPack[i].SetNumber(0); }
}
void Character::setItemsTra(string data)
{
	int i = 0, What = -1, Num = 0;
	string			DataSucker;
	istringstream	DATA(data.c_str());
	if(DATA.fail()) return;
	//This will always be capped at 28, so we're gaurenteed to return
	for(i = 0; i < 28; i++)
	{
		mTransport[i].Reset();
		if(!DATA.eof()) 
		{
			DATA >> DataSucker; What = atoi(DataSucker.c_str());
			if(!DATA.eof())
			{
				DATA >> DataSucker; Num = atoi(DataSucker.c_str());
				//Using NegOne because it will ensure a cleared item is replaced. This will
				//also alleviate the need to test how large the player's backpack is.
				if(What >= itNegOne && What < TOTAL_ITEMS)
				{ mTransport[i].SetWhat(What); mTransport[i].SetNumber(Num); }
			}
		}
	}
}
void Character::setItemTra(int i, int w, int q)
{
	if(i >= 0 && i < 28) { mTransport[i].SetWhat(w); mTransport[i].SetNumber(q); }
}
bool Character::addItem_Tra(int what, int num)
{
	//Don't let things outside of range get in...
	if(what < 0)								return false;
	if(Body[Transport].GetWhat() < itTrans)		return false;
	int limit;
	int i;
	if		(Body[Transport].GetWhat() >= itLgWag01)	limit = 28;	// 125
	else if	(Body[Transport].GetWhat() >= itSmWag01)	limit = 24;	// 100
	else if	(Body[Transport].GetWhat() >= itLgCart01)	limit = 20;	// 90
	else if	(Body[Transport].GetWhat() >= itSmCart01)	limit = 16;	// 80
	else if	(Body[Transport].GetWhat() >= itTrans)		limit = 14;	// 70
	else												limit = 0;
	//Limit of zero will return false indicating a problem (no transport)
	for(i = 0; i < limit; i++)
		if(mTransport[i].GetWhat() == what)
		{
			if		(Body[Transport].GetWhat() >= itLgWag01)
			{
				if(mTransport[i].GetNumber() + num < 99)
				{
					mTransport[i].SetNumber(mTransport[i].GetNumber() + num);
					return true;
				}
				else break;
			}
			else if	(Body[Transport].GetWhat() >= itSmWag01)
			{
				if(mTransport[i].GetNumber() + num < 99)
				{
					mTransport[i].SetNumber(mTransport[i].GetNumber() + num);
					return true;
				}
				else break;
			}
			else if	(Body[Transport].GetWhat() >= itLgCart01)
			{
				if(mTransport[i].GetNumber() + num < 99)
				{
					mTransport[i].SetNumber(mTransport[i].GetNumber() + num);
					return true;
				}
				else break;
			}
			else if	(Body[Transport].GetWhat() >= itSmCart01)
			{
				if(mTransport[i].GetNumber() + num < 99)
				{
					mTransport[i].SetNumber(mTransport[i].GetNumber() + num);
					return true;
				}
				else break;
			}
			else
			{
				if(mTransport[i].GetNumber() + num < 99)
				{
					mTransport[i].SetNumber(mTransport[i].GetNumber() + num);
					return true;
				}
				else break;
			}
		}
	//If item was not already in list, check to see if there is a slot open
	for(i = 0; i < limit; i++)
		if(mTransport[i].GetWhat() == itNegOne)
		{ mTransport[i].SetWhat(what); mTransport[i].SetNumber(num); return true; }
	return false;
}
int Character::getItem_Tra(int index)
{
	int limit;
	if		(Body[Transport].GetWhat() == itTrans)													limit = 14;	// 70
	else if	(Body[Transport].GetWhat() == itSmCart01 || Body[Transport].GetWhat() == itSmCart02)	limit = 16;	// 80
	else if	(Body[Transport].GetWhat() == itLgCart01 || Body[Transport].GetWhat() == itLgCart02)	limit = 20;	// 90
	else if	(Body[Transport].GetWhat() == itSmWag01  || Body[Transport].GetWhat() == itSmWag02)		limit = 24;	// 100
	else if	(Body[Transport].GetWhat() == itLgWag01  || Body[Transport].GetWhat() == itLgWag02)		limit = 28;	// 125
	else																							limit = -1; //fails
	if(index >= 0 && index < limit)	return mTransport[index].GetWhat();
	else							return -1;
}
int	Character::getAmount_Tra(int index)
{
	int limit;
	if		(Body[Transport].GetWhat() == itTrans)													limit = 14;	// 70
	else if	(Body[Transport].GetWhat() == itSmCart01 || Body[Transport].GetWhat() == itSmCart02)	limit = 16;	// 80
	else if	(Body[Transport].GetWhat() == itLgCart01 || Body[Transport].GetWhat() == itLgCart02)	limit = 20;	// 90
	else if	(Body[Transport].GetWhat() == itSmWag01  || Body[Transport].GetWhat() == itSmWag02)		limit = 24;	// 100
	else if	(Body[Transport].GetWhat() == itLgWag01  || Body[Transport].GetWhat() == itLgWag02)		limit = 28;	// 125
	else																							limit = -1; //fails
	if(index >= 0 && index < limit)	return mTransport[index].GetNumber();
	else							return -1;
}
void Character::setAmount_Tra(int index, int quant)
{
	if(index >= 0 && index < 28) mTransport[index].SetNumber(quant);
}
void Character::deleteItemTr(int i)
{
	if(Body[Transport].GetWhat() >= itTrans)
		if(i >= 0 && i < 28) { mTransport[i].SetWhat(-1); mTransport[i].SetNumber(0); }
}
void Character::setItemsPou(int index, string data)
{
	int What = -1, Num = 0;
	string			DataSucker;
	istringstream	DATA(data.c_str());
	if(DATA.fail()) return;
	if(index < 0 || index >= 6) return;
	//This will always be capped at 12, so we're gaurenteed to return
	for(int i = 0; i < 6; i++)
	{
		if(!DATA.eof()) 
		{ 
			DATA >> DataSucker; What = atoi(DataSucker.c_str());	
			if(!DATA.eof())
			{ 
				DATA >> DataSucker; Num = atoi(DataSucker.c_str());
				//Using NegOne because it will ensure a cleared item is replaced. This will
				//also alleviate the need to test how large the player's backpack is.
				if(What >= itNegOne && What < TOTAL_ITEMS)
				{ mPouches[index][i].SetWhat(What); mPouches[index][i].SetNumber(Num); }
			} else return;		
		} else return;
	}
}
void Character::setItemPou(int whi, int i, int wha, int q)
{
	if(whi >= 0 && whi < 6)
		if(i >= 0 && i < 6) { mPouches[whi][i].SetWhat(wha); mPouches[whi][i].SetNumber(q); }
}
bool Character::addItem_Pou(int which, int what, int num)
{
	//Don't let things outside of range get in...
	if(what < 0) return false;
	int limit;
	int i;
	int	x;
	if(which >= 0 && which < 6)
	{
		switch(which)
		{
		case 0: i = Pouch_01; break; case 1: i = Pouch_02; break; case 2: i = Pouch_03; break;
		case 3: i = Pouch_04; break; case 4: i = Pouch_05; break; case 5: i = Pouch_06; break;
		default: false;
		}
		if(Body[i].GetWhat() < itPo_01) return false;
	}
	else return false;
	if		(Body[i].GetWhat() == itPo_02)	limit = 6;
	else if	(Body[i].GetWhat() == itPo_01)	limit = 4;
	else if	(Body[i].GetWhat() == itPouch)	limit = 2;
	for(x = 0; x < limit; x++)
		if(mPouches[which][x].GetWhat() == what)
		{
			if		(Body[i].GetWhat() == itPo_02)
			{
				if(mPouches[which][x].GetNumber() + num < 40)
				{ mPouches[which][x].SetNumber(mPouches[which][x].GetNumber() + num); return true; }
				else break;
			}
			else if	(Body[i].GetWhat() == itPo_01)
			{
				if(mPouches[which][x].GetNumber() + num < 20)
				{ mPouches[which][x].SetNumber(mPouches[which][x].GetNumber() + num); return true; }
				else break;
			}
			else if	(Body[i].GetWhat() == itPouch)
			{ 
				if(mPouches[which][x].GetNumber() + num < 10)
				{ mPouches[which][x].SetNumber(mPouches[which][x].GetNumber() + num); return true; }
				else break;
			}
		}
	//If item was not already in list, check to see if there is a slot open
	for(x = 0; x < limit; x++)
		if(mPouches[which][x].GetWhat() == itNegOne)
		{ mPouches[which][x].SetWhat(what); mPouches[which][x].SetNumber(num); return true; }
	return false;
}
int Character::getItem_Pou(int which, int index)
{
	int limit = 0, i = 0;
	if(which >= 0 && which < 6)
	{
		switch(which)
		{
		case 0: i = Pouch_01; break; case 1: i = Pouch_02; break; case 2: i = Pouch_03; break;
		case 3: i = Pouch_04; break; case 4: i = Pouch_05; break; case 5: i = Pouch_06; break;
		default: break;
		}
	}
	else return false;
	if		(Body[i].GetWhat() == itPo_02)	limit = 6;
	else if	(Body[i].GetWhat() == itPo_01)	limit = 4;
	else if	(Body[i].GetWhat() == itPouch)	limit = 2;
	if(index >= 0 && index < limit) return mPouches[which][index].GetWhat();
	else return -1;
}
int Character::getAmount_Pou(int which, int index)
{
	int limit;
	int i;
	if(which >= 0 && which < 6)
	{
		switch(which)
		{
		case 0: i = Pouch_01; break; case 1: i = Pouch_02; break; case 2: i = Pouch_03; break;
		case 3: i = Pouch_04; break; case 4: i = Pouch_05; break; case 5: i = Pouch_06; break;
		default: break;
		}
	}
	else return false;
	if		(Body[i].GetWhat() == itPo_02)	limit = 6;
	else if	(Body[i].GetWhat() == itPo_01)	limit = 4;
	else if	(Body[i].GetWhat() == itPouch)	limit = 2;
	if(index >= 0 && index < limit)	return mPouches[which][index].GetNumber();
	else return -1;
}
void Character::setAmount_Pou(int which, int index, int quant)
{
	if((which >= 0 && which < 6) && (index >= 0 && index < 6)) mPouches[which][index].SetNumber(quant);
}
void Character::deleteItemPo(int which, int i)
{
	if(which >= 0 && which < 6)
		if(i >= 0 && i < 6) { mPouches[which][i].SetWhat(-1); mPouches[which][i].SetNumber(0); }
}
void Character::setX(int data)
{
	X = data;
}
int	Character::getX() const
{
	return X;
}
void Character::setY(int data)
{
	Y = data;
}
int	Character::getY() const
{
	return Y;
}
void Character::setZ(int data)
{
	Z = data;
}
int	Character::getZ() const
{
	return Z;
}
void Character::setCoordinates(int xData, int yData, int zData)
{
	X = xData; Y = yData; Z = zData;
}
void Character::setWorldMax(int x, int y, int z)
{
	maxX = x; maxY = y; maxZ = z;
}
void Character::setFacing(int nFace)//this version for mouse input
{
	facing = nFace; MyOffSetX = 0; MyOffSetY = 0;
}
void Character::changeFacing(int newFace)//this version for left/right arrow keys
{
	if(Tick > 0) return; // || (MyOffSetX != 0 || MyOffSetY != 0))
	facing += newFace;
	if		(facing < 0) facing = 7;
	else if	(facing > 7) facing = 0;
	MyOffSetX = 0; MyOffSetY = 0;
}
int Character::getDirection() const
{
	return facing;
}
void Character::CliMoveToCoord()
{
	switch(facing)
	{
	case 0:
        if(X == maxX - 1 || Y == 0)			{ Status = STAND_NORMAL; Moving = false; MyOffSetX = MyOffSetY = 0; }
		else { ++X; --Y; } break;
	case 1:
		if(X == maxX - 1)					{ Status = STAND_NORMAL; Moving = false; MyOffSetX = MyOffSetY = 0; }
		else ++X; break;
	case 2:
		if(X == maxX - 1 || Y == maxY - 1)	{ Status = STAND_NORMAL; Moving = false; MyOffSetX = MyOffSetY = 0; }
		else { ++X; ++Y; } break;
	case 3:
		if(Y == maxY - 1)					{ Status = STAND_NORMAL; Moving = false; MyOffSetX = MyOffSetY = 0; }
		else ++Y; break;
	case 4:
		if(X == 0 || Y == maxY - 1)			{ Status = STAND_NORMAL; Moving = false; MyOffSetX = MyOffSetY = 0; }
		else { --X; ++Y; } break;
	case 5:
		if(X == 0)							{ Status = STAND_NORMAL; Moving = false; MyOffSetX = MyOffSetY = 0; }	
		else --X; break;
	case 6:
		if (X == 0 || Y == 0)				{ Status = STAND_NORMAL; Moving = false; MyOffSetX = MyOffSetY = 0; }
		else { --X; --Y; } break;
	case 7:
		if(Y == 0)							{ Status = STAND_NORMAL; Moving = false; MyOffSetX = MyOffSetY = 0; }			
		else --Y; break;
	default: break;
	};
}
void Character::setSpeed(int data)
{
	Speed = data;
}
int Character::getSpeed() const
{
	return Speed;
}
void Character::setRunTimer(int data)
{
	RunTimer = data;
}
int Character::getRunTimer() const
{
	return RunTimer;
}
void Character::setCurRunTimer(int data)
{
	CurRunTimer = data;
}
int Character::getCurRunTimer() const
{
	return CurRunTimer;
}
bool Character::getMoving() const
{
	return Moving;
}
void Character::setMoving(bool data)
{
	Moving = data;
}
int Character::getOffSetX() const
{
	return MyOffSetX;
}
int Character::getOffSetY() const
{
	return MyOffSetY;
}
void Character::setOffsAuto()
{
	switch(facing)//Sets the OffSets
	{
	case 0:	MyOffSetX = -28;	MyOffSetY = 28;		break;
	case 1:	MyOffSetX = -28;	MyOffSetY = 0;		break;
	case 2:	MyOffSetX = -28;	MyOffSetY = -28;	break;
	case 3:	MyOffSetX = 0;		MyOffSetY = -28;	break;
	case 4:	MyOffSetX = 28;		MyOffSetY = -28;	break;
	case 5:	MyOffSetX = 28;		MyOffSetY = 0;		break;
	case 6:	MyOffSetX = 28;		MyOffSetY = 28;		break;
	case 7:	MyOffSetX = 0;		MyOffSetY = 28;		break;
	default:	break;
	}
}
void Character::incrementTick()
{
	++Tick;
}
void Character::setTicks(int data)
{
	Tick = data;
}
int Character::getTicks() const
{
	return Tick;
}
void Character::setPort(int data)
{
	PortNumber = data;
}
int Character::getPort() const
{
	return PortNumber;
}
void Character::setSkill(int Index, int What)
{
	if(Index >= 0 && Index < MAX_PLAYER_SKILLS) Skills[Index].SetSkill(What);
	else return;
	//Recount and assign the total skills used
	NumSkills = 0;
	for(int bTest = 0; bTest < MAX_PLAYER_SKILLS; bTest++) if(Skills[bTest].GetSkill() < Sk100) ++NumSkills;
}
void Character::setXP(int in, int newData)
{
	if(in < 0 || in >= MAX_PLAYER_SKILLS) return;
	Skills[in].SetXP(newData); assignSkillLevel(); CheckSelf();
}
void Character::setXPClient(int in, int newData)
{
	if(in < 0 || in >= MAX_PLAYER_SKILLS) return;
	Skills[in].SetXP(newData); assignSkillLevel(); CheckSelf();
}
void Character::setNumSkills(int Num)
{
	NumSkills = Num;
}
void Character::setSkillTimer(int index, int data)
{
	if(index > -1 && index < MAX_PLAYER_SKILLS) Skills[index].SetTimer(data);
}
void Character::setUsingSkill(bool data)
{
	UsingSkill = data;
}
void Character::assignSkillLevel()
{
	int totalSkills; totalSkills = 0;
	for(int index = 0; index < MAX_PLAYER_SKILLS; index++)	Skills[index].AssignLevel();
	for(int i = 0; i < NumSkills; i++)						totalSkills += Skills[i].GetLevel();
	if(NumSkills != 0)	Level = int(totalSkills/NumSkills);
}
int	Character::getSkill(int i)
{
	return Skills[i].GetSkill();
}
int	Character::getSkillXP(int i)
{
	return Skills[i].GetXP();
}
void Character::setMobSkillLvl(int lvl)
{
	Skills[0].SetLevel(lvl); Skills[1].SetLevel(lvl); Skills[2].SetLevel(lvl);	
}
int Character::getSkillLevel(int Index)
{
	if(Index >= 0 && Index < MAX_PLAYER_SKILLS) return Skills[Index].GetLevel();
	else return -1;
}
int	Character::getNumSkills() const
{
	return NumSkills;
}
int Character::getXPNextLvl(int index)
{
	if(index >= 0 && index < MAX_PLAYER_SKILLS) return	Skills[index].getXPNextLvl();
	else										return 0;
}
int	Character::getXPPercent(int index)
{
	if(index >= 0 && index < MAX_PLAYER_SKILLS) return Skills[index].getXPPercent();
	else										return 0;
}
int Character::getSkillTimer(int index)
{
	if(index > -1 && index < MAX_PLAYER_SKILLS) return Skills[index].GetTimer();
	else return -1;
}
bool Character::getUsingSkill() const
{
	return UsingSkill;
}
void Character::setRepeatSkill(bool a)
{
	RepeatSkill = a;
}
bool Character::getRepeatSkill() const
{
	return RepeatSkill;
}
bool Character::addSkill(int nSkill)
{
	int		bTest		= 0;
	Skill	temp;
	bool	result		= false;

	if(nSkill >= 0 && nSkill < Sk100)
	{
		if(NumSkills >= Int + 2 && nSkill != Sk100)	return false;

		//Checking to see if the skill is picked already
		for(bTest = 0; bTest < Int; bTest++)
		{
			//If it's picked already, no need to do more work
			if(Skills[bTest].GetSkill() == nSkill && nSkill != Sk100)
				return true;
		}//end: for(int bTest = 0; bTest < Int; bTest++)

		//Assign the new skills to last slot of array
		Skills[MAX_PLAYER_SKILLS - 1].SetSkill(nSkill);

		//bubble sort it up
		for(bTest = 0; bTest < MAX_PLAYER_SKILLS - 1; bTest++)
			for(int x = bTest + 1; x < MAX_PLAYER_SKILLS; x++)
				if(Skills[x] < Skills[bTest])
				{
					temp			= Skills[x];
					Skills[x]		= Skills[bTest];
					Skills[bTest]	= temp;
				}//end: if(Skills[x] < Skills[bTest])

		//Recount and assign the total skills used
		NumSkills = 0;

		for(bTest = 0; bTest < MAX_PLAYER_SKILLS; bTest++)
			if(Skills[bTest].GetSkill() < Sk100) 
				++NumSkills;

		return true;
	}
	else return false;
}
bool Character::deleteSkill(int Index)
{
	Skill	temp;
	int		bTest	= 0;
	int		x		= 0;

	if(Index >= 0 && Index < NumSkills)
	{
		Skills[Index].Reset();

		//bubble sort it up
		for(bTest = 0; bTest < MAX_PLAYER_SKILLS; bTest++)
		{
			for(x = bTest + 1; x < MAX_PLAYER_SKILLS; x++)
			{
				if(Skills[x] < Skills[bTest])
				{
					temp			= Skills[x];
					Skills[x]		= Skills[bTest];
					Skills[bTest]	= temp;
				}//end: if(Skills[x] < Skills[bTest])
			}//end: for(unsigned short x = bTest + 1; x < 25; x++)
		}//end: for(bTest = 0; bTest < 23; bTest++)

		//Recount and assign the total skills used
		NumSkills = 0;

		for(bTest = 0; bTest < MAX_PLAYER_SKILLS; bTest++)
			if(Skills[bTest].GetSkill() < Sk100) 
				++NumSkills;

		return true;
	}//end: if(nSkill < NumSkills)
	else 
		return false;
}
void Character::resetSkills()
{
	for(int x = 0; x < MAX_PLAYER_SKILLS; x++)
		Skills[x].Reset();
	//Mandatory skills
	Skills[0].SetSkill(SkWSDodgi);
	Skills[1].SetSkill(SkWSPunch);
	NumSkills = 2;
}
void Character::adjustSkillXP(int index, int amount)
{
	//amount can be positive or negative number to effect over all xp
	if(index >= 0 && index < MAX_PLAYER_SKILLS) Skills[index].adjustXP(amount);		
}
void Character::useSkill(int i)
{
	if(i > -1 && i < MAX_PLAYER_SKILLS) 
	{
		//This assignment here might be better in the next if-test - but works right now without any problems
		UsingSkill = true;
		if(Skills[i].GetTimer() == 0) { Skills[i].UseSkill(); LastSkillRight = i; }
	}
}
void Character::setLastSkillL(int i)
{
	LastSkillLeft = i;
}
void Character::setLastSkillR(int i)
{
	LastSkillRight = i;
}
int	Character::getLastSkillL() const
{
	return LastSkillLeft;
}
int	Character::getLastSkillR() const
{
	return LastSkillRight;
}
int	Character::getSkillAssoc(int index)
{
	return Skills[index].GetAssoc();
}
int	Character::getSkillRef(int index)
{
	return Skills[0].GetAssocByRef(index);
}
string Character::getReadibleSkill(int i)
{
	if(i >= 0 && i < MAX_PLAYER_SKILLS)	return Skills[i].getUserSkillName();
	else								return "Skill Error";
}
string Character::getReadSkillByCount(int i)
{
	if(i >= 0 && i < MAX_NUM_SKILLS)	return Skills[0].getUserSkillName(i);
	else								return "Skille Error";
}
string Character::getSkillStrID(int i)
{
	return "NeedsWork";
}
void Character::setPVP(int data)
{
	PVP_Status = data;
}
int	Character::getPVP() const
{
	return PVP_Status;
}
void Character::setStanding(bool data)
{
	Standing = data;
}
bool Character::getStanding() const
{
	return Standing;
}
void Character::setWarMode(bool data)
{
	WarMode = data;
}
bool Character::getWarMode() const
{
	return WarMode;
}
void Character::setMounted(int data)
{
	Mounted = data;
}
int	Character::getMounted() const
{
	return Mounted;
}
void Character::setStatus(int data)
{
	Status = data;
}
int	Character::getStatus() const
{
	return Status;
}
void Character::setOldStatus(int data)
{
	OldStatus = data;
}
int	Character::getOldStatus() const
{
	return OldStatus;
}
void Character::setNPCMode(bool data)
{
	NPC_Mode = data;
}
bool Character::getNPCMode() const
{
	return NPC_Mode;
}
void Character::ManageSelf()
{
	if(UsingSkill == true)
	{
		for(int i = 0; i < MAX_PLAYER_SKILLS; i++)
			if(Skills[i].GetTimer() > 0) { Skills[i].SetTimer(Skills[i].GetTimer() - 1); return; }
		UsingSkill = false;
	}
//	if(NPC_Mode == true)
//	{
//		
//
//	}//end: if(NPC_Mode)
	else //not NPC_Mode
	{
		if(Tick != 0)//Finish current action
		{
			if		(Status > STAND_CAST_SPELL)//Some sort of moving animation
			{
				switch(facing)
				{
				case 0: MyOffSetX += int(32/Speed);	MyOffSetY -= int(32/Speed);	break;		
				case 1: MyOffSetX += int(32/Speed);	MyOffSetY = 0;				break;			
				case 2: MyOffSetX += int(32/Speed);	MyOffSetY += int(32/Speed);	break;		
				case 3: MyOffSetX = 0;				MyOffSetY += int(32/Speed);	break;	
				case 4: MyOffSetX -= int(32/Speed);	MyOffSetY += int(32/Speed);	break;	
				case 5: MyOffSetX -= int(32/Speed);	MyOffSetY = 0;				break;		
				case 6: MyOffSetX -= int(32/Speed);	MyOffSetY -= int(32/Speed);	break;			
				case 7: MyOffSetX = 0;				MyOffSetY -= int(32/Speed);	break;	
				default:														break;
				}
				if(Tick < (Speed - 1)) ++Tick; 
				else { Tick = 0; MyOffSetX = 0; MyOffSetY = 0;  }
			}//end: if(Status > STAND_CAST_SPELL)
			//This will be '7' constant because non-moving animations have 8 frames
			else if	(Status > SIT_OBJECT) { if(Tick < 7) ++Tick; else Tick = 0;  }
			else Tick = 0;
		}//end: if(Tick != 0)//Finish current action
		//Or determine the new Action
		else
		{
			if(Moving == true)
			{
				if(WarMode == true)
				{
				//	if		(weaponType == 2)	Status = WALK_CMBT_BOW;
				//	else if	(weaponType == 1)	Status = WALK_CMBT_STAFF;
				//	else						Status = WALK_CMBT_NORMAL;
				}
				else Status = WALK_NORMAL;
				switch(facing)//Sets the OffSets
				{
				case 0:	MyOffSetX = -28;	MyOffSetY =  28;	break;
				case 1:	MyOffSetX = -28;	MyOffSetY =   0;	break;
				case 2:	MyOffSetX = -28;	MyOffSetY = -28;	break;
				case 3:	MyOffSetX =   0;	MyOffSetY = -28;	break;
				case 4:	MyOffSetX =  28;	MyOffSetY = -28;	break;
				case 5:	MyOffSetX =  28;	MyOffSetY =   0;	break;
				case 6:	MyOffSetX =  28;	MyOffSetY =  28;	break;
				case 7:	MyOffSetX =   0;	MyOffSetY =  28;	break;
				default:	break;
				}
				Tick = 1;
			}//end: if(Moving == true)
			else //not moving
			{
				if(Standing == true)
				{
					if(WarMode == true)
					{
					//	if		(weaponType == 3)	Status = STAND_CAST_SPELL;
					//	else if (weaponType == 2)	Status = CMBT_STAFF;
					//	else if (weaponType == 1)	Status = CMBT_BOW;
					//	else						Status = CMBT_NORMAL;	
					}
					else
					{
					//	if		(weaponType == 3)	Status = STAND_CAST_SPELL;
					//	else if (weaponType == 2)	Status = STAND_STAFF;
					//	else if (weaponType == 1)	Status = STAND_BOW;
					/*	else */						Status = STAND_NORMAL;
					}
				}//end: if(Standing == true)
				else
				{
					//Remember to put a test in here to see what might 
					//be in the tile or if they're mounted.
				//	Status = SIT_OBJECT;
					Status = SIT_GROUND;
				}//end: else
				MyOffSetX = 0; MyOffSetY = 0;
			}//end: else (aka 'not' moving)
		}//end: else
	//	Standing, Moving, Mounted, WarMode, CastingSpell
	//	#define	HORSE_CMBT_NORMAL			10	// (9)	
	}//end: not NPC_Mode
}//end: void Character::ManageSelf()
void Character::ServManageSelf()
{
	if		(UsingSkill == true)
	{
		for(int i = 0; i < MAX_PLAYER_SKILLS; i++)
			if(Skills[i].GetTimer() > 0) { Skills[i].SetTimer(Skills[i].GetTimer() - 1); return; }
		UsingSkill = false;
	}
//	else if	(NPC_Mode == true)
//	{
//		
//
//	}//end: if(NPC_Mode)
	else //not NPC_Mode
	{
		if(Tick != 0)//Finish current action
		{
			if		(Status > STAND_CAST_SPELL) { if(Tick < Speed - 1) ++Tick; else Tick = 0;	}
			else if	(Status > SIT_OBJECT)		{ if(Tick <			7) ++Tick; else Tick = 0;	}
			else								{ Tick = 0;										}
		}
		else
		{
			if(Moving == true)
			{
				if(WarMode == true)
				{
				//	if		(weaponType == 2)	Status = WALK_CMBT_BOW;
				//	else if	(weaponType == 1)	Status = WALK_CMBT_STAFF;
				//	else						Status = WALK_CMBT_NORMAL;
				}
				else Status = WALK_NORMAL;
				CliMoveToCoord();
				Tick = 1;
			}//end: if(Moving == true)
			else //not moving
			{
				if(Standing == true)
				{
					if(WarMode == true)
					{
					//	if		(weaponType == 3)	Status = STAND_CAST_SPELL;
					//	else if (weaponType == 2)	Status = CMBT_STAFF;
					//	else if (weaponType == 1)	Status = CMBT_BOW;
					//	else						Status = CMBT_NORMAL;	
					}
					else
					{
					//	if		(weaponType == 3)	Status = STAND_CAST_SPELL;
					//	else if (weaponType == 2)	Status = STAND_STAFF;
					//	else if (weaponType == 1)	Status = STAND_BOW;
					/*	else	*/					Status = STAND_NORMAL;
					}
				}//end: if(Standing == true)
				else
				{
					// Remember to put a test in here to see what might be in the tile or if they're mounted.
					// Status = SIT_OBJECT; Status = SIT_GROUND;
				}//end: else
			}//end: else (aka 'not' moving)
		}//end: else
	//	Standing, Moving, Mounted, WarMode, CastingSpell
	//	#define	HORSE_CMBT_NORMAL			10	// (9)	
	}//end: not NPC_Mode
}
void Character::setRed(int data)
{
	textRed = data;
}
void Character::setGreen(int data)
{
	textGreen = data;
}
void Character::setBlue(int data)
{
	textBlue = data;
}
int	Character::getRed() const
{
	return textRed;
}
int	Character::getGre() const
{
	return textGreen;
}
int	Character::getBlu() const
{
	return textBlue;
}
void Character::setTargetOcc(Character *t)
{
	if(t == NULL)	TargetOccupant = NULL;
	else			TargetOccupant = t->getThis();
}
Character* Character::getTargetOcc()
{
	if(TargetOccupant != NULL)	return TargetOccupant->getThis();
	else						return NULL;
}
void Character::setTargetItem(Item *t)
{
	if(t == NULL)	TargetItem = NULL;
	else			TargetItem = t->getThis();
}
Item* Character::getTargetItem()
{
	if(TargetItem != NULL)	return TargetItem->getThis();
	else					return NULL;
}
void Character::setTargetWMX(int t)
{
	TargetWMX = t;
}
int	Character::getTargetWMX() const
{
	return TargetWMX;
}
void Character::setTargetWMY(int t)
{
	TargetWMY = t;
}
int	Character::getTargetWMY() const
{
	return TargetWMY;
}
void Character::setTargetAni(int t)
{
	TargetAnimate = t;
}
int	Character::getTargetAni() const
{
	return TargetAnimate;
}
void Character::setTargetType(int t)
{
	TargetType = t;
}
int	Character::getTargetType() const
{
	return TargetType;
}
void Character::setSimpleTarget(int i)
{
	SimpleTarget = i;
}
int	Character::getSimpleTarget() const
{
	return SimpleTarget;
}
void Character::CheckSelf()
{
	int i;
	tStr = Str; tDex = Dex; tCon = Con; tInt = Int; tWis = Wis; tCha = Cha; 
	for(i = 0; i < MAX_PLAYER_SKILLS; i++)
	{
		if		(Skills[i].GetSkill() == SkBalance)	{ tDex += int(Skills[i].GetLevel() / 5); }
		else if	(Skills[i].GetSkill() == SkEnduran)	{ tCon += int(Skills[i].GetLevel() / 5); }
		else if	(Skills[i].GetSkill() == SkFieldSt)	{ tInt += int(Skills[i].GetLevel() / 5); }
		else if	(Skills[i].GetSkill() == SkLeaders)	{ tCha += int(Skills[i].GetLevel() / 5); }
		else if	(Skills[i].GetSkill() == SkPhiloso)	{ tWis += int(Skills[i].GetLevel() / 5); }
		else if	(Skills[i].GetSkill() == SkWghtLif)	{ tStr += int(Skills[i].GetLevel() / 5); }
	}
	
	RunTimer = tCon;
	for(i = 0; i < MAX_PLAYER_SKILLS; i++)
		if(Skills[i].GetSkill() == SkRunning)
		{
			RunTimer += int(Skills[i].GetLevel() / 5); break;
		}
	CurRunTimer = RunTimer;

	/*
	ADD THIS WHEN EQUIPMENT IS IN PLACE

	for(in = 0; 0 < NUM_EQUIP_SLOTS; in++)
	{
		if(Body[NUM_EQUIP_SLOTS] - (get Attribute effecting data) == define_(Attribute))
		{
			if		(define_(Attribute) == D_Str)	tStr += Amount;
			else if	(define_(Attribute) == D_Dex)	tDex += Amount;
			else if	(define_(Attribute) == D_Con)	tCon += Amount;
			else if	(define_(Attribute) == D_Int)	tInt += Amount;
			else if	(define_(Attribute) == D_Wis)	tWis += Amount;
			else if	(define_(Attribute) == D_Cha)	tCha += Amount;
		}
	}
	*/
	Health = tCon * 2;
}
void Character::setPlat(int amount)
{
	mCoinPurse[0].SetNumber(amount);
}
int	Character::getPlat()
{
	return mCoinPurse[0].GetNumber();
}
void Character::setGold(int amount)
{
	mCoinPurse[1].SetNumber(amount);
}
int	Character::getGold()
{
	return mCoinPurse[1].GetNumber();
}
void Character::setSilv(int amount)
{
	mCoinPurse[2].SetNumber(amount);
}
int	Character::getSilv()
{
	return mCoinPurse[2].GetNumber();
}
void Character::setCopp(int amount)
{
	mCoinPurse[3].SetNumber(amount);
}
int	Character::getCopp()
{
	return mCoinPurse[3].GetNumber();
}
void Character::setNumSRs(int data)
{
	// 1-roll, Perfect Roller Player, gets +10% xp bonus
	// 2 through 11 equals a -1% to the 10% xp bonus...
	// 12 through 21 no xp modifications...
	// 22 through 31, each represents a -1% to a max of -10% bonus...
	// - M. White 7 April, 2019
	if(data >= 0)
	{
		numStatRolls = data;

		if		(numStatRolls > 31)	{ intXP_BonusMod = -10;	dblXP_BonusMod = 0.90; }
		else if	(numStatRolls > 21)	{ intXP_BonusMod =  0 - (numStatRolls - 21); dblXP_BonusMod = double(1 - (intXP_BonusMod / 10)); }
		else if	(numStatRolls > 11)	{ intXP_BonusMod = 0; dblXP_BonusMod = 1.00; }
		else if	(numStatRolls > 1)	{ intXP_BonusMod = 10 - (numStatRolls - 1); dblXP_BonusMod = double(1.1 - (intXP_BonusMod / 10)); }
		else						{ intXP_BonusMod = 10; dblXP_BonusMod = 1.1; }
	}
}
int Character::getNumSRs() const
{
	return numStatRolls;
}
int Character::getStatRollB() const
{
	return intXP_BonusMod;
}
/*
void Character::genRace() 
{	
	unsigned short user = 0;
	do
	{
		system("cls");
		cout << "Pick a Race by entering the number to the left:\n\n"
			 << "1)  Dwarf     \n"
			 << "2)  Elf       \n"
			 << "3)  Gnome     \n"
			 << "4)  Human     \n"
			 << "5)  Triblaufen\n" // Halfling
			 << "6)  Nymph     \n"
			 << "7)  Bugbear   \n"
			 << "8)  Goblin    \n"
			 << "9)  Gremlin   \n"
			 << "10) Hobgoblin \n";
		cin >> user;
	} while (user < 1 || user > 14); 
	
	Race = user;
}
void Character::printRace() const
{
	if		(Race ==  0) cout << "None";
	//Good Guys
	else if (Race ==  1) cout << "Dwarf";
	else if (Race ==  2) cout << "Elf";
	else if (Race ==  3) cout << "Gnome";
	else if (Race ==  4) cout << "Human";
	//Nuetral Guys
	else if (Race ==  5) cout << "Centaur";
	else if (Race ==  6) cout << "Triblaufen";
	else if (Race ==  7) cout << "Nymph";
	//Evil Guys
	else if (Race ==  8) cout << "Bugbear";
	else if (Race ==  9) cout << "Goblin";
	else if (Race == 10) cout << "Gremlin";
	else				 cout << "Hobgoblin";
}*/
/*
private:
	Item	Body[NUM_EQUIP_SLOTS];	// 31

	//These reflect what is in Either Transport, Backpack, 
	//or the six Pouches (not actual containers).
	Item	mTransport[28];	// 28, 24, 20, 16, 14
	Item	mBackPack[12];	// 12, 10, 8
	Item	mPouches[6][6];	// 2, 4, 6
	Item	mCoinPurse[4];	// Platinum, Gold, Silver, Copper

	char	chrFirstName[16];
	char	chrLastName[16];
	int		ID;

	Skill	Skills[MAX_PLAYER_SKILLS];
	int		NumSkills, LastSkillLeft, LastSkillRight, Level;//Level is the average of the levels of the skills

	int		X, Y, Z, facing, MyOffSetX, MyOffSetY, Tick, Speed, Mounted;
	int		RunTimer, CurRunTimer;
	int		maxX, maxY, maxZ;
	
	int		Title;//Duke, Baron, etc...
	int		Race, Sex, PortNumber, Height, Weight, Class;				
	int		BirthDay, BirthMonth, BirthYear, Age;
	
	int		Str, Dex, Con, Int, Wis, Cha, Com;
	int		tStr, tDex, tCon, tInt, tWis, tCha;
	int		Health, CurrentHealth;
	
	int		PVP_Status;
	int 	Status, OldStatus;			
	int 	textRed, textGreen, textBlue;	

	//Targeting stuff--------------
	Character*	TargetOccupant;
	Item*	TargetItem;
	int		TargetWMX;
	int		TargetWMY;
	int		TargetAnimate;
	int		TargetType;

	//This target is for mobs to attack a chair at a table...
	//Or an index in the Customers.
	int		SimpleTarget;
	//-----------------------------

	bool	NPC_Mode;
	bool	Moving;
	bool	WarMode;
	bool	Standing;
	bool	CastingSpell;
	bool	Created;
	bool	SittingTable;
	bool	UsingSkill;
	bool	RepeatSkill;
	string	transferString;
*/