/**** 
* Initialize Game
****/ 
var game = new LK.Game({
	backgroundColor: 0x000000
});

/**** 
* Game Code
****/ 
// Create a 2D array to represent the grid
var gridSize = 20;
var character;
var wallTiles = [];
var floorTiles = [];
var selectedTile;
var tileOriginalColor;
var isGameStarted = false;
var grid = new Array(gridSize * gridSize);
for (var i = 0; i < gridSize * gridSize; i++) {
	var x = i % gridSize;
	var y = Math.floor(i / gridSize);
	var tile;
	if (x === 0 || y === 0 || x === gridSize - 1 || y === gridSize - 1) {
		tile = LK.getAsset('wallTile', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: x * 100 + (2048 - gridSize * 100) / 2,
			y: y * 100 + (2732 - gridSize * 100) / 2
		});
		wallTiles.push(tile);
	} else {
		tile = LK.getAsset('floorTile', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: x * 100 + (2048 - gridSize * 100) / 2,
			y: y * 100 + (2732 - gridSize * 100) / 2
		});
		floorTiles.push(tile);
	}
	game.addChild(tile);
	grid[i] = tile;
}
// Select a random wall tile and replace it with a hole tile
var randomWallTileIndex = Math.floor(Math.random() * wallTiles.length);
var randomWallTile = wallTiles[randomWallTileIndex];
var holeTile = LK.getAsset('holeTile', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: randomWallTile.x,
	y: randomWallTile.y
});
game.addChild(holeTile);
game.removeChild(randomWallTile);
wallTiles[randomWallTileIndex] = holeTile;
// Create a mask and add it to the game
// Create a boolean variable to track the game state
var fadeEffect = {
	alpha: 0,
	speed: 0.01
};
LK.on('tick', function () {
	if (fadeEffect.alpha < 1) {
		fadeEffect.alpha += fadeEffect.speed;
		game.alpha = fadeEffect.alpha;
	} else {
		// Call the event On game start
		LK.emit('On game start');
	}
});
// Add event listener for touch events;
var originalColor;
game.on('down', function (obj) {
	if (isGameStarted) {
		var pos = obj.event.getLocalPosition(game);
		var x = Math.floor((pos.x - (2048 - gridSize * 100) / 2) / 100);
		var y = Math.floor((pos.y - (2732 - gridSize * 100) / 2) / 100);
		if (selectedTile) {
			selectedTile.tint = tileOriginalColor; // Restore the original color of the previously selected tile
		}
		if (x >= 0 && x < gridSize && y >= 0 && y < gridSize) {
			var index = y * gridSize + x;
			if (floorTiles.includes(grid[index])) {
				selectedTile = grid[index];
				tileOriginalColor = selectedTile.tint;
				selectedTile.tint = 0xeaf23; // Highlight the selected tile in yellow
			}
		}
	}
});
// Subscribe to the event On game start
LK.on('On game start', function () {
	// Spawn an instance of the character on the hole tile
	character = LK.getAsset('character', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: holeTile.x,
		y: holeTile.y
	});
	game.addChild(character);
	// Switch the value of the isGameStarted variable
	isGameStarted = true;
});
// Implement A* pathfinding algorithm
function aStarPathfinding(start, end) {
	// Create open and closed list
	var openList = [];
	var closedList = [];
	openList.push(start);
	while (openList.length > 0) {
		// Get the current node
		var lowestIndex = 0;
		for (var i = 0; i < openList.length; i++) {
			if (openList[i].f < openList[lowestIndex].f) {
				lowestIndex = i;
			}
		}
		var currentNode = openList[lowestIndex];
		// End case -- result has been found, return the traced path
		if (currentNode === end) {
			var curr = currentNode;
			var ret = [];
			while (curr.parent) {
				ret.push(curr);
				curr = curr.parent;
			}
			return ret.reverse();
		}
		// Normal case -- move currentNode from open to closed, process each of its neighbors
		openList = openList.filter(function (node) {
			return node !== currentNode;
		});
		closedList.push(currentNode);
		var neighbors = currentNode.neighbors;
		for (var i = 0; i < neighbors.length; i++) {
			var neighbor = neighbors[i];
			if (closedList.includes(neighbor) || neighbor.isWall()) {
				// Not a valid node to process, skip to next neighbor
				continue;
			}
			// g score is the shortest distance from start to current node, we need to check if
			// the path we have arrived at this neighbor is the shortest one we have seen yet
			var gScore = currentNode.g + 1; // 1 is the distance from a node to it's neighbor
			var gScoreIsBest = false;
			if (!openList.includes(neighbor)) {
				// This the the first time we have arrived at this node, it must be the best
				gScoreIsBest = true;
				neighbor.h = heuristic(neighbor, end);
				openList.push(neighbor);
			} else if (gScore < neighbor.g) {
				// We have already seen the node, but last time it had a worse g (distance from start)
				gScoreIsBest = true;
			}
			if (gScoreIsBest) {
				// Found an optimal (so far) path to this node. Store info on how we got here and
				// just how good it really is...
				neighbor.parent = currentNode;
				neighbor.g = gScore;
				neighbor.f = neighbor.g + neighbor.h;
			}
		}
	}
	// No result was found -- empty array signifies failure to find path
	return [];
}
// Move the character to the selected tile using A* pathfinding
game.on('down', function (obj) {
	if (isGameStarted && selectedTile) {
		var path = aStarPathfinding(character, selectedTile);
		for (var i = 0; i < path.length; i++) {
			character.x = path[i].x;
			character.y = path[i].y;
		}
	}
});

===================================================================
--- original.js
+++ change.js
@@ -126,9 +126,11 @@
 			}
 			return ret.reverse();
 		}
 		// Normal case -- move currentNode from open to closed, process each of its neighbors
-		openList.remove(currentNode);
+		openList = openList.filter(function (node) {
+			return node !== currentNode;
+		});
 		closedList.push(currentNode);
 		var neighbors = currentNode.neighbors;
 		for (var i = 0; i < neighbors.length; i++) {
 			var neighbor = neighbors[i];