Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- 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
- resetVectorAppearence()
- 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
- resetVectorAppearence()
- // 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 resetVectorAppearence():void
- {
- // 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);
- }
- }
- }
- 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;
- }
- }
- }
- }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement