/**** 
* Plugins
****/ 
var tween = LK.import("@upit/tween.v1");

/**** 
* Classes
****/ 
var Dot = Container.expand(function () {
	var self = Container.call(this);
	var graphics = self.attachAsset('dot', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.collected = false;
	return self;
});
var Ghost = Container.expand(function (color) {
	var self = Container.call(this);
	var mazeHeight = 21;
	var mazeWidth = 19;
	var graphics = self.attachAsset(color === 0xFF0000 ? 'ghost' : 'ghostBlue', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	if (color !== 0xFF0000 && color !== 0x0000FF) {
		graphics.tint = color;
	}
	self.gridX = 0;
	self.gridY = 0;
	self.targetX = 0;
	self.targetY = 0;
	self.moving = false;
	self.speed = 2;
	self.vulnerable = false;
	self.eaten = false;
	self.originalColor = color;
	self.moveTimer = 0;
	self.makeVulnerable = function () {
		self.vulnerable = true;
		self.removeChild(graphics);
		graphics = self.attachAsset('ghostBlue', {
			anchorX: 0.5,
			anchorY: 0.5
		});
	};
	self.makeNormal = function () {
		self.vulnerable = false;
		self.removeChild(graphics);
		graphics = self.attachAsset('ghost', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		if (self.originalColor !== 0xFF0000) {
			graphics.tint = self.originalColor;
		}
	};
	self.moveToGrid = function (gx, gy) {
		if (self.moving) return;
		if (gy >= 0 && gy < mazeHeight && gx >= 0 && gx < mazeWidth && maze[gy] && maze[gy][gx] !== 1) {
			self.moving = true;
			self.gridX = gx;
			self.gridY = gy;
			self.targetX = offsetX + gx * cellSize + cellSize / 2;
			self.targetY = offsetY + gy * cellSize + cellSize / 2;
		}
	};
	self.update = function () {
		if (self.moving) {
			var dx = self.targetX - self.x;
			var dy = self.targetY - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance < self.speed) {
				self.x = self.targetX;
				self.y = self.targetY;
				self.moving = false;
			} else {
				self.x += dx / distance * self.speed;
				self.y += dy / distance * self.speed;
			}
		}
		self.moveTimer++;
		if (!self.moving && self.moveTimer > 30) {
			self.moveTimer = 0;
			var directions = [{
				x: self.gridX - 1,
				y: self.gridY
			}, {
				x: self.gridX + 1,
				y: self.gridY
			}, {
				x: self.gridX,
				y: self.gridY - 1
			}, {
				x: self.gridX,
				y: self.gridY + 1
			}];
			var validDirections = [];
			for (var i = 0; i < directions.length; i++) {
				var dir = directions[i];
				if (dir.y >= 0 && dir.y < mazeHeight && dir.x >= 0 && dir.x < mazeWidth && maze[dir.y] && maze[dir.y][dir.x] !== 1) {
					validDirections.push(dir);
				}
			}
			if (validDirections.length > 0) {
				var randomDir = validDirections[Math.floor(Math.random() * validDirections.length)];
				self.moveToGrid(randomDir.x, randomDir.y);
			}
		}
	};
	return self;
});
var Pacman = Container.expand(function () {
	var self = Container.call(this);
	var mazeHeight = 21;
	var mazeWidth = 19;
	var graphics = self.attachAsset('pacman', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.gridX = 9;
	self.gridY = 19;
	self.targetX = 0;
	self.targetY = 0;
	self.moving = false;
	self.speed = 4;
	self.moveToGrid = function (gx, gy) {
		if (self.moving) return;
		if (gy >= 0 && gy < mazeHeight && gx >= 0 && gx < mazeWidth && maze[gy] && maze[gy][gx] !== 1) {
			self.moving = true;
			self.gridX = gx;
			self.gridY = gy;
			self.targetX = offsetX + gx * cellSize + cellSize / 2;
			self.targetY = offsetY + gy * cellSize + cellSize / 2;
		}
	};
	self.update = function () {
		if (self.moving) {
			var dx = self.targetX - self.x;
			var dy = self.targetY - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance < self.speed) {
				self.x = self.targetX;
				self.y = self.targetY;
				self.moving = false;
			} else {
				self.x += dx / distance * self.speed;
				self.y += dy / distance * self.speed;
			}
		}
	};
	return self;
});
var PowerPellet = Container.expand(function () {
	var self = Container.call(this);
	var graphics = self.attachAsset('powerPellet', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.collected = false;
	self.update = function () {
		graphics.scaleX = 1 + Math.sin(LK.ticks * 0.1) * 0.2;
		graphics.scaleY = 1 + Math.sin(LK.ticks * 0.1) * 0.2;
	};
	return self;
});

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

/**** 
* Game Code
****/ 
var maze = [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 1], [1, 3, 1, 1, 2, 1, 1, 1, 2, 1, 2, 1, 1, 1, 2, 1, 1, 3, 1], [1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1], [1, 2, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 2, 1], [1, 2, 2, 2, 2, 1, 2, 2, 2, 1, 2, 2, 2, 1, 2, 2, 2, 2, 1], [1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 2, 1, 1, 1, 2, 1, 1, 1, 1], [0, 0, 0, 1, 2, 1, 0, 0, 2, 0, 2, 0, 0, 1, 2, 1, 0, 0, 0], [1, 1, 1, 1, 2, 1, 0, 1, 1, 0, 1, 1, 0, 1, 2, 1, 1, 1, 1], [0, 0, 0, 0, 2, 0, 0, 1, 0, 0, 0, 1, 0, 0, 2, 0, 0, 0, 0], [1, 1, 1, 1, 2, 1, 0, 1, 0, 0, 0, 1, 0, 1, 2, 1, 1, 1, 1], [0, 0, 0, 1, 2, 1, 0, 1, 1, 1, 1, 1, 0, 1, 2, 1, 0, 0, 0], [1, 1, 1, 1, 2, 1, 0, 0, 0, 0, 0, 0, 0, 1, 2, 1, 1, 1, 1], [1, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 1], [1, 2, 1, 1, 2, 1, 1, 1, 2, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1], [1, 3, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 3, 1], [1, 1, 2, 1, 2, 1, 2, 1, 1, 1, 1, 1, 2, 1, 2, 1, 2, 1, 1], [1, 2, 2, 2, 2, 1, 2, 2, 2, 1, 2, 2, 2, 1, 2, 2, 2, 2, 1], [1, 2, 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 2, 1], [1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1]];
var mazeWidth = maze[0].length;
var mazeHeight = maze.length;
var cellSize = 60;
var offsetX = (2048 - mazeWidth * cellSize) / 2;
var offsetY = (2732 - mazeHeight * cellSize) / 2;
var walls = [];
var dots = [];
var powerPellets = [];
var ghosts = [];
var pacman = null;
var powerMode = false;
var powerModeTimer = 0;
var totalDots = 0;
var collectedDots = 0;
var scoreTxt = new Text2('0', {
	size: 80,
	fill: 0xFFFFFF
});
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
for (var y = 0; y < mazeHeight; y++) {
	for (var x = 0; x < mazeWidth; x++) {
		var cell = maze[y][x];
		var worldX = offsetX + x * cellSize + cellSize / 2;
		var worldY = offsetY + y * cellSize + cellSize / 2;
		if (cell === 1) {
			var wall = game.addChild(LK.getAsset('wall', {
				anchorX: 0.5,
				anchorY: 0.5,
				x: worldX,
				y: worldY
			}));
			walls.push(wall);
		} else if (cell === 2) {
			var dot = game.addChild(new Dot());
			dot.x = worldX;
			dot.y = worldY;
			dot.gridX = x;
			dot.gridY = y;
			dots.push(dot);
			totalDots++;
		} else if (cell === 3) {
			var powerPellet = game.addChild(new PowerPellet());
			powerPellet.x = worldX;
			powerPellet.y = worldY;
			powerPellet.gridX = x;
			powerPellet.gridY = y;
			powerPellets.push(powerPellet);
		}
	}
}
pacman = game.addChild(new Pacman());
pacman.gridX = 9;
pacman.gridY = 19;
pacman.x = offsetX + pacman.gridX * cellSize + cellSize / 2;
pacman.y = offsetY + pacman.gridY * cellSize + cellSize / 2;
pacman.targetX = pacman.x;
pacman.targetY = pacman.y;
var ghostColors = [0xFF0000, 0xFFB8FF, 0x00FFFF, 0xFFB852];
var ghostStartPositions = [{
	x: 8,
	y: 10
}, {
	x: 9,
	y: 9
}, {
	x: 10,
	y: 10
}, {
	x: 9,
	y: 11
}];
for (var i = 0; i < 4; i++) {
	var ghost = game.addChild(new Ghost(ghostColors[i]));
	ghost.gridX = ghostStartPositions[i].x;
	ghost.gridY = ghostStartPositions[i].y;
	ghost.x = offsetX + ghost.gridX * cellSize + cellSize / 2;
	ghost.y = offsetY + ghost.gridY * cellSize + cellSize / 2;
	ghost.targetX = ghost.x;
	ghost.targetY = ghost.y;
	ghosts.push(ghost);
}
// AI variables
var aiMoveTimer = 0;
var aiTarget = null;
var aiPath = [];
var errors = [];
var errorText = new Text2('', {
	size: 40,
	fill: 0xFF0000
});
errorText.anchor.set(0.5, 0);
errorText.y = 100;
LK.gui.top.addChild(errorText);
// AI pathfinding function
function findPath(startX, startY, targetX, targetY) {
	var queue = [{
		x: startX,
		y: startY,
		path: []
	}];
	var visited = {};
	visited[startX + ',' + startY] = true;
	while (queue.length > 0) {
		var current = queue.shift();
		if (current.x === targetX && current.y === targetY) {
			return current.path;
		}
		var directions = [{
			x: current.x - 1,
			y: current.y,
			dir: 'left'
		}, {
			x: current.x + 1,
			y: current.y,
			dir: 'right'
		}, {
			x: current.x,
			y: current.y - 1,
			dir: 'up'
		}, {
			x: current.x,
			y: current.y + 1,
			dir: 'down'
		}];
		for (var i = 0; i < directions.length; i++) {
			var next = directions[i];
			var key = next.x + ',' + next.y;
			if (!visited[key] && next.y >= 0 && next.y < mazeHeight && next.x >= 0 && next.x < mazeWidth && maze[next.y][next.x] !== 1) {
				visited[key] = true;
				var newPath = current.path.slice();
				newPath.push(next.dir);
				queue.push({
					x: next.x,
					y: next.y,
					path: newPath
				});
			}
		}
	}
	return [];
}
// Find nearest collectible
function findNearestCollectible() {
	var nearest = null;
	var minDistance = Infinity;
	// Check dots first
	for (var i = 0; i < dots.length; i++) {
		if (!dots[i].collected) {
			var distance = Math.abs(pacman.gridX - dots[i].gridX) + Math.abs(pacman.gridY - dots[i].gridY);
			if (distance < minDistance) {
				minDistance = distance;
				nearest = {
					x: dots[i].gridX,
					y: dots[i].gridY,
					type: 'dot'
				};
			}
		}
	}
	// Check power pellets (prioritize if ghosts are near)
	for (var i = 0; i < powerPellets.length; i++) {
		if (!powerPellets[i].collected) {
			var distance = Math.abs(pacman.gridX - powerPellets[i].gridX) + Math.abs(pacman.gridY - powerPellets[i].gridY);
			var ghostNear = false;
			for (var j = 0; j < ghosts.length; j++) {
				if (!ghosts[j].eaten && Math.abs(pacman.gridX - ghosts[j].gridX) + Math.abs(pacman.gridY - ghosts[j].gridY) < 3) {
					ghostNear = true;
					break;
				}
			}
			if (ghostNear && distance < minDistance) {
				minDistance = distance;
				nearest = {
					x: powerPellets[i].gridX,
					y: powerPellets[i].gridY,
					type: 'power'
				};
			}
		}
	}
	return nearest;
}
// AI movement logic
function aiMove() {
	if (pacman.moving) return;
	// Find target if we don't have one or reached current target
	if (!aiTarget || pacman.gridX === aiTarget.x && pacman.gridY === aiTarget.y) {
		aiTarget = findNearestCollectible();
		if (aiTarget) {
			aiPath = findPath(pacman.gridX, pacman.gridY, aiTarget.x, aiTarget.y);
			if (aiPath.length === 0) {
				errors.push("AI Error: No path found to target at " + aiTarget.x + "," + aiTarget.y);
			}
		} else {
			errors.push("AI Error: No collectibles found");
		}
	}
	// Move along path
	if (aiPath.length > 0) {
		aiMoveTimer = 0; // Reset timer when moving
		var nextMove = aiPath.shift();
		var newGridX = pacman.gridX;
		var newGridY = pacman.gridY;
		switch (nextMove) {
			case 'left':
				newGridX--;
				break;
			case 'right':
				newGridX++;
				break;
			case 'up':
				newGridY--;
				break;
			case 'down':
				newGridY++;
				break;
		}
		// Validate move
		if (newGridY >= 0 && newGridY < mazeHeight && newGridX >= 0 && newGridX < mazeWidth && maze[newGridY][newGridX] !== 1) {
			pacman.moveToGrid(newGridX, newGridY);
		} else {
			errors.push("AI Error: Invalid move attempted to " + newGridX + "," + newGridY);
			aiTarget = null; // Reset target
			aiPath = [];
		}
	}
}
// Error detection
function detectErrors() {
	// Check if Pacman is stuck
	if (!pacman.moving && aiMoveTimer > 120) {
		// 2 seconds at 60fps
		errors.push("AI Error: Pacman appears to be stuck at " + pacman.gridX + "," + pacman.gridY);
		aiMoveTimer = 0;
	}
	// Check for ghost collision without power mode
	for (var i = 0; i < ghosts.length; i++) {
		if (!ghosts[i].eaten && pacman.gridX === ghosts[i].gridX && pacman.gridY === ghosts[i].gridY) {
			if (!powerMode) {
				errors.push("AI Error: Collision with ghost at " + pacman.gridX + "," + pacman.gridY + " without power mode");
			}
		}
	}
	// Display latest error
	if (errors.length > 0) {
		errorText.setText("Errors: " + errors.length + " | Latest: " + errors[errors.length - 1]);
		if (errors.length > 10) {
			errors.shift(); // Keep only last 10 errors
		}
	}
}
// Remove manual controls and replace with AI
game.down = function (x, y, obj) {
	// AI controls - no manual input needed
};
game.up = function (x, y, obj) {
	// AI controls - no manual input needed  
};
game.update = function () {
	// AI movement every 10 frames (slower than ghosts for difficulty)
	aiMoveTimer++;
	if (aiMoveTimer % 10 === 0) {
		aiMove();
	}
	// Error detection
	detectErrors();
	if (powerMode) {
		powerModeTimer--;
		if (powerModeTimer <= 0) {
			powerMode = false;
			for (var i = 0; i < ghosts.length; i++) {
				if (!ghosts[i].eaten) {
					ghosts[i].makeNormal();
				}
			}
		}
	}
	for (var i = dots.length - 1; i >= 0; i--) {
		var dot = dots[i];
		if (!dot.collected && pacman.gridX === dot.gridX && pacman.gridY === dot.gridY) {
			dot.collected = true;
			dot.visible = false;
			collectedDots++;
			LK.setScore(LK.getScore() + 10);
			scoreTxt.setText(LK.getScore());
			LK.getSound('eatDot').play();
			var collectedPowerPellets = 0;
			for (var j = 0; j < powerPellets.length; j++) {
				if (powerPellets[j].collected) collectedPowerPellets++;
			}
			if (collectedDots >= totalDots && collectedPowerPellets >= powerPellets.length) {
				LK.showYouWin();
			}
		}
	}
	for (var i = powerPellets.length - 1; i >= 0; i--) {
		var pellet = powerPellets[i];
		if (!pellet.collected && pacman.gridX === pellet.gridX && pacman.gridY === pellet.gridY) {
			pellet.collected = true;
			pellet.visible = false;
			powerMode = true;
			powerModeTimer = 300;
			LK.setScore(LK.getScore() + 50);
			scoreTxt.setText(LK.getScore());
			LK.getSound('powerUp').play();
			for (var j = 0; j < ghosts.length; j++) {
				if (!ghosts[j].eaten) {
					ghosts[j].makeVulnerable();
				}
			}
		}
	}
	for (var i = 0; i < ghosts.length; i++) {
		var ghost = ghosts[i];
		if (pacman.gridX === ghost.gridX && pacman.gridY === ghost.gridY) {
			if (powerMode && ghost.vulnerable && !ghost.eaten) {
				ghost.eaten = true;
				ghost.visible = false;
				LK.setScore(LK.getScore() + 200);
				scoreTxt.setText(LK.getScore());
				LK.getSound('eatGhost').play();
				LK.setTimeout(function (ghostIndex) {
					return function () {
						ghost.eaten = false;
						ghost.visible = true;
						ghost.gridX = ghostStartPositions[ghostIndex].x;
						ghost.gridY = ghostStartPositions[ghostIndex].y;
						ghost.x = offsetX + ghost.gridX * cellSize + cellSize / 2;
						ghost.y = offsetY + ghost.gridY * cellSize + cellSize / 2;
						ghost.makeNormal();
					};
				}(i), 3000);
			} else if (!ghost.vulnerable && !ghost.eaten) {
				LK.showGameOver();
			}
		}
	}
};

===================================================================
--- original.js
+++ change.js
@@ -60,10 +60,10 @@
 		if (gy >= 0 && gy < mazeHeight && gx >= 0 && gx < mazeWidth && maze[gy] && maze[gy][gx] !== 1) {
 			self.moving = true;
 			self.gridX = gx;
 			self.gridY = gy;
-			self.targetX = gx * 60 + 30;
-			self.targetY = gy * 60 + 30;
+			self.targetX = offsetX + gx * cellSize + cellSize / 2;
+			self.targetY = offsetY + gy * cellSize + cellSize / 2;
 		}
 	};
 	self.update = function () {
 		if (self.moving) {
@@ -129,10 +129,10 @@
 		if (gy >= 0 && gy < mazeHeight && gx >= 0 && gx < mazeWidth && maze[gy] && maze[gy][gx] !== 1) {
 			self.moving = true;
 			self.gridX = gx;
 			self.gridY = gy;
-			self.targetX = gx * 60 + 30;
-			self.targetY = gy * 60 + 30;
+			self.targetX = offsetX + gx * cellSize + cellSize / 2;
+			self.targetY = offsetY + gy * cellSize + cellSize / 2;
 		}
 	};
 	self.update = function () {
 		if (self.moving) {
@@ -231,8 +231,10 @@
 pacman.gridX = 9;
 pacman.gridY = 19;
 pacman.x = offsetX + pacman.gridX * cellSize + cellSize / 2;
 pacman.y = offsetY + pacman.gridY * cellSize + cellSize / 2;
+pacman.targetX = pacman.x;
+pacman.targetY = pacman.y;
 var ghostColors = [0xFF0000, 0xFFB8FF, 0x00FFFF, 0xFFB852];
 var ghostStartPositions = [{
 	x: 8,
 	y: 10
@@ -251,8 +253,10 @@
 	ghost.gridX = ghostStartPositions[i].x;
 	ghost.gridY = ghostStartPositions[i].y;
 	ghost.x = offsetX + ghost.gridX * cellSize + cellSize / 2;
 	ghost.y = offsetY + ghost.gridY * cellSize + cellSize / 2;
+	ghost.targetX = ghost.x;
+	ghost.targetY = ghost.y;
 	ghosts.push(ghost);
 }
 // AI variables
 var aiMoveTimer = 0;