===================================================================
--- original.js
+++ change.js
@@ -3,13 +3,17 @@
 ****/ 
 // 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;
-	if (!LK.screen) {
-		return;
-	}
+	var dpadButtonSize = 265;
+	// 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.68,
 		y: LK.screen.height * 0.89 + buttonYPosAdjustment + LK.screen.height * 0.055
 	};
@@ -53,18 +57,33 @@
 		x: bButtonPosition.x,
 		y: bButtonPosition.y,
 		width: buttonSize.width * .7,
 		height: buttonSize.height * .7
+		// 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('dpadButton', {
+		anchorX: 0.5,
+		anchorY: 0.5,
+		x: dpadBase.x - 250,
+		y: dpadBase.y,
+		width: dpadButtonSize,
+		height: dpadButtonSize,
+		// Removed tint application
+		//{r} Change dpad buttons to black
+		orientation: 3
+	});
+	// Refactored D-pad control to use moveCharacter function for cleaner code
 	var moveInterval;
 	function startMovingCharacter(xDir, yDir) {
 		if (moveInterval) {
 			LK.clearInterval(moveInterval);
@@ -73,30 +92,53 @@
 		moveInterval = LK.setInterval(function () {
 			moveCharacter(xDir, yDir);
 		}, 150);
 	}
-	var dpadDirections = [{
-		button: dpadLeft,
-		xDir: -1,
-		yDir: 0
-	}, {
-		button: dpadUp,
-		xDir: 0,
-		yDir: -1
-	}, {
-		button: dpadRight,
-		xDir: 1,
-		yDir: 0
-	}, {
-		button: dpadDown,
-		xDir: 0,
-		yDir: 1
-	}];
-	dpadDirections.forEach(function (direction) {
-		direction.button.on('down', function () {
-			startMovingCharacter(direction.xDir, direction.yDir);
-		});
-		direction.button.on('up', function () {
+	dpadLeft.on('down', function () {
+		startMovingCharacter(-1, 0);
+	});
+	var dpadUp = self.attachAsset('dpadButton', {
+		anchorX: 0.5,
+		anchorY: 0.5,
+		x: dpadBase.x,
+		y: dpadBase.y - 250,
+		width: dpadButtonSize,
+		height: dpadButtonSize,
+		// Removed tint application
+		orientation: 0
+	});
+	dpadUp.on('down', function () {
+		startMovingCharacter(0, -1);
+	});
+	var dpadRight = self.attachAsset('dpadButton', {
+		anchorX: 0.5,
+		anchorY: 0.5,
+		x: dpadBase.x + 250,
+		y: dpadBase.y,
+		width: dpadButtonSize,
+		height: dpadButtonSize,
+		// Removed tint application
+		orientation: 1
+	});
+	dpadRight.on('down', function () {
+		startMovingCharacter(1, 0);
+	});
+	var dpadDown = self.attachAsset('dpadButton', {
+		anchorX: 0.5,
+		anchorY: 0.5,
+		x: dpadBase.x,
+		y: dpadBase.y + 250,
+		width: dpadButtonSize,
+		height: dpadButtonSize,
+		// Removed tint application
+		orientation: 2
+	});
+	dpadDown.on('down', function () {
+		startMovingCharacter(0, 1);
+	});
+	// Consolidated dpad 'up' event listener
+	['dpadLeft', 'dpadUp', 'dpadRight', 'dpadDown'].forEach(function (dpadDirection) {
+		this[dpadDirection].on('up', function () {
 			LK.clearInterval(moveInterval);
 		});
 	});
 });
@@ -111,71 +153,41 @@
 
 /**** 
 * Game Code
 ****/ 
+// Function to move character based on direction
+var dpadButtonSize = {
+	width: 450,
+	height: 450
+};
 function moveCharacter(xDir, yDir) {
-	// Extracted character movement logic to a separate function for clarity and reuse
-	function attemptCharacterMove(xDir, yDir) {
-		var nextX = character.x + xDir * tileWidth;
-		var nextY = character.y + yDir * tileHeight;
-		if (nextX >= gridOffsetX && nextX <= gridOffsetX + gridSize * tileWidth && nextY >= gridOffsetY && nextY <= gridOffsetY + gridSize * tileHeight) {
-			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];
-			}
+	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];
 		}
 	}
-	moveCharacter = attemptCharacterMove;
 }
+// Screen dimensions initialization removed to avoid duplication
 var gridSize = 10;
