/**** 
* Classes
****/ 
// OnScreenController class encapsulating A, B buttons and D-pad
var OnScreenController = Container.expand(function () {
	var self = Container.call(this);
	// Add a background for the on screen controllers
	var yPosAdjustment = -180;
	var buttonYPosAdjustment = -273.2;
	var dpadButtonSize = 270;
	// Removed redundant tint application on A and B buttons
	LK.screen = {
		width: 2048,
		height: 2732
	}; // Initialize screen dimensions
	var aButtonPosition = {
		x: LK.screen.width * 0.75,
		y: LK.screen.height * 0.85 + buttonYPosAdjustment + LK.screen.height * 0.055
	};
	var buttonSize = {
		width: 400,
		height: 403.01
	};
	var aButton = self.attachAsset('aButton', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: aButtonPosition.x,
		y: aButtonPosition.y,
		width: buttonSize.width,
		height: buttonSize.height
	});
	// Removed tint application
	// D-pad
	var dpadBase = self.attachAsset('dpadBase', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: LK.screen.width * 0.24,
		y: LK.screen.height * 0.89 + yPosAdjustment - 10,
		scaleX: LK.screen.width * 0.003,
		scaleY: LK.screen.width * 0.003
	});
	// Move dpad base to the top of the display list so it appears on top of the arrows
	self.setChildIndex(dpadBase, self.children.length - 1);
	var dpadLeft = self.attachAsset('dpadButtonLeft', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: dpadBase.x - 300,
		y: dpadBase.y,
		width: dpadButtonSize,
		height: dpadButtonSize,
		alpha: 0,
		// Tint arrow yellow
		orientation: 3
	});
	// Refactored D-pad control to use moveCharacter function for cleaner code
	var moveInterval;
	function startMovingCharacter(xDir, yDir) {
		if (moveInterval) {
			LK.clearInterval(moveInterval);
		}
		isCharacterMoving = true;
		moveCharacter(xDir, yDir);
		moveInterval = LK.setInterval(function () {
			moveCharacter(xDir, yDir);
		}, 150);
	}
	dpadLeft.on('down', function () {
		startMovingCharacter(-1, 0);
	});
	var dpadUp = self.attachAsset('dpadButtonUp', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: dpadBase.x,
		y: dpadBase.y - 300,
		width: dpadButtonSize,
		height: dpadButtonSize,
		alpha: 0,
		// Tint arrow yellow
		orientation: 0
	});
	dpadUp.on('down', function () {
		startMovingCharacter(0, -1);
	});
	var dpadRight = self.attachAsset('dpadButtonRight', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: dpadBase.x + 300,
		y: dpadBase.y,
		width: dpadButtonSize,
		height: dpadButtonSize,
		alpha: 0,
		// Tint arrow yellow
		orientation: 1
	});
	dpadRight.on('down', function () {
		startMovingCharacter(1, 0);
	});
	var dpadDown = self.attachAsset('dpadButtonDown', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: dpadBase.x,
		y: dpadBase.y + 300,
		width: dpadButtonSize,
		height: dpadButtonSize,
		alpha: 0,
		// Tint arrow yellow
		orientation: 2
	});
	dpadDown.on('down', function () {
		startMovingCharacter(0, 1);
	});
	// Consolidate dpad 'up' event handlers into a single function
	function stopMovingCharacter() {
		isCharacterMoving = false;
		LK.clearInterval(moveInterval);
	}
	dpadLeft.on('up', stopMovingCharacter);
	dpadUp.on('up', stopMovingCharacter);
	dpadRight.on('up', stopMovingCharacter);
	dpadDown.on('up', stopMovingCharacter);
});
var Robot = Container.expand(function () {
	var self = Container.call(this);
	var robotGraphics = self.attachAsset('robot', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 0.9,
		scaleY: 0.9
	});
	// Patrol logic variables
	// Enhanced patrol logic to include vertical movement
	self.patrolDirectionX = 1; // 1 for right, -1 for left
	self.patrolDirectionY = 0; // 1 for down, -1 for up
	self.patrolSpeed = 3;
	self.patrolBounds = {
		left: gridOffsetX + tileWidth * 2,
		right: gridOffsetX + tileWidth * (gridSize - 3),
		top: gridOffsetY + tileHeight * 2,
		bottom: gridOffsetY + tileHeight * (gridSize - 3)
	};
	self.update = function () {
		var margin = self.patrolSpeed;
		var futureX = self.x + (self.patrolSpeed + margin) * self.patrolDirectionX;
		var futureY = self.y + (self.patrolSpeed + margin) * self.patrolDirectionY;
		// Change direction before hitting the bounds
		if (futureX > self.patrolBounds.right || futureX < self.patrolBounds.left) {
			self.patrolDirectionX *= -1;
			self.patrolDirectionY = 0;
		} else if (futureY > self.patrolBounds.bottom || futureY < self.patrolBounds.top) {
			self.patrolDirectionY *= -1;
			self.patrolDirectionX = 0;
		}
		// Randomly decide to change patrol direction to vertical or horizontal
		if (Math.random() < 0.05) {
			// 5% chance to change direction
			if (self.patrolDirectionX !== 0) {
				self.patrolDirectionX = 0;
				self.patrolDirectionY = Math.random() < 0.5 ? 1 : -1; // Randomly choose up or down
			} else {
				self.patrolDirectionY = 0;
				self.patrolDirectionX = Math.random() < 0.5 ? 1 : -1; // Randomly choose left or right
			}
		}
		self.x += self.patrolSpeed * self.patrolDirectionX;
		self.y += self.patrolSpeed * self.patrolDirectionY;
	};
});

