DUDE ANIMATION

------------------------------------------------------------------------------------------------------

1- OPEN ACTION SCRIPT 3

2- CRATE FOLDER DUDE ON DESKTOP AND CRATE CLASS FILES

AND SET NAME Dude.as , SimpleAStar.as , SimpleCell.as , SimpleGrid.as

3- CRATE ACTION LAYER AND PASTE BELOW ACTION SCRIPT

--------------------------------------------------------------------------------------------------

var array:Array = [ 1,1,1,1,1,1,1,1,1,1,1,

1,0,1,0,0,0,0,0,0,0,1,

1,0,1,0,1,0,0,0,0,1,1,

1,0,1,0,1,0,1,1,0,0,1,

1,0,0,0,1,0,1,0,0,0,1,

1,1,1,1,1,0,1,0,0,0,1,

1,0,0,0,0,0,1,0,0,0,1,

1,1,1,1,1,1,1,1,1,1,1 ];

var grid:SimpleGrid = new SimpleGrid(11,8,50,array);

grid.draw(this);

var aStar:SimpleAStar = new SimpleAStar(grid);

var dude = new Dude(grid, aStar,75,75,2);

addChild(dude);

--------------------------------------------------------------------------------------------

4-IMPORT SPRITE ON STAGE AND CHANGE INTO MOVE CLIP

AND SET CLASS NAME

-------------------------------------------------------------------------------------------------

------------------------------------------------------------------------------------------------------

Dude.as

-------------------------------------------------------------------------------------------------------

package {
 
 // the dude is a Sprite and will update every frame
 import flash.display.Sprite;
 import flash.events.Event;
 
 public class Dude extends Sprite {
  
  // a reference to the grid and the pathfinding
  private var grid:SimpleGrid;
  private var pathfinding:SimpleAStar;
  // a path to follow
  private var path:Array;
  // a movement speed
  private var speed:Number;
  
  public function Dude(g:SimpleGrid, pf:SimpleAStar, sx:Number, sy:Number, s:int) {
   // set the variables
   grid = g;
   pathfinding = pf;
   x = sx;
   y = sy;
   speed = s;
   path = new Array();
   // make the Dude move every frame
   addEventListener(Event.ENTER_FRAME, loop);
  }
  
  private function loop(e:Event) {
   // if the path isn't empty
   if (path.length>0) {
    // move towards to the first point
    var dx = path[0].x*grid.cellSize+grid.cellSize/2-x;
    var dy = path[0].y*grid.cellSize+grid.cellSize/2-y;
    var distance = Math.sqrt((dx*dx)+(dy*dy));
    var angle = Math.atan2(dy,dx);
    // if the distance is more than the Dude's speed
    if (distance > speed) {
     x += Math.cos(angle)*speed;
     y += Math.sin(angle)*speed;
    } else { // if the distance is less than speed
     // move to the target point
     x = path[0].x*grid.cellSize+grid.cellSize/2;
     y = path[0].y*grid.cellSize+grid.cellSize/2;
     // remove the top cell from the path
     path.shift();
    }
   } else { // if the path is empty
    // pick a random cell in the grid and attempt to go to it
    path = pathfinding.getPath(x/grid.cellSize, y/grid.cellSize, Math.random()*grid.width, Math.random()*grid.height);
   }
  }
 }
}

------------------------------------------------------------------------------------------------------

SimpleAStar.as

-------------------------------------------------------------------------------------------------------

