/**** 
* 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 = 265;
	// Removed redundant tint application on A and B buttons
	// Initialize screen dimensions in a single, reusable method
	function initializeScreenDimensions() {
		LK.screen = {
			width: 2048,
			height: 2732
		};
	}
	initializeScreenDimensions();
	var aButtonPosition = {
		x: LK.screen.width * 0.68,
		y: LK.screen.height * 0.89 + buttonYPosAdjustment + LK.screen.height * 0.055
	};
	var bButtonPosition = {
		x: LK.screen.width * 0.88,
		y: LK.screen.height * 0.89 + buttonYPosAdjustment - LK.screen.height * 0.018
	};
	var buttonSize = {
		width: LK.screen.width * 0.2,
		height: LK.screen.width * 0.2
	};
	var buttonFrameA = self.attachAsset('buttonFrame', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: aButtonPosition.x,
		y: aButtonPosition.y,
		width: buttonSize.width * 1.2,
		height: buttonSize.height * 1.2
	});
	var buttonFrameB = self.attachAsset('buttonFrame', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: bButtonPosition.x,
		y: bButtonPosition.y,
		width: buttonSize.width * 1.2 * .7,
		// Match B button's scaled size
		height: buttonSize.height * 1.2 * .7
	});
	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
	});
	var bButton = self.attachAsset('bButton', {
		anchorX: 0.5,
		anchorY: 0.5,
		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);
		}
		moveCharacter(xDir, yDir);
		moveInterval = LK.setInterval(function () {
			moveCharacter(xDir, yDir);
		}, 150);
	}
	// Optimize event listener setup for D-pad buttons using a loop
	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 () {
			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
			});
			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
			});
			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
			});
			LK.clearInterval(moveInterval);
		});
	});
});

/**** 
* Initialize Game
****/ 
// Instantiate and add OnScreenController to the game
var game = new LK.Game({
	backgroundColor: 0xb2beb5 // Light teal gray background
});

/**** 
* 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];
			}
		}
	}
	moveCharacter = attemptCharacterMove;
}
var gridSize = 10;
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 = LK.screen.width * .6 / (gridSize - 1);
	var tileHeight = tileWidth;
	var gridOffsetX = (LK.screen.width - tileWidth * (gridSize - 1)) / 2;
	var gridOffsetY = (LK.screen.height - tileHeight * (gridSize - 1)) / 2 - LK.screen.height * 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 onScreenController = game.addChild(new OnScreenController());
// Character movement function removed
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 * .7,
		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;
		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: (gridSize - 1) * tileHeight + gridOffsetY
	}, {
		x: (gridSize - 1) * tileWidth + gridOffsetX,
		y: gridOffsetY
	}, {
		x: (gridSize - 1) * tileWidth + gridOffsetX,
		y: (gridSize - 1) * tileHeight + gridOffsetY
	}];
	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);
	}
});
// 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];
}
// Optimized speaker hole creation with a function to reduce redundancy
function createSpeakerHoles() {
	var baseX = LK.screen.width / 2;
	var baseY = LK.screen.height / 2;
	var offsets = [880, -880];
	var yPositions = [-500, -200];
	offsets.forEach(function (offsetX) {
		yPositions.forEach(function (offsetY) {
			game.addChild(LK.getAsset('speakerHoles', {
				anchorX: 0.5,
				anchorY: 0.5,
				x: baseX + offsetX,
				y: baseY + offsetY,
				width: 250,
				height: 200
			}));
		});
	});
}
createSpeakerHoles();

===================================================================
--- original.js
+++ change.js
@@ -8,9 +8,16 @@
 	var yPosAdjustment = -180;
 	var buttonYPosAdjustment = -273.2;
 	var dpadButtonSize = 265;
 	// Removed redundant tint application on A and B buttons
-	// Removed redundant LK.screen initialization
+	// Initialize screen dimensions in a single, reusable method
+	function initializeScreenDimensions() {
+		LK.screen = {
+			width: 2048,
+			height: 2732
+		};
+	}
+	initializeScreenDimensions();
 	var aButtonPosition = {
 		x: LK.screen.width * 0.68,
 		y: LK.screen.height * 0.89 + buttonYPosAdjustment + LK.screen.height * 0.055
 	};
@@ -89,62 +96,64 @@
 		moveInterval = LK.setInterval(function () {
 			moveCharacter(xDir, yDir);
 		}, 150);
 	}
-	dpadLeft.on('down', function () {
-		startMovingCharacter(-1, 0);
+	// Optimize event listener setup for D-pad buttons using a loop
+	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 () {
+			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
+			});
+			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
+			});
+			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
+			});
+			LK.clearInterval(moveInterval);
+		});
 	});
-	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);
-	});
-	dpadLeft.on('up', function () {
-		LK.clearInterval(moveInterval);
-	});
-	dpadUp.on('up', function () {
-		LK.clearInterval(moveInterval);
-	});
-	dpadRight.on('up', function () {
-		LK.clearInterval(moveInterval);
-	});
-	dpadDown.on('up', function () {
-		LK.clearInterval(moveInterval);
-	});
 });
 
 /**** 
 * Initialize Game
@@ -156,53 +165,52 @@
 
 /**** 
 * Game Code
 ****/ 
