/**** 
* Classes
****/ 
// Move method inside Character class for better encapsulation
var Character = Container.expand(function () {
	var self = Container.call(this);
	// Other Character methods and properties...
	self.move = function (xDir, yDir) {
		var nextX = this.x + xDir * tileWidth;
		var nextY = this.y + yDir * tileHeight;
		if (isValidMove(nextX, nextY)) {
			this.x = nextX;
			this.y = nextY;
			this.currentTile = getTileAtPosition(nextX, nextY);
		}
	};
});
// Check if the next position is valid for movement
var Cheese = Container.expand(function () {
	var self = Container.call(this);
	var cheeseShadow = self.attachAsset('CircularShadow', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 1.5,
		scaleY: 1.5,
		alpha: 0.5,
		y: 20
	});
	var cheeseGraphics = self.attachAsset('cheese', {
		anchorX: 0.5,
		anchorY: 0.5
	});
});
// EnemyFactory function to create enemy instances with type-specific configurations
// OnScreenController class encapsulating A button and D-pad
var OnScreenController = Container.expand(function () {
	var self = Container.call(this);
	var yPosAdjustment = -180;
	var buttonYPosAdjustment = -273.2;
	var dpadButtonSize = 290;
	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: 400
	};
	var dPadSize = {
		width: 750,
		height: 750
	};
	this.aButton = self.attachAsset('aButton', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: aButtonPosition.x,
		y: aButtonPosition.y,
		width: buttonSize.width,
		height: buttonSize.height
	});
	// 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,
		width: dPadSize.width,
		height: dPadSize.height
	});
	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
	});
	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,
		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,
		orientation: 2
	});
	dpadDown.on('down', function () {
		startMovingCharacter(0, 1);
	});
	function stopMovingCharacter() {
		isCharacterMoving = false;
		LK.clearInterval(moveInterval);
	}
	dpadLeft.on('up', stopMovingCharacter);
	dpadUp.on('up', stopMovingCharacter);
	dpadRight.on('up', stopMovingCharacter);
	dpadDown.on('up', stopMovingCharacter);
});

/**** 
* Initialize Game
****/ 
// Integrate EventManager directly into the Game class for centralized event management
var game = new LK.Game({
	backgroundColor: 0xf9e076,
	// Fun yellow background
	eventManager: EventManager
});