package  {
 
 // No extension needed
 public class SimpleAStar {

// private variables
  private var current:SimpleCell;  // the current cell being looked at
  private var grid:SimpleGrid;  // the grid of all cells
  private var sx:int;     // starting x position of path
  private var sy:int;     // starting y position of path
  private var tx:int;     // target x position of path
  private var ty:int;     // target y position of path
  private var openList:Array;   // a list of 'open' cells
  private var closedList:Array;  // a list of 'closed' cells

// pass a grid in to the constructor
  public function SimpleAStar(theGrid:SimpleGrid) {
   grid = theGrid;
  }

// a function to start the pathfinding and return the end result as an array of cells
  // pass in start and end coordinates
  public function getPath(startX:int, startY:int, targetX:int, targetY:int):Array {
   sx=startX;
   sy=startY;
   tx=targetX;
   ty=targetY;
   // open list and closed list
   openList = new Array();
   closedList = new Array();
   // if the start or end are impassable, return no path
   if (grid.getCell(sx,sy).value!=0 || grid.getCell(tx,ty).value!=0) {
    return new Array();
   }
   // do some pathfinding!
   // set the start position as the current cell
   // g to 0 and calculate heuristic
   current=grid.getCell(sx,sy);
   current.g=0;
   current.h=getH(sx,sy,tx,ty);
   // set parent to null
   current.parent=null;
   // add to open list
   openList.push(current);
   // recursive stuff starts here
   recurseToGoal();
   // work backwards from the current cell to get the path
   // go from the current to its parent until the start is reached
   var path:Array = new Array();
   // optional - draw a line to each cell to show the path (import Sprite)
   while (current.x!=sx || current.y!=sy) {
    path.unshift(current);
    current=current.parent;
   }
   path.unshift(current);
   //return the path
   return path;
  }
  
  // the recursive search - this function reuses itself until a path is generated
  public function recurseToGoal() {
   // remove the current cell from the open list
   if (openList.indexOf(current)>=0) {
    openList.splice(openList.indexOf(current),1);
   }
   // add it to the closed list
   closedList.push(current);
   // if the current cell is the goal, the path is complete, so return.
   if (current.x==tx && current.y==ty) {
    return;
   }
   // get a list of cells adjacent to the current cell
   var adjacents:Array = grid.getAdjacents(current);
   // optional - randomly shuffle them to generate varying paths of the same length
   while (adjacents.length>0) {
    var checking:SimpleCell = adjacents.shift();
    // if the cell is not on the closed list 
    if (closedList.indexOf(checking)<0) {
     // set its h score
     checking.h=getH(checking.x, checking.y, tx, ty);
     // if it is already on the open list
     if (openList.indexOf(checking)>=0) {
      // check to see if its g score would be lower with the current cell as its parent
      var compG = current.g+getDistance(current, checking);
      // if so, make the current cell its parent
      if (compG<=checking.g) {
       checking.parent = current;
       checking.g=compG;
      }
     // else, if this adjacent cell wasn't on the open list
     } else {
      // make the current cell its parent and assign a g value
      checking.parent=current;
      checking.g=current.g+getDistance(current,checking);
      // add this adjacent cell to the open list for future reference
      openList.push(checking);
     }
    }
   }
   // after all adjacents have been checked...
   // update the current cell to be the cell with the lowest f score in the open list
   var nextCell:SimpleCell=null;
   for (var i=0; i<openList.length; i++) {
    if (nextCell==null || openList[i].f < nextCell.f) {
     nextCell=openList[i];
    }
   }
   // if nextCell is null (the open list was empty), there is no path.
   // optional - choose the lowest h score from the closed list as a "that'll do" cell
   if (nextCell==null) {
    for (i=0; i<closedList.length; i++) {
     if (closedList[i].h<current.h) {
      current=closedList[i];
     }
    }
   // else... if there are still cells to recurse through
   } else {
    // set the current cell the be the next cell (decided above)
    current=nextCell;
    // call this function again (a function that calls itself = recursive)
    recurseToGoal();
   }
  }
  
  // this function returns 10 or 14 based on the 2 cells' positions
  // return 14 if diagonal, 10 otherwise
  public function getDistance(c1:SimpleCell, c2:SimpleCell):int {
   if (c1.x!=c2.x && c1.y!=c2.y) return 14;
   return 10;
  }
  
  // the heuristic (h) generator. Can be done in many different ways
  public function getH(x1:int, y1:int, x2:int, y2:int):int {
   // manhattan method
   var x = (x1>x2) ? x1-x2 : x2-x1;
   var y = (y1>y2) ? y1-y2 : y2-y1;
   return (x+y)*10;
   // 'real method'
   //return Math.sqrt(Math.pow(x2-x1,2)+Math.pow(y2-y1,2))*10;
  }

}
 
}

------------------------------------------------------------------------------------------------------

SimpleCell.as

-------------------------------------------------------------------------------------------------------

------------------------------------------------------------------------------------------------------

SimpleGrid.as

-------------------------------------------------------------------------------------------------------