-// Create a black overlay for the iris wipe effect
-// Ensure 'gridBackground' asset is correctly initialized before use
-var irisWipeOverlay = game.addChild(LK.getAsset('gridBackground', {
-	anchorX: 0.5,
-	anchorY: 0.5,
-	x: game.width / 2,
-	// Use game.width for correct reference
-	y: game.height / 2,
-	// Use game.height for correct reference
-	scaleX: game.width / 100,
-	// Use game.width for scaling
-	scaleY: game.height / 100,
-	// Use game.height for scaling
-	color: 0x000000
-}));
-game.addChild(irisWipeOverlay);
 // 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];
+	// 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];
+			}
 		}
 	}
+	moveCharacter = attemptCharacterMove;
 }
-// Removed duplicate LK.screen initialization
 var gridSize = 10;
 var character;
 var wallTiles = [];
 var floorTiles = [];
 var grid = new Array(gridSize * gridSize);
-var tileWidth = game.width * .6 / (gridSize - 1); // Adjust tile width to ensure tiles are touching using game.width
-var tileHeight = tileWidth; // Ensure square tiles for a uniform grid
-var gridOffsetX = (game.width - tileWidth * gridSize) / 2; // Corrected grid offset X calculation using game.width
-var gridOffsetY = (LK.screen.height - tileHeight * gridSize) / 2 - LK.screen.height * 0.15; // Corrected grid offset Y calculation
+// Consolidate tile dimension and offset calculations into a single function
+function calculateTileDimensionsAndOffsets(gridSize) {
+	var tileWidth = LK.screen.width * .6 / (gridSize - 1);
+	var tileHeight = tileWidth;
+	var gridOffsetX = (LK.screen.width - tileWidth * (gridSize - 1)) / 2;
+	var gridOffsetY = (LK.screen.height - tileHeight * (gridSize - 1)) / 2 - LK.screen.height * 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 onScreenController = game.addChild(new OnScreenController());
 // Character movement function removed
 function createTiles() {
 	// Create a black square background for the grid
@@ -219,12 +227,8 @@
 	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,
@@ -290,21 +294,8 @@
 var isGameStarted = false;
 LK.on('tick', function () {
 	if (!isGameStarted) {
 		isGameStarted = true; // Ensure game start logic is only triggered once
-		// Start iris wipe effect
-		var radius = 0;
-		var maxRadius = Math.sqrt(Math.pow(LK.screen.width, 2) + Math.pow(LK.screen.height, 2));
-		var irisWipeInterval = LK.setInterval(function () {
-			radius += maxRadius / 60; // Increase radius over time for smooth animation
-			irisWipeOverlay.shape = 'ellipse';
-			irisWipeOverlay.width = radius * 2;
-			irisWipeOverlay.height = radius * 2;
-			if (radius >= maxRadius) {
-				LK.clearInterval(irisWipeInterval);
-				game.removeChild(irisWipeOverlay); // Remove overlay after effect completion
-			}
-		}, 16.67); // Approximately 60FPS
 		character = LK.getAsset('character', {
 			anchorX: 0.5,
 			anchorY: 0.5,
 			x: holeTile.x,