Поиск пути во флеш. Очистка массива.

Avrilka · 06.07.2010, 15:15

Код AS1/AS2:

findPath2 = function(map, startY, startX, endY, endX) {;
 
if (startY == undefined || startX == undefined) return null; // Error: no starting point;
if (endY == undefined || endX == undefined) return null; // Error: no ending point;
if (endY == startY && endX == startX) { trace ('!')};
// Caches dimensions;
var mapH = map.length;
var mapW = map[0].length;
 
// New status arrays;
var mapStatus = [];
for (var i=0; i<mapH; i++){;
mapStatus[i] = [];
for (var j=0; j<mapW; j++){;
mapStatus[i][j]={};
};
};
// Finds the way given a certain path;
 
// Constants/configuration - change here as needed! --------------------------------;
var HV_COST = 1; // "Movement cost" for horizontal/vertical moves;
var D_COST = 99999; // "Movement cost" for diagonal moves;
var ALLOW_DIAGONAL = false; // If diagonal movements are allowed at all;
var ALLOW_DIAGONAL_CORNERING = false; // If diagonal movements over corners are allowed;
 
// Complimentary functions =========================================================;
 
isOpen = function (y, x) {;
// Return TRUE if the point is on the open list, false if otherwise;
return mapStatus[y][x].open;
};
isClosed = function (y, x) {;
// Return TRUE if the point is on the closed list, false if otherwise;
return mapStatus[y][x].closed;
};
nearerSquare = function() {;
// Returns the square with a lower movementCost + heuristic distance;
// from the open list;
var minimum = 999999;
var indexFound = 0;
var thisF = undefined;
var thisSquare = undefined;
var i = openList.length;
// Finds lowest;
while (i-->0) {;
thisSquare = mapStatus[openList[i][0]][openList[i][1]];
thisF = thisSquare.heuristic + thisSquare.movementCost;
if (thisF <= minimum) {;
minimum = thisF;
indexFound = i;
};
};
// Returns lowest;
return indexFound;
};
closeSquare = function(y, x) {;
// Drop from the open list;
var len = openList.length;
for (var i=0; i < len; i++) {;
if (openList[i][0] == y) {;
if (openList[i][1] == x) {;
openList.splice(i, 1);
break;
};
};
};
// Closes an open square;
mapStatus[y][x].open = false;
mapStatus[y][x].closed = true;
};
openSquare = function(y, x, parent, movementCost, heuristic, replacing) {;
// Opens a square;
if (!replacing) {;
openList.push([y,x]);
mapStatus[y][x] = {heuristic:heuristic, open:true, closed:false};
};
mapStatus[y][x].parent = parent;
mapStatus[y][x].movementCost = movementCost;
};
 
// Ok, now go back to our regular schedule. Find the path! -------------------------;
 
 
 
// Now really starts;
var openList = new Array();
openSquare (startY, startX, undefined, 0);
 
// Loops until there's no other way to go OR found the exit;
while (openList.length > 0 && !isClosed(endY, endX)) {;
// Browse through open squares;
var i = nearerSquare();
 
var nowY = openList[i][0]/1;
var nowX = openList[i][1]/1;
 
// Closes current square as it has done its purpose...;
closeSquare (nowY, nowX);
// Opens all nearby squares, ONLY if:;
//trace('__now:['+nowX+","+nowY+"]");
for (var j=nowY-1; j<(nowY+2); j++) {;
for (var k=nowX-1; k<(nowX+2); k++) {;
if (j >= 0 && j < mapH && k >= 0 && k < mapW && map[j][k] != 0) {;
//if (j >= 0 && j < mapH && k >= 0 && k < mapW && !(j==nowY && k==nowX) && (ALLOW_DIAGONAL || j==nowY || k==nowX) && (ALLOW_DIAGONAL_CORNERING || j==nowY || k==nowX || (map[j][nowX] != 0 && map[nowY][k] != 0))) {;
// If not outside the boundaries or at the same point or a diagonal (if disabled) or a diagonal (with a wall next to it)...;
// And if not a wall...;
if (!isClosed(j,k)) {;
// And if not closed... THEN open.;
//var py=mapStatus[nowY][nowX].parent[0];
//var px=mapStatus[nowY][nowX].parent[1];
//var pcost=mapStatus[nowY][nowX].movementCost;
//if(py!=undefined){pcost=mapStatus[py][px].movementCost;};
var movementCost = mapStatus[nowY][nowX].movementCost + ((j==nowY || k==nowX ? HV_COST : D_COST) * map[j][k]);
//trace("___map("+k+","+j+")="+map[j][k]+","+movementCost+'['+mapStatus[nowY][nowX].movementCost+',('+nowX+','+nowY+')]');
//gfx_mc.sur_map[k][j]=movementCost;
//trace('('+k+','+j+') from ['+nowX+","+nowY+"]");
//gfx_mc.sur_map_type[k][j]=100;
if (isOpen(j,k)) {;
// Already opened: check if it's ok to re-open (cheaper);
if (movementCost < mapStatus[j][k].movementCost) {;
// Cheaper: simply replaces with new cost and parent.;
//trace('__replace:('+k+','+j+') for ('+nowX+','+nowY+")");
openSquare (j, k, [nowY, nowX], movementCost, undefined, true); // heuristic not passed: faster, not needed 'cause it's already set;
};
} else {;
// Empty: open.;
var heuristic = (Math.abs (j - endY) + Math.abs (k - endX)) * 10;
openSquare (j, k, [nowY, nowX], movementCost, heuristic, false);
};
} else {;
// Already closed, ignore.;
};
};
};
};
};
//Ended;
var pFound = isClosed(endY, endX); // Was the path found?;
// Clean up temporary functions;
//delete isOpen;
//delete isClosed;
//delete nearerSquare;
//delete closeSquare;
//delete openSquare;
 
if (pFound) {;
// Ended with path found; generates return path;
var returnPath = [];
var justPath = [];
var nowY = endY;
var nowX = endX;
var movCost=mapStatus[nowY][nowX].movementCost;
while ((nowY != startY || nowX != startX)) {;
returnPath.push([nowX,nowY,movCost]);
justPath.push([nowX,nowY]);
var newY = mapStatus[nowY][nowX].parent[0];
var newX = mapStatus[nowY][nowX].parent[1];
nowY = newY;
nowX = newX;
movCost=mapStatus[nowY][nowX].movementCost;
};
returnPath.push([startX,startY,0]);
justPath.push([startX,startY]);
var path_xy:Array= []// [];
for(var i=returnPath.length-1;i>-1;i--){;
path_xy.push(returnPath[i]);
_root.battle.mazer.path_end.push(justPath[i]);  // КОНЕЧНЫЙ МАССИВ!
//trace("____path:"+ path_xy.join('|'));
//trace("____path:"+ _root.battle.mazer.path_end.join('|'));
};
 
return path_xy;
} else {;
_root.battle.mazer.path_end.push(['NOTHING']);
// Ended with 0 open squares; ran out of squares, path NOT found;
return null;
};
};