/**** 
* Initialize Game
****/ 
var game = new LK.Game({
	backgroundColor: 0xf9e076 // Fun yellow background
});

/**** 
* Game Code
****/ 
var isCharacterMoving = false;
// Function to move character based on direction
var dpadButtonSize = {
	width: 450,
	height: 450
};
function moveCharacter(xDir, yDir) {
	var nextX = character.x + xDir * tileWidth;
	var nextY = character.y + yDir * tileHeight;
	// Check if the next position is within the grid boundaries
	if (nextX >= gridOffsetX && nextX <= gridOffsetX + gridSize * tileWidth && nextY >= gridOffsetY && nextY <= gridOffsetY + gridSize * tileHeight) {
		// Check if the next tile is not a wall
		var nextTileIndex = Math.floor((nextY - gridOffsetY) / tileHeight) * gridSize + Math.floor((nextX - gridOffsetX) / tileWidth);
		if (floorTiles.includes(grid[nextTileIndex]) || grid[nextTileIndex] === holeTile) {
			character.x = nextX;
			character.y = nextY;
			character.currentTile = grid[nextTileIndex];
		}
	}
}
LK.screen = {
	width: 2048,
	height: 2732
}; // Initialize screen dimensions
var gridSize = 10;
var character;
var wallTiles = [];
var floorTiles = [];
var grid = new Array(gridSize * gridSize);
var tileWidth = LK.screen.width * .6 / (gridSize - 1); // Adjust tile width to ensure tiles are touching
var tileHeight = tileWidth; // Ensure square tiles for a uniform grid
var gridOffsetX = (LK.screen.width - tileWidth * gridSize) / 2; // Corrected grid offset X calculation
var gridOffsetY = (LK.screen.height - tileHeight * gridSize) / 2 - LK.screen.height * 0.15; // Corrected grid offset Y calculation
var onScreenController = game.addChild(new OnScreenController());
function createTiles() {
	// Create a black square background for the grid
	var gridBackground = LK.getAsset('gridBackground', {
		anchorX: 0.5,
		anchorY: 0.8,
		x: LK.screen.width / 2,
		y: LK.screen.height / 2,
		width: LK.screen.width * .9,
		height: LK.screen.height * .6,
		color: 0x000000
	});
	game.addChild(gridBackground);
	for (var i = 0; i < gridSize * gridSize; i++) {
		var x = i % gridSize;
		var y = Math.floor(i / gridSize);
		var tile;
		var tileWidth = LK.screen.width * .6 / (gridSize - 1); // Adjust tile width to ensure tiles are touching
		var tileHeight = tileWidth; // Ensure square tiles for a uniform grid
		var gridOffsetX = (LK.screen.width - tileWidth * (gridSize - 1)) / 2; // Adjust grid offset to account for new tile width
		var gridOffsetY = (LK.screen.height - tileHeight * (gridSize - 1)) / 2 - LK.screen.height * 0.15; // Adjust grid offset to account for new tile height
		if (!(x === 0 || y === 0 || x === gridSize - 1 || y === gridSize - 1)) {
			tile = LK.getAsset('floorTile', {
				anchorX: 0.5,
				anchorY: 0.5,
				x: x * tileWidth + gridOffsetX,
				y: y * tileHeight + gridOffsetY
			});
			floorTiles.push(tile);
			game.addChild(tile);
			grid[i] = tile;
		}
	}
	// Add walls after floor tiles to ensure they render on top
	for (var i = 0; i < gridSize * gridSize; i++) {
		var x = i % gridSize;
		var y = Math.floor(i / gridSize);
		if (x === 0 || y === 0 || x === gridSize - 1 || y === gridSize - 1) {
			var tile = LK.getAsset('wallTile', {
				anchorX: 0.5,
				anchorY: 0.5,
				x: x * tileWidth + gridOffsetX,
				y: y * tileHeight + gridOffsetY
			});
			wallTiles.push(tile);
			game.addChild(tile);
			grid[i] = tile;
		}
	}
}
createTiles();
// Function to check if a tile is in a corner
function isTileInCorner(tile) {
	var corners = [{
		x: gridOffsetX,
		y: gridOffsetY
	}, {
		x: gridOffsetX,
		y: gridOffsetY + tileHeight * (gridSize - 1)
	}, {
		x: gridOffsetX + tileWidth * (gridSize - 1),
		y: gridOffsetY
	}, {
		x: gridOffsetX + tileWidth * (gridSize - 1),
		y: gridOffsetY + tileHeight * (gridSize - 1)
	}];
	return corners.some(function (corner) {
		return Math.abs(tile.x - corner.x) < tileWidth / 2 && Math.abs(tile.y - corner.y) < tileHeight / 2;
	});
}
// Select a random wall tile and replace it with a hole tile, ensuring it's not in a corner
do {
	randomWallTileIndex = Math.floor(Math.random() * wallTiles.length);
	randomWallTile = wallTiles[randomWallTileIndex];
} while (isTileInCorner(randomWallTile));
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;
var isGameStarted = false;
LK.on('tick', function () {
	if (!isGameStarted) {
		isGameStarted = true; // Ensure game start logic is only triggered once
		character = LK.getAsset('character', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: holeTile.x,
			y: holeTile.y - 50,
			scaleX: 1.5,
			scaleY: 1.5
		});
		var characterShadow = LK.getAsset('characterShadow', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: -15,
			y: 50,
			scaleX: 0.6,
			scaleY: 0.6,
			alpha: 0.5
		});
		character.addChild(characterShadow);
		character.currentTile = getTileAtPosition(holeTile.x, holeTile.y); // Correctly initialize character's current tile
		game.addChild(character);
		// Add a robot to a random floor tile and start its patrol
		var randomFloorTileIndex = Math.floor(Math.random() * floorTiles.length);
		var randomFloorTile = floorTiles[randomFloorTileIndex];
		var robot = game.addChild(new Robot());
		robot.x = randomFloorTile.x;
		robot.y = randomFloorTile.y;
		// Start robot patrol immediately
		LK.on('tick', robot.update);
	}
});
// Define a function to get the tile at a given position
function getTileAtPosition(x, y) {
	var index = Math.floor(y / 100) * gridSize + Math.floor(x / 100);
	return grid[index];
}

