package
{
	import flash.display.Sprite;
	import flash.display.MovieClip;
	import flash.events.Event;
	import flash.events.MouseEvent;
	import flash.events.KeyboardEvent;
	import flash.ui.Keyboard;
	import flash.ui.Mouse;

	public class Main extends Sprite
	{
		// Createing The Level
		// Reference To Tile Moveiclip
		private var tileVar:Tile;
		// Grid Width Can Be Set To Whatever Number Of Tiles Is In Each Line In The levelArray
		private var gridWidth:uint = 18;
		// The Level Array Holds Number Values To Repersent If A Tile Is A Empty Space, Wall, End Point, Etc
		private var levelArray:Array =
		[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
		 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
		 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
		 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
		 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
		 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
		 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
		 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
		 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
		 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
		 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
		 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
		 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
		 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
		 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
		 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
		 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
		 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1];
		// Level Vector Is A Vector That Is Later Filled With All The Tile Objects That Make Up The Level
		private var levelVector:Vector.<Object >  = new Vector.<Object >   ;
		// Pathfinding
		// Open List Is An Array Of The Current Tiles Being Checked
		private var openListArray:Array = [];
		// Close List Is An Array Of Tiles That Have Been Checked
		private var closeListArray:Array = [];
		// Current Parent Is The Current Tile We Are Checking The Surroundings Of
		private var currentParent:Object;
		// Current Target Is Our Target Tile
		private var currentTarget:Object;
		// Starting Parent Doesn't Really Need To Exist But Is A Reference To The First Tile Being Checked At The Start Of Pathfinding
		private var startingParent:Object;
		// A Variable To Check If The Path Has Been Found
		private var currentTargetFound:Boolean;
		// A Variable That Checks If No Path Can Be Found
		private var noPathCanBeFound:Boolean;
		// The Final Array That Is Filled With The Shortest Path To A Point
		private var finalListArray:Array = [];
		// Enemy
		private var enemyVector:Vector.<Object >  = new Vector.<Object >   ;
		private var enemyVar:Enemy;
		//private var currentTileEnemyInVector:Vector.<Object >  = new Vector.<Object >   ;
		//private var currentTileEnemyIn:Object = null;
		// Keyboard
		// Used As A Pause Button
		private var spaceKeyDown:Boolean;
		public function Main()
		{
			// Remove Right Click Menu;
			stage.addEventListener(MouseEvent.RIGHT_CLICK, function(e:Event){});
			// Create The Level
			createLevel();
			// Create The Enemy
			createEnemy();
			/*createEnemy();
			createEnemy();
			createEnemy();
			createEnemy();
			createEnemy();*/
			// On Enter Frame Events
			addEventListener(Event.ENTER_FRAME,onFrame);
			//
			stage.addEventListener(KeyboardEvent.KEY_UP,keyIsUp);
			stage.addEventListener(KeyboardEvent.KEY_DOWN,keyIsDown);
		}
		// On Frame Events
		private function onFrame(e:Event):void
		{
			// Checks If There Is A Path To Move Along
			if (noPathCanBeFound == false)
			{
				// Checks If Enemy Has Finished Path And If Enemy Movement Should Be Paused - If Both False Then Enemy Move Along Its Path
				// eV = Enemy Vector
				for (var eV=0; eV<enemyVector.length; eV++)
				{
					if (enemyVector[eV].enemyPathArray.length != 0 && spaceKeyDown == false)
					{
						// Simple Movement To Get To Each Tile
						if (enemyVector[eV].y > enemyVector[eV].enemyPathArray[0].y)
						{
							enemyVector[eV].y -=  enemyVector[eV].enemySpeed;
						}
						if (enemyVector[eV].y < enemyVector[eV].enemyPathArray[0].y)
						{
							enemyVector[eV].y +=  enemyVector[eV].enemySpeed;
						}
						if (enemyVector[eV].x > enemyVector[eV].enemyPathArray[0].x)
						{
							enemyVector[eV].x -=  enemyVector[eV].enemySpeed;
						}
						if (enemyVector[eV].x < enemyVector[eV].enemyPathArray[0].x)
						{
							enemyVector[eV].x +=  enemyVector[eV].enemySpeed;
						}
						// If The Enemy Reaches The Center Of A Tile Remove It From The List Of Tiles It Needs To Move To
						//if(this._x <= _root._xmouse + 1 && this._x >= _root._xmouse - 1){
						// if(this._y <= _root._ymouse + 1 && this._y >= _root._ymouse - 1 ){
						if (enemyVector[eV].x <= enemyVector[eV].enemyPathArray[0].x + enemyVector[eV].enemySpeed && enemyVector[eV].x >= enemyVector[eV].enemyPathArray[0].x - enemyVector[eV].enemySpeed)
						{
							if (enemyVector[eV].y <= enemyVector[eV].enemyPathArray[0].y + enemyVector[eV].enemySpeed && enemyVector[eV].y >= enemyVector[eV].enemyPathArray[0].y - enemyVector[eV].enemySpeed)
							{
								if (enemyVector[eV].enemyPathArray.length == 1)
								{
									enemyVector[eV].x = enemyVector[eV].enemyPathArray[0].x;
									enemyVector[eV].y = enemyVector[eV].enemyPathArray[0].y;
								}
								enemyVector[eV].enemyPathArray.splice(0,1);
							}
						}
					}
				}
			}
		}
		// Create Enemy
		private function createEnemy():void
		{
			enemyVar = new Enemy();
			enemyVar.x = 40 + Math.round(Math.random() * 640);
			enemyVar.y = 40 + Math.round(Math.random() * 640);
			enemyVar.enemyPathArray = [];
			enemyVar.currentTileEnemyIn = null;
			enemyVar.enemySpeed = 1;
			addChild(enemyVar);
			enemyVector.push(enemyVar);
		}
		// Create Level;
		private function createLevel():void
		{
			var tilePlacementX:Number = 20;
			var tilePlacementY:Number = 20;
			var currentCollum:int = 1;
			var currentRow:int = 1;
			// cLT = Create Level Tiles
			for (var cLT=0; cLT<levelArray.length; cLT++)
			{
				tileVar = new Tile();
				tileVar.x = tilePlacementX;
				tileVar.y = tilePlacementY;
				// Purely Aesthetic
				tileVar.gotoAndStop(levelArray[cLT]+1);
				// If The Level Array Not A 1 Then The Tile Is Walkable;
				if (levelArray[cLT] != 1)
				{
					tileVar.walkable = true;
				}
				else
				{
					// If The Level Array Is A 1 Then Make A Non-Walkable Wall Tile
					if (levelArray[cLT] == 1)
					{
						tileVar.walkable = false;
					}
				}
				// This Is A Little Preset Thing I Did Where If In The Level Array At The Start I Put A 2 In That Would Be The End Point
				// Much Like In A TD That Could Be The Point The Enemies Want To Get To
				/*if (levelArray[cLT] == 2)
				{
				currentTarget = tileVar;
				}*/
				// These Vars Are Used In The Pathfinding Functions And Are Explined When They Come Up
				tileVar.positionInArray = cLT;
				tileVar.currentRow = currentRow;
				tileVar.currentCollum = currentCollum;
				tileVar.gScore = 0;
				tileVar.hScore = 0;
				tileVar.fScore = 0;
				tileVar.currentTileParent = null;
				tileVar.alreadyOnClosedList = false;
				// This Listener Let Us Add And Remove Walls
				tileVar.addEventListener(MouseEvent.CLICK,makeIntoWall);
				// This Listener Lets Us Make A End Point
				tileVar.addEventListener(MouseEvent.RIGHT_MOUSE_DOWN,makeIntoEndArea);
				// Add The Child To Stage
				addChild(tileVar);
				// Push This Object Into The Level Vector
				levelVector.push(tileVar);
				// Updates The X and Y Placemetn For The Next Tile;
				tilePlacementX +=  40;
				currentRow++;
				if (tilePlacementX >= 720)
				{
					currentCollum++;
					currentRow = 1;
					tilePlacementX = 20;
					tilePlacementY +=  40;
				}
			}
			setChildIndex(tutorialText,numChildren - 1);
		}
		// This Function Lets Us Add/Remove Walls
		private function makeIntoWall(e:MouseEvent):void
		{
			// If Tile Is Not A Wall Make It A Wall
			if (e.currentTarget.walkable == true)
			{
				e.currentTarget.gotoAndStop(2);
				e.currentTarget.walkable = false;
			}
			else
			{
				// If Tile Is A Wall Make It Not A Wall
				if (e.currentTarget.walkable == false)
				{
					e.currentTarget.gotoAndStop(0);
					e.currentTarget.walkable = true;
				}
			}
			// If You Have A End Point Then Update The Path If You Have No End Point This Prevent A Crash
			if (currentTarget != null)
			{
				// Finds The Paths Starting Point
				findStartingPoint();
			}
		}
		private function makeIntoEndArea(e:MouseEvent):void
		{
			// This Is Purely Aesthetic - Like All gotoAndStop It Only Adjusts The Appearence Of The Tiles This Loop Can Be Removed
			// rLVA = Reset Level Vector Appearence
			for (var rLVA=0; rLVA<levelVector.length; rLVA++)
			{
				if (levelVector[rLVA].currentFrame == 3 || levelVector[rLVA].currentFrame == 7)
				{
					levelVector[rLVA].gotoAndStop(1);
				}
			}
			// Make Current Tile Into An End Area
			e.currentTarget.gotoAndStop(3);
			e.currentTarget.walkable = true;
			// Sets The Selected Tile To The Current Target Of The Pathfinding
			currentTarget = e.currentTarget;
			// Finds The Paths Starting Point
			findStartingPoint();

		}
		private function findStartingPoint():void
		{
			// fSP = Find Starting Point
			for (var fSP=0; fSP<levelVector.length; fSP++)
			{
				// lVHEV = Level Vector Hitting Enemy Vector
				for (var lVHEV=0; lVHEV<enemyVector.length; lVHEV++)
				{
					if (levelVector[fSP].hitTestPoint(enemyVector[lVHEV].x,enemyVector[lVHEV].y,true))
					{
						enemyVector[lVHEV].currentTileEnemyIn = levelVector[fSP];
						startingParent = levelVector[fSP];
						setPathfindingForCurrentParentTile(enemyVector[lVHEV].currentTileEnemyIn);
						findAPathForEnemy(enemyVector[lVHEV]);
						//break;
					}
				}
			}
			// Update Path
			//setPathfindingForCurrentParentTile(enemyVar.currentTileEnemyIn);
			//findAPathForEnemy(enemyVar);
		}
		private function findAPathForEnemy(currentEnemy:Object):void
		{
			// At The Start We Assume A Path Can Be Found
			noPathCanBeFound = false;
			// Reset The Open And Closed Lists
			openListArray = [];
			closeListArray = [];
			// Push The Tile The Enemy Is In Into The Open List
			openListArray.push(currentEnemy.currentTileEnemyIn);
			// Resets The Level Vectors Values For Pathfinding;
			// rLVPV = Reset Level Vector Pathfinding Values
			for (var rLVPV=0; rLVPV<levelVector.length; rLVPV++)
			{
				levelVector[rLVPV].gScore = 0;
				levelVector[rLVPV].hScore = 0;
				levelVector[rLVPV].fScore = 0;
				levelVector[rLVPV].currentTileParent = null;
				levelVector[rLVPV].alreadyOnClosedList = false;
			}
			// Reset The Fact That We Have Found The Square We Are Going To
			currentTargetFound = false;
			// Set The Current Parent Square To The Square The Enemy Is Currently In
			currentParent = currentEnemy.currentTileEnemyIn;
			// Loop Until We Find A Target
			while (currentTargetFound == false)
			{
				// If We Run Out Of Possible Tiles In Our Open List It Means The Target Can Not Be Reached (Is Surrounded By Impassable Tiles)
				if (openListArray.length == 0)
				{
					// We Break The Loop
					currentTargetFound = true;
					// And Set It So The onFrame Function Does Not Try To Move The Enemy To A Point That Can Not Be Reahced
					noPathCanBeFound = true;
				}
				// The Start Of Fun Pathfinding Functions
				setPathfindingForCurrentParentTile(currentParent);
				// Through The Above Function We Will Set currentTargetFound To True Unless It Is Impossible To Get To The Current Target
				if (currentTargetFound == true)
				{
					// Sets The Enemies Parth To The Final List Path We Create With The setPathfindingForCurrentParentTile Function
					currentEnemy.enemyPathArray = finalListArray;
					// Reverses This List Becuase It Starts At The End
					currentEnemy.enemyPathArray.reverse();
					// Remove The First Object In This List As We Are Already In That Square;
					currentEnemy.enemyPathArray.splice(0,1);
				}
			}
		}
		private function setPathfindingForCurrentParentTile(currentParentTile:Object):void
		{
			// Remove Current Parent From Open List
			// rCPFOL = Remove Current Parent From Open List
			for (var rCPFOL=0; rCPFOL<openListArray.length; rCPFOL++)
			{
				if (currentParent == openListArray[rCPFOL])
				{
					openListArray.splice(rCPFOL,1);
					break;
				}
			}
			// Add Current Parent To Close List - AKA The List Of Objects We've Checked
			closeListArray.push(currentParentTile);
			currentParentTile.alreadyOnClosedList = true;
			// NW Tile
			// Note If YOu Want Enemies To Not Be Able To Cut Through Walls At All
			// Check If Going NW Would Go Through A Wall - NOTE: IF YOU WANT TO ALLOW ENEMIES TO CUT THROUGH CORNERS REMOVE THIS IF STATEMENT
			// NOTE: If You Want Enemies To Be Able TO Move Diaginol Make This A Or
			if (levelVector[currentParentTile.positionInArray-(gridWidth)].walkable == true || levelVector[currentParentTile.positionInArray-(1)].walkable == true)
			{
				checkIfThisCurrentSurroundingTileIsOnOpenListAndIfNotAddIt(levelVector[currentParentTile.positionInArray-(gridWidth+1)]);
			}
			// N Tile
			checkIfThisCurrentSurroundingTileIsOnOpenListAndIfNotAddIt(levelVector[currentParentTile.positionInArray-(gridWidth)]);
			// Check If Going NE Would Go Through A Wall  - NOTE: IF YOU WANT TO ALLOW ENEMIES TO CUT THROUGH CORNERS REMOVE THIS IF STATEMENT
			if (levelVector[currentParentTile.positionInArray-(gridWidth)].walkable == true || levelVector[currentParentTile.positionInArray+(1)].walkable == true)
			{
				checkIfThisCurrentSurroundingTileIsOnOpenListAndIfNotAddIt(levelVector[currentParentTile.positionInArray-(gridWidth-1)]);
			}
			// W Tile
			checkIfThisCurrentSurroundingTileIsOnOpenListAndIfNotAddIt(levelVector[currentParentTile.positionInArray-(1)]);
			// E Tile
			checkIfThisCurrentSurroundingTileIsOnOpenListAndIfNotAddIt(levelVector[currentParentTile.positionInArray+(1)]);
			// SW Tile
			// Check If Going NW Would Go Through A Wall  - NOTE: IF YOU WANT TO ALLOW ENEMIES TO CUT THROUGH CORNERS REMOVE THIS IF STATEMENT
			if (levelVector[currentParentTile.positionInArray+(gridWidth)].walkable == true || levelVector[currentParentTile.positionInArray-(1)].walkable == true)
			{
				checkIfThisCurrentSurroundingTileIsOnOpenListAndIfNotAddIt(levelVector[currentParentTile.positionInArray+(gridWidth-1)]);
			}
			// S Tile
			checkIfThisCurrentSurroundingTileIsOnOpenListAndIfNotAddIt(levelVector[currentParentTile.positionInArray+(gridWidth)]);
			// Check If Going SE Would Go Through A Wall  - NOTE: IF YOU WANT TO ALLOW ENEMIES TO CUT THROUGH CORNERS REMOVE THIS IF STATEMENT
			if (levelVector[currentParentTile.positionInArray+(gridWidth)].walkable == true || levelVector[currentParentTile.positionInArray+(1)].walkable == true)
			{
				checkIfThisCurrentSurroundingTileIsOnOpenListAndIfNotAddIt(levelVector[currentParentTile.positionInArray+(gridWidth+1)]);
			}
			// Find New Current Parent Tile
			getNewCurrentParentTile();
		}
		private function checkIfThisCurrentSurroundingTileIsOnOpenListAndIfNotAddIt(currentChildToCheckIfOnOpenArray:Object):void
		{
			var currentTileChildGScoreToTest:int = currentChildToCheckIfOnOpenArray.gScore
			var comparisionOfCurrentChildGScoreOnCurrentParth:int
			// If The Target We Are Checking Is The Target Point We Want To Get To Then We Have Found Our Path
			if (currentChildToCheckIfOnOpenArray == currentTarget)
			{
				currentTargetFound = true;
				// Sets End Tile Parent To Current Parent
				currentTarget.currentParent = currentParent;
				// This Function Gives Us Our Path From The End To The Tile The Enemy Is In
				findWayBack();
			}
			// If We Have Not Found Our Target And This Tile Is Not Our Target Then...
			if (currentChildToCheckIfOnOpenArray != currentTarget && currentTargetFound == false)
			{
				// If It Is A Wall Or Already On The Closed List We Skip It
				if (currentChildToCheckIfOnOpenArray.walkable == true && currentChildToCheckIfOnOpenArray.alreadyOnClosedList == false)
				{
					// Check If This Child If Already On The Open List
					var thisChildIsNotAlreadyOnOpenList:Boolean = true;
					// aCPSTTOL = Add Current Parent Surrounding Tiles To Open List
					for (var aCPSTTOL=0; aCPSTTOL<openListArray.length; aCPSTTOL++)
					{
						if (openListArray[aCPSTTOL] == currentChildToCheckIfOnOpenArray)
						{
							// This Child Is On The Open List So We Do A Special Check To Find A New A Parent If A Better Movement Can Be Found
							// Check If Parent Is Up Down Left Or Right Of This Tile
							comparisionOfCurrentChildGScoreOnCurrentParth = currentParent.gScore
							if (levelVector[currentChildToCheckIfOnOpenArray.positionInArray-(gridWidth)] == currentChildToCheckIfOnOpenArray.currentParent || levelVector[currentChildToCheckIfOnOpenArray.positionInArray-(1)] == currentChildToCheckIfOnOpenArray.currentParent|| levelVector[currentChildToCheckIfOnOpenArray.positionInArray+(1)] == currentChildToCheckIfOnOpenArray.currentParent || levelVector[currentChildToCheckIfOnOpenArray.positionInArray+(gridWidth)] == currentChildToCheckIfOnOpenArray.currentParent)
							{
								// A Up Down Left Or Right Movement Cost 10
								comparisionOfCurrentChildGScoreOnCurrentParth += 10
							}
							// Check If Parent Is Diagonal To This Tile
							if (levelVector[currentChildToCheckIfOnOpenArray.positionInArray - (gridWidth - 1)] == currentChildToCheckIfOnOpenArray.currentParent || levelVector[currentChildToCheckIfOnOpenArray.positionInArray - (gridWidth + 1)] == currentChildToCheckIfOnOpenArray.currentParent || levelVector[currentChildToCheckIfOnOpenArray.positionInArray + (gridWidth - 1)] == currentChildToCheckIfOnOpenArray.currentParent || levelVector[currentChildToCheckIfOnOpenArray.positionInArray + (gridWidth + 1)] == currentChildToCheckIfOnOpenArray.currentParent)
							{
								// A Diagonal Movement Cost 14
								comparisionOfCurrentChildGScoreOnCurrentParth += 14
							}
							// If Going To That Child Would Make A Longer Path Then Reparent It
							if(comparisionOfCurrentChildGScoreOnCurrentParth < currentTileChildGScoreToTest)
							{
								currentChildToCheckIfOnOpenArray.currentParent = currentParent;
								addToATileGScore(currentChildToCheckIfOnOpenArray)
							}
							thisChildIsNotAlreadyOnOpenList = false;
							break;
						}
					}
					// If thisChildIsNotAlreadyOnOpenList Is Still True Then Add It To The Open List
					if (thisChildIsNotAlreadyOnOpenList == true)
					{
						// Add Current Child To Open Array
						openListArray.push(currentChildToCheckIfOnOpenArray);
						// Sets Child Of Current Parent, Parent Var To That Of The Current Parent;
						currentChildToCheckIfOnOpenArray.currentParent = currentParent;
						// Give This Tile An H Score
						// An H Score Is The Number Of Tiles This Tile Is From The End (Not Counting Walls) Times 10
						updateATileHScore(currentChildToCheckIfOnOpenArray);
						// Add To This Tiles G Score
						// A G Score Is How Far A Tile Is In The Path We Are Taking - If Getting To This Tile Is A Up, Down, Left, Or Right Movement
						// Then The G Score Is Equal To Its Parents G Score + 10, If Its A Diagonal Movement Then The G Score Is Equal To Its Parents G Score + 14 Beucase Moveing Diagonal Is Slightly Longer Path
						addToATileGScore(currentChildToCheckIfOnOpenArray);
						// Update The Tiles F Score
						// A F Score Is The Tiles H + The Tiles G Score
						// The Lower The F Score The Better The Path Is To TAke
						updateATileFScore(currentChildToCheckIfOnOpenArray);
					}
				}
			}
		}
		private function getNewCurrentParentTile():void
		{
			// If We Still Have Not Found Out Target
			if (currentTargetFound == false)
			{
				// Look For The Lowest F Value
				var currentLowestFValue:int = 10000;
				// fLFV = Find Lowest F Value
				for (var fLFV=0; fLFV<openListArray.length; fLFV++)
				{
					// If A Tiles F Value Is Lower Then The Current One Then Our Parent Becomes That Tile
					if (openListArray[fLFV].fScore < currentLowestFValue)
					{
						currentLowestFValue = openListArray[fLFV].fScore;
						currentParent = openListArray[fLFV];
					}
				}
			}
		}
		private function findWayBack():void
		{
			// We Have Found Our Current Target Now We Just Keep Adding The Parent Of Each Square Until We Get To Our Starting Square
			var currentFindWayBackParent:Object = currentTarget;
			// Each New Parent We Hop To Is Added To Our Final List Array
			finalListArray = [];
			while (currentFindWayBackParent != startingParent)
			{
				finalListArray.push(currentFindWayBackParent);
				currentFindWayBackParent.gotoAndStop(7);
				currentFindWayBackParent = currentFindWayBackParent.currentParent;
			}
			// When We Find Our Parent We Have The Shortest Path From The Current Target To Our Parent
			if (currentFindWayBackParent == startingParent)
			{
				finalListArray.push(startingParent);
				startingParent.gotoAndStop(7);
			}
		}
		private function addToATileGScore(currentTileGScoreToAddTo:Object):void
		{
			// Check If Parent Is Up Down Left Or Right Of This Tile
			if (levelVector[currentTileGScoreToAddTo.positionInArray-(gridWidth)] == currentTileGScoreToAddTo.currentParent || levelVector[currentTileGScoreToAddTo.positionInArray-(1)] == currentTileGScoreToAddTo.currentParent|| levelVector[currentTileGScoreToAddTo.positionInArray+(1)] == currentTileGScoreToAddTo.currentParent || levelVector[currentTileGScoreToAddTo.positionInArray+(gridWidth)] == currentTileGScoreToAddTo.currentParent)
			{
				// A Up Down Left Or Right Movement Cost 10
				currentTileGScoreToAddTo.gScore = currentTileGScoreToAddTo.currentParent.gScore + 10;
			}
			// Check If Parent Is Diagonal To This Tile
			if (levelVector[currentTileGScoreToAddTo.positionInArray - (gridWidth - 1)] == currentTileGScoreToAddTo.currentParent || levelVector[currentTileGScoreToAddTo.positionInArray - (gridWidth + 1)] == currentTileGScoreToAddTo.currentParent || levelVector[currentTileGScoreToAddTo.positionInArray + (gridWidth - 1)] == currentTileGScoreToAddTo.currentParent || levelVector[currentTileGScoreToAddTo.positionInArray + (gridWidth + 1)] == currentTileGScoreToAddTo.currentParent)
			{
				// A Diagonal Movement Cost 14
				currentTileGScoreToAddTo.gScore = currentTileGScoreToAddTo.currentParent.gScore + 14;
			}
		}
		private function updateATileHScore(currentTileHScoreToUpdate:Object):void
		{
			// Simple Math To Find The Combined Diffrence Between The Current Tiles Collum And Row Compated To The Target Tile Collum And Row
			var currentTargetCollum:int = currentTarget.currentCollum;
			var currentTargetRow:int = currentTarget.currentRow;
			var currentCollumDiffrence:int;
			var currentRowDiffrence:int;
			currentCollumDiffrence = currentTargetCollum - currentTileHScoreToUpdate.currentCollum;
			if (currentCollumDiffrence < 0)
			{
				currentCollumDiffrence *=  -1;
			}
			currentRowDiffrence = currentTargetRow - currentTileHScoreToUpdate.currentRow;
			if (currentRowDiffrence < 0)
			{
				currentRowDiffrence *=  -1;
			}
			currentTileHScoreToUpdate.hScore = 10 * (currentCollumDiffrence + currentRowDiffrence);
		}
		private function updateATileFScore(currentTileGScoreToUpdate:Object):void
		{
			// Adds The Tile G and H Score Together
			currentTileGScoreToUpdate.fScore = currentTileGScoreToUpdate.hScore + currentTileGScoreToUpdate.gScore;
		}
		// Keyboard Events
		private function keyIsUp(e:KeyboardEvent):void
		{
			if (e.keyCode == 32)
			{
				spaceKeyDown = false;
			}
		}
		private function keyIsDown(e:KeyboardEvent):void
		{
			if (e.keyCode == 32)
			{
				spaceKeyDown = true;
			}
		}
	}
}