Функция нахождения пути.
Трейс

Код:

3 2 || 5 5
Path:5,5 || 5,4 || 4,4 || 4,3 || 3,3 || 3,2

3 4 || 5 5
Path:5,5 || 5,4 || 4,4 || 4,3 || 3,3 || 3,2 || 5,5 || 5,4 || 4,4 || 3,4

4 3 || 5 5
Path:5,5 || 5,4 || 4,4 || 4,3 || 3,3 || 3,2 || 5,5 || 5,4 || 4,4 || 3,4 || 5,5 || 5,4 || 4,4 || 4,3
2 3 || 5 5
Path:5,5 || 5,4 || 4,4 || 4,3 || 3,3 || 3,2 || 5,5 || 5,4 || 4,4 || 3,4 || 5,5 || 5,4 || 4,4 || 4,3 || 5,5 || 5,4 || 4,4 || 4,3 || 3,3 || 2,3
3 2 || 5 5
Path:5,5 || 5,4 || 4,4 || 4,3 || 3,3 || 3,2 || 5,5 || 5,4 || 4,4 || 3,4 || 5,5 || 5,4 || 4,4 || 4,3 || 5,5 || 5,4 || 4,4 || 4,3 || 3,3 || 2,3 || 5,5 || 5,4 || 4,4 || 4,3 || 3,3 || 3,2

Надо вычеркнуть зачеркнутое. Я покапался в коде, ничего не вышло.

KirAmp · 07.07.2010, 01:12

удалить первый элемент массива можно при помощи функции array.shift()
При помощи array.reverse() можно поменять порядок на противоположный, и удалить последние эллементы при помощи array.pop()

в вашем случае сделайте так:
цикл от 0 до кол-ва элементов преведущего массива, с процедурой array.shift()