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

/**** 
* Game Code
****/ 
// Define the grid size
var gridSize = 20;
// Create a 2D array to represent the grid
var grid = new Array(gridSize);
for (var i = 0; i < gridSize; i++) {
	grid[i] = new Array(gridSize);
}
// Calculate the size of each cell in the grid
var cellWidth = 2048 / gridSize;
var cellHeight = 2048 / gridSize;
// Populate the grid with cells
for (var x = 0; x < gridSize; x++) {
	for (var y = 0; y < gridSize; y++) {
		var tile;
		if (x == 0 || y == 0 || x == gridSize - 1 || y == gridSize - 1) {
			tile = LK.getAsset('wallTile', {
				anchorX: 0.0,
				anchorY: 0.0,
				scaleX: cellWidth / 100,
				scaleY: cellHeight / 100,
				x: x * cellWidth,
				y: y * cellHeight
			});
		} else {
			tile = LK.getAsset('floorTile', {
				anchorX: 0.0,
				anchorY: 0.0,
				scaleX: cellWidth / 100,
				scaleY: cellHeight / 100,
				x: x * cellWidth,
				y: y * cellHeight
			});
		}
		game.addChild(tile);
		grid[x][y] = tile;
	}
}
var selectedTile;
// Handle touch events on the game stage
game.on('down', function (obj) {
	// Get the position of the touch event
	var pos = obj.event.getLocalPosition(game);
	// Calculate the grid coordinates of the touch event
	var gridX = Math.floor(pos.x / cellWidth);
	var gridY = Math.floor(pos.y / cellHeight);
	// Clear the tint of the previously selected tile
	if (selectedTile) {
		selectedTile.tint = 0xFFFFFF;
	}
	// Highlight the tile under the touch event
	var tile = grid[gridX][gridY];
	tile.tint = 0x00ff00;
	// Save the selected tile
	selectedTile = tile;
});
// Spawn the mouse on a random tile at the start of the game
var spawnX, spawnY;
do {
	spawnX = Math.floor(Math.random() * gridSize);
	spawnY = Math.floor(Math.random() * gridSize);
} while (grid[spawnX][spawnY] === 'wallTile');
var character = LK.getAsset('character', {
	anchorX: 0.0,
	anchorY: 0.0,
	scaleX: cellWidth / 100,
	scaleY: cellHeight / 100,
	x: spawnX * cellWidth,
	y: spawnY * cellHeight
});
game.addChild(character);
var shadow = LK.getAsset('shadow', {
	anchorX: 0.5,
	anchorY: 0.0,
	scaleX: cellWidth / 120,
	scaleY: cellHeight / 30,
	x: character.x + cellWidth / 2,
	y: character.y + cellHeight
});
shadow.alpha = 0.5;
game.addChild(shadow);
// Add an idle animation to the character
var idleAnimation = 0;
LK.on('tick', function () {
	idleAnimation++;
	if (idleAnimation > 60) {
		character.scaleX = cellWidth / 100;
	}
	if (idleAnimation > 120) {
		character.scaleX = -cellWidth / 100;
		idleAnimation = 0;
	}
});
// Create a method to calculate the shortest path from the mouse to the selected tile using the A* pathfinding algorithm
function calculatePath(start, end) {
	// Create an empty array to store the open list
	var openList = [];
	// Create an empty array to store the closed list
	var closedList = [];
	// Add the start node to the open list
	openList.push(start);
	// While the open list is not empty
	while (openList.length > 0) {
		// Sort the open list by f value
		openList.sort(function (a, b) {
			return a.f - b.f;
		});
		// Pop the node with the lowest f value off the open list
		var current = openList.pop();
		// Add the current node to the closed list
		closedList.push(current);
		// If the current node is the end node
		if (current === end) {
			// Return the path
			var path = [];
			while (current.parent) {
				path.push(current);
				current = current.parent;
			}
			return path.reverse();
		}
		// For each neighbor of the current node
		var neighbors = getNeighbors(current);
		for (var i = 0; i < neighbors.length; i++) {
			var neighbor = neighbors[i];
			// If the neighbor is not walkable or is in the closed list
			if (!neighbor.walkable || closedList.includes(neighbor)) {
				// Skip to the next neighbor
				continue;
			}
			// Calculate the new possible g value for the neighbor
			var g = current.g + 1;
			// If the neighbor is not in the open list or the new g value is less than the neighbor's current g value
			if (!openList.includes(neighbor) || g < neighbor.g) {
				// Update the neighbor's g value
				neighbor.g = g;
				// Update the neighbor's h value
				neighbor.h = heuristic(neighbor, end);
				// Update the neighbor's f value
				neighbor.f = neighbor.g + neighbor.h;
				// Update the neighbor's parent to the current node
				neighbor.parent = current;
				// If the neighbor is not in the open list
				if (!openList.includes(neighbor)) {
					// Add the neighbor to the open list
					openList.push(neighbor);
				}
			}
		}
	}
	// If no path was found, return an empty array
	return [];
}
// Create a method to get the neighbors of a node
function getNeighbors(node) {
	var neighbors = [];
	var x = node.x;
	var y = node.y;
	if (grid[x - 1] && grid[x - 1][y]) {
		neighbors.push(grid[x - 1][y]);
	}
	if (grid[x + 1] && grid[x + 1][y]) {
		neighbors.push(grid[x + 1][y]);
	}
	if (grid[x][y - 1]) {
		neighbors.push(grid[x][y - 1]);
	}
	if (grid[x][y + 1]) {
		neighbors.push(grid[x][y + 1]);
	}
	return neighbors;
}
// Create a method to calculate the heuristic value for a node (distance to the end node)
function heuristic(node, end) {
	var dx = Math.abs(node.x - end.x);
	var dy = Math.abs(node.y - end.y);
	return dx + dy;
}
// Create a method to move the character along a path
function moveCharacter(path) {
	if (path && path.length > 0) {
		var nextTile = path.shift();
		character.x = nextTile.x * cellWidth;
		character.y = nextTile.y * cellHeight;
		shadow.x = character.x + cellWidth / 2;
		shadow.y = character.y + cellHeight - 15;
		shadow.scaleX = cellWidth / 120;
		shadow.scaleY = cellHeight / 30;
		LK.setTimeout(function () {
			moveCharacter(path);
		}, 500);
	}
}
// Handle touch events on the game stage
game.on('down', function (obj) {
	// Get the position of the touch event
	var pos = obj.event.getLocalPosition(game);
	// Calculate the grid coordinates of the touch event
	var gridX = Math.floor(pos.x / cellWidth);
	var gridY = Math.floor(pos.y / cellHeight);
	// Clear the tint of the previously selected tile
	if (selectedTile) {
		selectedTile.tint = 0xFFFFFF;
	}
	// Highlight the tile under the touch event
	var tile = grid[gridX][gridY];
	tile.tint = 0x00ff00;
	// Save the selected tile
	selectedTile = tile;
	// Calculate the path from the mouse to the selected tile
	var path = calculatePath({
		x: Math.floor(character.x / cellWidth),
		y: Math.floor(character.y / cellHeight)
	}, {
		x: gridX,
		y: gridY
	});
	// Move the character along the path
	moveCharacter(path);
});

===================================================================
--- original.js
+++ change.js
@@ -39,9 +39,8 @@
 				scaleY: cellHeight / 100,
 				x: x * cellWidth,
 				y: y * cellHeight
 			});
-			tile.tint = 0xD3D3D3; // Light grey tint
 		}
 		game.addChild(tile);
 		grid[x][y] = tile;
 	}