package  {
 
 // import the Sprite class so we can draw the grid if requested
 import flash.display.Sprite;
 
 // no extension
 public class SimpleGrid {

private var grid:Array;   // a 1-dimensional array to store the cells
  private var _width:int;   // the width of the grid in cells, not pixels
  private var _height:int;  // the height of the grid in cells.
  public var cellSize:int;  // the width and height of each cell in pixels  
  
  // pass a width, height, cell size and cell array to the constructor
  public function SimpleGrid(w:int=10, h:int=10, c:int=10, array:Array=null) {
   // set width and height, don't allow less than 2 on each axis
   _width = (w<2) ? 2 : w;
   _height = (h<2) ? 2 : h;
   // set cell size
   cellSize=c;
   // if the user didn't pass in an array, make it a blank one
   if (array==null) array = new Array();
   // populate the grid (finish it if an incomplete one was passed).
   grid = new Array();
   while (grid.length<_width*_height) {
    if (array.length>grid.length) {
     grid.push(new SimpleCell(array[grid.length],
            grid.length%_width,
            int(grid.length/_width)));
    } else {
     grid.push(new SimpleCell(0,
            grid.length%_width,
            int(grid.length/_width)));
    }
   }
  }
  
  // get functions for height and width
  public function get width():int {
   return _width;
  }
  
  public function get height():int {
   return _height;
  }
  
  // getCell - return the cell at x,y
  public function getCell(x:int, y:int):SimpleCell {
   if (x>=0 && x<_width && y>=0 && y<_height) {
    return grid[y*_width+x];
   }
   return new SimpleCell(-1,x,y); // return an impassable cell if out of bounds
  }
  
  // get the cells adjacent to the specified cell if they are accessible and walkable
  public function getAdjacents(cell:SimpleCell):Array {
   var adjacents = new Array();
   // if the cell isn't part of the grid, return an empty list
   if (grid.indexOf(cell)<0) return adjacents;
   // loop around the cell and determine if the cells are valid
   for (var ix=cell.x-1; ix<cell.x+2; ix++) {
    for (var iy=cell.y-1; iy<cell.y+2; iy++) {
     var potential:SimpleCell = getCell(ix, iy);
     if (potential.value==0 && potential!=cell && passable(cell, potential)) {
      adjacents.push(potential);
     }
    }
   }
   return adjacents;
  }
  
  // a function to determine if movement between 2 cells is possible - checks diagonals
  public function passable(c1:SimpleCell, c2:SimpleCell):Boolean {
   // if the x or y values of the cells are equal - movement is possible 
   if (c1.x==c2.x || c1.y==c2.y) return true;
   // ternary operator use to determine starting x and y values
   var startX = (c1.x>c2.x) ? c2.x : c1.x;
   var endX = (c1.x>c2.x) ? c1.x : c2.x;
   var startY = (c1.y>c2.y) ? c2.y : c1.y;
   var endY = (c1.y>c2.y) ? c1.y : c2.y;
   // check a 2x2 square starting from the above position
   // if any of the 4 cells are impassable, diagonal movement is impossible
   for (var x=startX; x<=endX; x++) {
    for (var y=startY; y<=endY; y++) {
     if (grid[y*_width+x].value!=0) return false;
    }
   }
   // if all 4 cells are passable, return true
   return true;
  }
  
  // draw the grid to a specified Sprite. Pass the sprite in from outside
  public function draw(sprite:Sprite) {
   // clear graphics and set line style
   sprite.graphics.clear();
   sprite.graphics.lineStyle(0.1,0);
   // draw horizontal lines
   for (var i:int=0; i<=_height; i++) {
    sprite.graphics.moveTo(0, i*cellSize);
    sprite.graphics.lineTo(_width*cellSize, i*cellSize);
   }
   // draw verticals
   for (i=0; i<=_width; i++) {
    sprite.graphics.moveTo(i*cellSize,0);
    sprite.graphics.lineTo(i*cellSize, _height*cellSize);
   }
   // fill in impassable spaces with solid rectangles
   sprite.graphics.beginFill(0)
   for (i=0; i<grid.length; i++) {
    if (grid[i].value!=0) {
     sprite.graphics.drawRect(cellSize*(i%_width), cellSize*(int(i/_width)), cellSize, cellSize);
    }
   }
   sprite.graphics.endFill();
  }
 }
}

Flash College

Sunday, 21 September 2014

DUDE ANIMATION