/**** 
* Game Code
****/ 
// Function to place the hole tile on the game board
function placeHoleTile() {
	// Logic to place the hole tile
}
// Function to place the hole tile on the game board
// EventManager class for centralized event handling
// EnemyFactory function to create enemy instances with type-specific configurations
// Subscribe to 'gameStart' event to initialize character and game state
function EnemyFactory(type) {
	var EnemyTypes = {
		Roomba: {
			shadowAssetId: 'CircularShadow',
			enemyAssetId: 'Roomba',
			shadowScale: 3.2,
			enemySpeed: 2
		}
	};
	return Container.expand(function () {
		var self = Container.call(this);
		var enemyStats = EnemyTypes[type];
		if (!enemyStats) {
			console.error('Unknown enemy type:', type);
			return;
		}
		var shadowGraphics = self.attachAsset(enemyStats.shadowAssetId, {
			anchorX: 0.5,
			anchorY: 0.5,
			alpha: 0.5,
			scaleX: enemyStats.shadowScale,
			scaleY: enemyStats.shadowScale
		});
		var enemyGraphics = self.attachAsset(enemyStats.enemyAssetId, {
			anchorX: 0.5,
			anchorY: 0.5
		});
		shadowGraphics.x = enemyGraphics.x;
		shadowGraphics.y = enemyGraphics.y + 40;
		self.speed = enemyStats.enemySpeed;
		self.move = function () {
			// Movement logic here
		};
	});
}
var EventManager = {
	events: {},
	subscribe: function subscribe(eventType, listener) {
		if (!this.events[eventType]) {
			this.events[eventType] = [];
		}
		this.events[eventType].push(listener);
	},
	unsubscribe: function unsubscribe(eventType, listener) {
		if (this.events[eventType]) {
			var index = this.events[eventType].indexOf(listener);
			if (index > -1) {
				this.events[eventType].splice(index, 1);
			}
		}
	},
	publish: function publish(eventType, data) {
		if (this.events[eventType]) {
			this.events[eventType].forEach(function (listener) {
				listener(data);
			});
		}
	}
};
var EventManager = {
	events: {},
	subscribe: function subscribe(eventType, listener) {
		if (!this.events[eventType]) {
			this.events[eventType] = [];
		}
		this.events[eventType].push(listener);
	},
	unsubscribe: function unsubscribe(eventType, listener) {
		if (this.events[eventType]) {
			var index = this.events[eventType].indexOf(listener);
			if (index > -1) {
				this.events[eventType].splice(index, 1);
			}
		}
	},
	publish: function publish(eventType, data) {
		if (this.events[eventType]) {
			this.events[eventType].forEach(function (listener) {
				listener(data);
			});
		}
	}
};
game.eventManager = EventManager;
game.eventManager.subscribe('gameStart', function () {
	isGameStarted = true;
	character = LK.getAsset('character', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: holeTile.x,
		y: holeTile.y - 50,
		scaleX: 1.5,
		scaleY: 1.5
	});
});
// Initialize scoreboard container and elements once and update score dynamically
if (!window.scoreBoardInitialized) {
	window.scoreBoardContainer = new Container();
	var scoreBoardX = 200,
		scoreBoardY = 125;
	var cheeseIconForScore = window.scoreBoardContainer.attachAsset('cheese', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 0.5,
		scaleY: 0.5,
		x: -50,
		y: 0
	});
	// Ensure only one instance of the score text asset exists
	if (!window.cheeseScoreIcon) {
		window.cheeseScoreIcon = new Text2('0', {
			size: 50,
			fill: "#E0E0E0",
			font: "Arial Black, bold",
			x: 20,
			y: -25
		});
		window.scoreBoardContainer.addChild(window.cheeseScoreIcon);
	}
	window.scoreBoardContainer.x = scoreBoardX;
	window.scoreBoardContainer.y = scoreBoardY;
	LK.gui.addChild(window.scoreBoardContainer);
	window.scoreBoardInitialized = true;
}
// Update score dynamically without recreating the scoreboard elements
window.cheeseScoreIcon.setText(LK.getScore().toString());
// Move the onScreenController initialization to the top of Game Code section to ensure it's available before adding event listeners
var onScreenController = game.addChild(new OnScreenController());
// Event listener for A button press to pick up the cheese using a refined proximity check and method encapsulation
onScreenController.aButton.on('down', function () {
	// Check if cheese is picked up and character is on the hole tile
	if (cheesePlaced && cheeseIcon && cheeseIcon.visible && isWithinProximity(character, holeTile, 75)) {
		console.log('Cheese placed on hole tile!');
		// Update to handle multiple cheeses
		cheeses.forEach(function (cheese) {
			if (isWithinProximity(cheese, character, 75)) {
				cheese.x = holeTile.x; // Place cheese on hole tile
				cheese.y = holeTile.y;
				cheese.visible = true; // Make cheese visible on the hole tile
			}
		});
		// Disable cheese icon on character head
		if (cheeseIcon) {
			cheeseIcon.visible = false;
		}
		// Correct lerp logic for moving placed cheese to scoreboard
		cheeses.forEach(function (cheese) {
			if (isWithinProximity(cheese, holeTile, 75)) {
				var lerpDuration = 1000; // 1 second in milliseconds
				var startTime = Date.now();
				var startPos = {
					x: cheese.x,
					y: cheese.y
				};
				var endPos = {
					x: window.scoreBoardContainer.x + cheeseIconForScore.x,
					y: window.scoreBoardContainer.y + cheeseIconForScore.y
				};
				var lerp = function lerp() {
					var currentTime = Date.now();
					var timeElapsed = currentTime - startTime;
					var t = Math.min(1, timeElapsed / lerpDuration);
					cheese.x = startPos.x + (endPos.x - startPos.x) * t;
					cheese.y = startPos.y + (endPos.y - startPos.y) * t;
					if (t < 1) {
						requestAnimationFrame(lerp);
					} else {
						// Make cheese invisible after reaching scoreboard
						cheese.visible = false;
					}
				};
				requestAnimationFrame(lerp);
			}
		});
	} else if (cheeses.some(function (cheese) {
		return isWithinProximity(character, cheese, 75);
	})) {
		var pickedCheese = cheeses.find(function (cheese) {
			return isWithinProximity(character, cheese, 75);
		});
		pickedCheese.visible = false; // Hide the picked cheese from the game
		// Check if cheese is initialized and within a refined proximity to the character for pickup
		console.log('Cheese picked up!');
		pickedCheese.visible = false; // Hide the picked cheese from the game
		// Show UI icon indicating cheese has been picked up only if not already visible
		if (!cheeseIcon || !cheeseIcon.visible) {
			cheeseIcon = character.attachAsset('cheese', {
				anchorX: 0.5,
				anchorY: 0.5,
				x: 0,
				// Centered on character's head
				y: -character.height * 0.75,
				// Positioned above the character's head
				scaleX: 0.5,
				scaleY: 0.5
			});
		}
		cheesePlaced = true; // Set cheese placement flag to true
	}
});
// Helper function to check if two objects are within a certain distance
function isWithinProximity(obj1, obj2, threshold) {
	return Math.abs(obj1.x - obj2.x) < threshold && Math.abs(obj1.y - obj2.y) < threshold;
}
// Simplified and optimized game code initialization and logic
var isCharacterMoving = false;
var character;
var cheeses = []; // Global cheeses array
var cheeseIcon; // Global cheese icon variable
var wallTiles = [];
var floorTiles = [];
var grid = [];
var gridSize = 10;
var tileWidth, tileHeight, gridOffsetX, gridOffsetY;
var enemies = [];
// Function to initialize enemies for the game
function initializeEnemies() {
	// Logic to initialize enemies goes here
}
// Function to initialize screen dimensions for better reusability and maintainability
function initializeScreenDimensions() {
	LK.screen = {
		width: 2048,
		height: 2732
	};
}
initializeScreenDimensions();
// Check if the next position is valid for movement
function isValidMove(nextX, nextY) {
	return nextX >= gridOffsetX && nextX <= gridOffsetX + gridSize * tileWidth && nextY >= gridOffsetY && nextY <= gridOffsetY + gridSize * tileHeight && !isWallTile(nextX, nextY);
}
// Check if the specified position is a wall tile
function isWallTile(x, y) {
	var tile = getTileAtPosition(x, y);
	return wallTiles.includes(tile);
}
// Define a function to get the tile at a given position
function getTileAtPosition(x, y) {
	var index = Math.floor((y - gridOffsetY) / tileHeight) * gridSize + Math.floor((x - gridOffsetX) / tileWidth);
	return grid[index];
}
// Initialize game elements and logic
function initializeGame() {
	calculateTileDimensions();
	createTiles();
	placeHoleTile();
	initializeEnemies();
	game.eventManager.subscribe('gameStart', initializeCharacterAndCheeses);
}
// Calculate tile dimensions and grid offsets
function calculateTileDimensions() {
	tileWidth = LK.screen.width * .6 / gridSize;
	tileHeight = tileWidth;
	gridOffsetX = (LK.screen.width - tileWidth * gridSize) / 2;
	gridOffsetY = (LK.screen.height - tileHeight * gridSize) / 2 - LK.screen.height * 0.15;
}
// Initialize character and cheeses at game start
function initializeCharacterAndCheeses() {
	if (!isGameStarted) {
		character = game.addChild(new Character());
		character.currentTile = getTileAtPosition(holeTile.x, holeTile.y);
		placeCheeses();
		isGameStarted = true;
	}
}
// Place cheeses on the game board
function placeCheeses() {
	cheeses = [new Cheese(), new Cheese(), new Cheese()];
	cheeses.forEach(function (cheese) {
		game.addChild(cheese);
	});
	distributeCheeses();
}
// Distribute cheeses on valid floor tiles
function distributeCheeses() {
	var validTiles = floorTiles.filter(function (tile) {
		return !isTileInCorner(tile);
	});
	shuffleArray(validTiles);
	cheeses.forEach(function (cheese, index) {
		if (validTiles[index]) {
			cheese.x = validTiles[index].x;
			cheese.y = validTiles[index].y;
		}
	});
	cheesePlaced = true;
}
// Shuffle an array in place
function shuffleArray(array) {
	for (var i = array.length - 1; i > 0; i--) {
		var j = Math.floor(Math.random() * (i + 1));
		var _ref = [array[j], array[i]];
		array[i] = _ref[0];
		array[j] = _ref[1];
	}
}
// Function to create and place tiles on the game board
function createTiles() {
	// Logic to create and place tiles
}
// Dedicated method for game initialization to improve code organization
function initializeGameElements() {
	calculateTileDimensions();
	createTiles();
	placeHoleTile();
	initializeEnemies();
	game.eventManager.subscribe('gameStart', initializeCharacterAndCheeses);
	// Initialize on-screen controller
	var onScreenController = game.addChild(new OnScreenController());
}
initializeGameElements();

===================================================================
--- original.js
+++ change.js
@@ -382,8 +382,12 @@
 var grid = [];
 var gridSize = 10;
 var tileWidth, tileHeight, gridOffsetX, gridOffsetY;
 var enemies = [];
+// Function to initialize enemies for the game
+function initializeEnemies() {
+	// Logic to initialize enemies goes here
+}
 // Function to initialize screen dimensions for better reusability and maintainability
 function initializeScreenDimensions() {
 	LK.screen = {
 		width: 2048,