===================================================================
--- original.js
+++ change.js
@@ -127,21 +127,43 @@
 		scaleX: 0.9,
 		scaleY: 0.9
 	});
 	// Patrol logic variables
-	self.patrolDirection = 1; // 1 for right, -1 for left
+	// Enhanced patrol logic to include vertical movement
+	self.patrolDirectionX = 1; // 1 for right, -1 for left
+	self.patrolDirectionY = 0; // 1 for down, -1 for up
 	self.patrolSpeed = 3;
 	self.patrolBounds = {
 		left: gridOffsetX + tileWidth * 2,
-		right: gridOffsetX + tileWidth * (gridSize - 3)
+		right: gridOffsetX + tileWidth * (gridSize - 3),
+		top: gridOffsetY + tileHeight * 2,
+		bottom: gridOffsetY + tileHeight * (gridSize - 3)
 	};
 	self.update = function () {
 		var margin = self.patrolSpeed;
-		var futureX = self.x + (self.patrolSpeed + margin) * self.patrolDirection;
+		var futureX = self.x + (self.patrolSpeed + margin) * self.patrolDirectionX;
+		var futureY = self.y + (self.patrolSpeed + margin) * self.patrolDirectionY;
+		// Change direction before hitting the bounds
 		if (futureX > self.patrolBounds.right || futureX < self.patrolBounds.left) {
-			self.patrolDirection *= -1; // Change direction before hitting the bounds
+			self.patrolDirectionX *= -1;
+			self.patrolDirectionY = 0;
+		} else if (futureY > self.patrolBounds.bottom || futureY < self.patrolBounds.top) {
+			self.patrolDirectionY *= -1;
+			self.patrolDirectionX = 0;
 		}
-		self.x += self.patrolSpeed * self.patrolDirection;
+		// Randomly decide to change patrol direction to vertical or horizontal
+		if (Math.random() < 0.05) {
+			// 5% chance to change direction
+			if (self.patrolDirectionX !== 0) {
+				self.patrolDirectionX = 0;
+				self.patrolDirectionY = Math.random() < 0.5 ? 1 : -1; // Randomly choose up or down
+			} else {
+				self.patrolDirectionY = 0;
+				self.patrolDirectionX = Math.random() < 0.5 ? 1 : -1; // Randomly choose left or right
+			}
+		}
+		self.x += self.patrolSpeed * self.patrolDirectionX;
+		self.y += self.patrolSpeed * self.patrolDirectionY;
 	};
 });
 
 /****