-// Initialize character variable globally to ensure it's defined before use
-// Initialize character and holeTile variables globally to ensure they're defined before use
-var holeTile;
-var holeTile;
-var holeTile;
-// Initialize character after holeTile
-// Initialize character after holeTile
-var character = LK.getAsset('character', {
-	anchorX: 0.5,
-	anchorY: 0.5,
-	x: holeTile.x,
-	y: holeTile.y - 50,
-	scaleX: 1.5,
-	scaleY: 1.5
-});
-// Ensure character is defined before this point in the code
-// Moved character initialization to after holeTile definition to ensure it's defined
+var character;
 var wallTiles = [];
 var floorTiles = [];
 var grid = new Array(gridSize * gridSize);
-// Consolidate tile dimension and offset calculations into a single function
-function calculateTileDimensionsAndOffsets(gridSize) {
-	var tileWidth = 2048 * .6 / (gridSize - 1);
-	var tileHeight = tileWidth;
-	var gridOffsetX = (2048 - tileWidth * (gridSize - 1)) / 2;
-	var gridOffsetY = (2732 - tileHeight * (gridSize - 1)) / 2 - 2732 * 0.15;
-	return {
-		tileWidth: tileWidth,
-		tileHeight: tileHeight,
-		gridOffsetX: gridOffsetX,
-		gridOffsetY: gridOffsetY
-	};
-}
-var _calculateTileDimensi = calculateTileDimensionsAndOffsets(gridSize),
-	tileWidth = _calculateTileDimensi.tileWidth,
-	tileHeight = _calculateTileDimensi.tileHeight,
-	gridOffsetX = _calculateTileDimensi.gridOffsetX,
-	gridOffsetY = _calculateTileDimensi.gridOffsetY;
+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());
 // Character movement function removed
 function createTiles() {
 	// Create a black square background for the grid
-	// Removed console.error log for uninitialized LK.screen
-	if (!LK.screen) {
-		return;
-	}
 	var gridBackground = LK.getAsset('gridBackground', {
 		anchorX: 0.5,
 		anchorY: 0.8,
 		x: LK.screen.width / 2,
@@ -188,8 +200,9 @@
 	for (var i = 0; i < gridSize * gridSize; i++) {
 		var x = i % gridSize;
 		var y = Math.floor(i / gridSize);
 		var tile;
+		// Removed redundant tile size and offset calculations within createTiles function
 		if (!(x === 0 || y === 0 || x === gridSize - 1 || y === gridSize - 1)) {
 			tile = LK.getAsset('floorTile', {
 				anchorX: 0.5,
 				anchorY: 0.5,
@@ -218,8 +231,9 @@
 		}
 	}
 }
 createTiles();
+// Function to check if a tile is in a corner
 function isTileInCorner(tile) {
 	var corners = [{
 		x: gridOffsetX,
 		y: gridOffsetY
@@ -233,57 +247,49 @@
 		x: (gridSize - 1) * tileWidth + gridOffsetX,
 		y: (gridSize - 1) * tileHeight + gridOffsetY
 	}];
 	return corners.some(function (corner) {
-		return tile && Math.abs(tile.x - corner.x) < tileWidth / 2 && Math.abs(tile.y - corner.y) < tileHeight / 2;
+		return Math.abs(tile.x - corner.x) < 1 && Math.abs(tile.y - corner.y) < 1;
 	});
 }
-function placeHoleTile() {
-	do {
-		randomWallTileIndex = Math.floor(Math.random() * wallTiles.length);
-		randomWallTile = wallTiles[randomWallTileIndex];
-	} while (isTileInCorner(randomWallTile));
-	if (!LK.screen) {
-		return;
-	}
-	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;
-}
-placeHoleTile();
+// 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) || randomWallTileIndex % gridSize == 0 || randomWallTileIndex % gridSize == gridSize - 1 || randomWallTileIndex < gridSize || randomWallTileIndex >= gridSize * (gridSize - 1));
+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) {
-		var createCharacterAndShadow = function createCharacterAndShadow() {
-			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);
-		};
 		isGameStarted = true; // Ensure game start logic is only triggered once
-		createCharacterAndShadow();
+		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);
 	}
 });
 // Define a function to get the tile at a given position
 function getTileAtPosition(x, y) {
@@ -291,11 +297,8 @@
 	return grid[index];
 }
 // Optimized speaker hole creation with a function to reduce redundancy
 function createSpeakerHoles() {
-	if (!LK.screen) {
-		return;
-	}
 	var baseX = LK.screen.width / 2;
 	var baseY = LK.screen.height / 2;
 	var offsets = [880, -880];
 	var yPositions = [-500, -200];