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

/**** 
* Classes
****/ 
var Coin = Container.expand(function () {
	var self = Container.call(this);
	var coinGraphics = self.attachAsset('coin', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 3,
		scaleY: 3
	});
	self.touchCount = 0; // Add a counter to track the number of times the coin has been touched
	self.lastWasIntersecting = false; // Initialize lastWasIntersecting for tracking intersection state
	// Add rotation to the coin continuously when the game start
	self.update = function () {
		if (self.touchCount === 0) {
			self.rotation += 0.05;
		}
		// Check if the point reaches the coin
		if (!self.lastWasIntersecting && (point.intersects(self) || Math.abs(point.x - self.x) <= self.width / 2 && Math.abs(point.y - self.y) <= self.height / 2)) {
			// Increase the touch count
			self.touchCount++;
			// Play a sound effect
			LK.getSound('coin').play();
			// Add score (only adds 1 point)
			LK.setScore(LK.getScore() + 1);
			// Update the score display to show the number of coins after a slash
			scoreTxt.setText(LK.getScore() + '/7');
			// Remove the coin from the game after it's been touched
			self.destroy();
		}
		self.lastWasIntersecting = point.intersects(self) || Math.abs(point.x - self.x) <= self.width / 2 && Math.abs(point.y - self.y) <= self.height / 2;
	};
});

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

/**** 
* Game Code
****/ 
// Create and position the wall1 asset at the bottom of the screen
var wall1 = LK.getAsset('wall1', {
	anchorX: 0.5,
	anchorY: 0.5,
	scaleX: 2048 / 100,
	// Scale to fit the width of the screen
	scaleY: 1 // Keep the original height
});
wall1.x = 2048 / 2; // Center horizontally
wall1.y = 2732 - wall1.height / 2; // Position at the bottom
game.addChild(wall1);
// Create and position the wall1 asset at the top of the screen
var wallTop = LK.getAsset('wall1', {
	anchorX: 0.5,
	anchorY: 0.5,
	scaleX: 2048 / 100,
	// Scale to fit the width of the screen
	scaleY: 1 // Increase the vertical thickness
});
wallTop.x = 2048 / 2; // Center horizontally
wallTop.y = wallTop.height / 2; // Position at the top
game.addChild(wallTop);
// Create and position the wall1 asset at the left side of the screen
var wallLeft = LK.getAsset('wall1', {
	anchorX: 0.5,
	anchorY: 0.5,
	scaleX: 1,
	// Keep the original width
	scaleY: 2732 / 100 // Scale to fit the height of the screen
});
wallLeft.x = wallLeft.width / 2; // Position at the left
wallLeft.y = 2732 / 2; // Center vertically
game.addChild(wallLeft);
// Create right wall1 once
var wallRight = LK.getAsset('wall1', {
	anchorX: 0.5,
	anchorY: 0.5,
	scaleX: 1,
	// Keep the original width
	scaleY: 2732 / 100 // Scale to fit the height of the screen
});
wallRight.x = 2048 - wallRight.width / 2; // Position at the right
wallRight.y = 2732 / 2; // Center vertically
game.addChild(wallRight);
// Create and position wall2 assets to form a maze inside the 4 main walls
// Calculate playable area dimensions
var playableAreaLeft = wallLeft.width;
var playableAreaRight = 2048 - wallRight.width;
var playableAreaTop = wallTop.height;
var playableAreaBottom = 2732 - wall1.height;
var playableWidth = playableAreaRight - playableAreaLeft;
var playableHeight = playableAreaBottom - playableAreaTop;
// Create a grid-like maze with corridors sized for coins to pass through
var gridSizeX = 12; // Number of vertical sections
var gridSizeY = 15; // Number of horizontal sections
var cellWidth = playableWidth / gridSizeX;
var cellHeight = playableHeight / gridSizeY;
var wallThickness = 0.8; // Wall thickness factor
// Create horizontal walls with gaps for a proper maze
for (var y = 1; y < gridSizeY; y += 2) {
	for (var x = 0; x < gridSizeX - 1; x++) {
		// Skip some walls to create paths (40% chance)
		if (Math.random() > 0.6) {
			continue;
		}
		var horizontalWall = LK.getAsset('wall2', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: cellWidth / 100,
			scaleY: wallThickness
		});
		// Position the wall between cells, inside the main walls
		horizontalWall.x = playableAreaLeft + (x + 0.5) * cellWidth;
		horizontalWall.y = playableAreaTop + y * cellHeight;
		// Make sure the wall is inside the playable area
		if (horizontalWall.x > playableAreaLeft + horizontalWall.width / 2 && horizontalWall.x < playableAreaRight - horizontalWall.width / 2) {
			game.addChild(horizontalWall);
		}
	}
}
// Create vertical walls with gaps for a proper maze
for (var x = 1; x < gridSizeX; x += 2) {
	for (var y = 0; y < gridSizeY - 1; y++) {
		// Skip some walls to create paths (40% chance)
		if (Math.random() > 0.6) {
			continue;
		}
		var verticalWall = LK.getAsset('wall2', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: wallThickness,
			scaleY: cellHeight / 100
		});
		// Position the wall between cells, inside the main walls
		verticalWall.x = playableAreaLeft + x * cellWidth;
		verticalWall.y = playableAreaTop + (y + 0.5) * cellHeight;
		// Make sure the wall is inside the playable area
		if (verticalWall.y > playableAreaTop + verticalWall.height / 2 && verticalWall.y < playableAreaBottom - verticalWall.height / 2) {
			game.addChild(verticalWall);
		}
	}
}
// We won't add diagonal walls as we need only horizontal and vertical walls between the main walls
// We won't add circular/square patterns as we need only horizontal and vertical walls between the main walls
// We won't add zigzag walls as we need only horizontal and vertical walls between the main walls
// Add some additional wall2 sections to make the maze harder
for (var i = 0; i < 15; i++) {
	// Random position within the playable area
	var posX = playableAreaLeft + Math.random() * (playableWidth - 200) + 100;
	var posY = playableAreaTop + Math.random() * (playableHeight - 200) + 100;
	// 50% chance for horizontal or vertical wall
	if (Math.random() > 0.5) {
		// Horizontal wall
		var extraWall = LK.getAsset('wall2', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: cellWidth * (1 + Math.random()) / 100,
			scaleY: wallThickness
		});
		extraWall.x = posX;
		extraWall.y = posY;
	} else {
		// Vertical wall
		var extraWall = LK.getAsset('wall2', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: wallThickness,
			scaleY: cellHeight * (1 + Math.random()) / 100
		});
		extraWall.x = posX;
		extraWall.y = posY;
	}
	// Make sure we're not adding walls too close to the coins
	var tooClose = false;
	game.children.forEach(function (child) {
		if (child instanceof Coin && Math.abs(child.x - extraWall.x) < cellWidth * 1.5 && Math.abs(child.y - extraWall.y) < cellHeight * 1.5) {
			tooClose = true;
		}
	});
	if (!tooClose) {
		game.addChild(extraWall);
	}
}
var point = LK.getAsset('point', {
	anchorX: 0.5,
	anchorY: 0.5
});
game.addChild(point);
// Handle mouse movement
// Add background to the game
var background = LK.getAsset('Background1', {
	anchorX: 0.5,
	anchorY: 0.5,
	scaleX: 2048 / 1000,
	scaleY: 2732 / 1075
});
game.addChildAt(background, 0);
background.x = 2048 / 2;
background.y = 2732 / 2 + 115; // Lower the background a bit from the top
game.down = function (x, y, obj) {
	// Check if a wall2 asset is being clicked
	game.children.forEach(function (child) {
		if (child.assetId === 'wall2' && child.intersects(point)) {
			game.draggedWall = child;
		}
	});
	// Set a flag to track if the mouse is down
	game.isMouseDown = true;
	// Coin handling is now done exclusively in the Coin class update method
};
// Create a function to check if a position is clear of walls
function isPositionClear(x, y, minDistance) {
	var isClear = true;
	game.children.forEach(function (child) {
		if (child.assetId === 'wall1' || child.assetId === 'wall2') {
			if (Math.abs(child.x - x) < minDistance && Math.abs(child.y - y) < minDistance) {
				isClear = false;
			}
		}
	});
	return isClear;
}
// Create a function to find valid coin positions
function findValidCoinPositions(count) {
	var positions = [];
	var minDistanceFromWall = 50; // Minimum distance from any wall
	var minDistanceBetweenCoins = 100; // Minimum distance between coins
	var maxAttempts = 200; // Maximum attempts to find a valid position
	// Try to find valid positions for all coins
	for (var i = 0; i < count; i++) {
		var validPosition = false;
		var attempts = 0;
		var x, y;
		while (!validPosition && attempts < maxAttempts) {
			// Generate a random position within the playable area
			x = playableAreaLeft + cellWidth * (1 + Math.random() * (gridSizeX - 2));
			y = playableAreaTop + cellHeight * (1 + Math.random() * (gridSizeY - 2));
			// Check if position is clear of walls
			validPosition = isPositionClear(x, y, minDistanceFromWall);
			// Check if position is far enough from other coins
			if (validPosition) {
				for (var j = 0; j < positions.length; j++) {
					if (Math.abs(positions[j].x - x) < minDistanceBetweenCoins && Math.abs(positions[j].y - y) < minDistanceBetweenCoins) {
						validPosition = false;
						break;
					}
				}
			}
			attempts++;
		}
		if (validPosition) {
			positions.push({
				x: x,
				y: y
			});
		} else {
			// Fallback position if we couldn't find a valid one
			positions.push({
				x: playableAreaLeft + (i + 1) * (playableWidth / (count + 1)),
				y: playableAreaTop + (i % 2 === 0 ? playableHeight / 3 : playableHeight * 2 / 3)
			});
		}
	}
	return positions;
}
// Generate valid positions for 7 coins based on the current maze layout
var coinPositions = findValidCoinPositions(7);
// Create 7 new coin assets at positions that fit within maze corridors
for (var i = 0; i < 7; i++) {
	var newCoin = new Coin();
	game.addChild(newCoin);
	// Set the coins at positions within the maze corridors
	newCoin.x = coinPositions[i].x;
	newCoin.y = coinPositions[i].y;
	console.log("Coin " + (i + 1) + " position: x=" + newCoin.x + ", y=" + newCoin.y);
}
game.up = function (x, y, obj) {
	// Reset the dragged wall when the mouse is released
	game.draggedWall = null;
	game.isMouseDown = false;
};
// Set a flag to track if the mouse is up
game.isMouseDown = false;
// Add level text to the top right side
var levelText = new Text2('Level 1', {
	size: 80,
	fill: 0xFFFFFF
});
levelText.anchor.set(1, 0); // Sets anchor to the top right edge of the text.
LK.gui.topRight.addChild(levelText);
// Initialize status time
var statusTime = 60; // 60 seconds = 1 minute
// Initialize status time text
var statusTimeText = new Text2(statusTime.toString(), {
	size: 80,
	fill: 0xFFFFFF
});
// Initialize score text to display the number of coins after a slash
var scoreTxt = new Text2('0/7', {
	size: 80,
	fill: 0xFFFFFF
});
scoreTxt.anchor.set(0, 0); // Sets anchor to the top left edge of the text.
statusTimeText.anchor.set(-0.8, 0); // Sets anchor to the top center edge of the text.
LK.gui.top.addChild(statusTimeText);
// Position the score text directly to the left of the time text
scoreTxt.x = -400; // Position score text to the left of time text
LK.gui.top.addChild(scoreTxt);
// Create a timer that decreases the status time every second
var statusTimeTimer = LK.setInterval(function () {
	statusTime--;
	// Update the status time text
	statusTimeText.setText(statusTime.toString());
	// If the status time reaches 0, stop the timer and show game over
	if (statusTime <= 0) {
		LK.clearInterval(statusTimeTimer);
		LK.showGameOver();
	}
}, 1000); // 1000 milliseconds = 1 second
// Update the score display to show the number of coins after a slash
scoreTxt.setText(LK.getScore() + '/7');
game.move = function (x, y, obj) {
	// Check if the mouse is down and a wall2 asset is being dragged
	if (game.isMouseDown && game.draggedWall) {
		game.draggedWall.x = x;
		game.draggedWall.y = y;
	} else {
		// Check if the cursor reaches any wall2 asset
		game.children.forEach(function (child) {
			if (child.assetId === 'wall2' && point.intersects(child)) {
				game.draggedWall = child;
			}
		});
	}
	// Update the position of the point asset to the current mouse position
	point.x = x;
	point.y = y;
	// Draw the way of cursor by point asset when its moving
	var newPoint = LK.getAsset('point', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	newPoint.x = x;
	newPoint.y = y;
	game.addChild(newPoint);
	// Check for intersection with wall1 and wall2 assets
	game.children.forEach(function (child) {
		if ((child.assetId === 'wall1' || child.assetId === 'wall2') && point.intersects(child)) {
			// Handle collision with wall1 or wall2
			console.log("Collision detected with wall:", child.assetId);
			// Implement any specific logic needed for collision with walls
		}
	});
	// Coin collision is now handled in the Coin class update method
	// We don't need to check for coin collisions here anymore
};

===================================================================
--- original.js
+++ change.js
@@ -217,38 +217,72 @@
 	// Set a flag to track if the mouse is down
 	game.isMouseDown = true;
 	// Coin handling is now done exclusively in the Coin class update method
 };
-// Create 7 new coin assets at fixed positions that fit within maze corridors
+// Create a function to check if a position is clear of walls
+function isPositionClear(x, y, minDistance) {
+	var isClear = true;
+	game.children.forEach(function (child) {
+		if (child.assetId === 'wall1' || child.assetId === 'wall2') {
+			if (Math.abs(child.x - x) < minDistance && Math.abs(child.y - y) < minDistance) {
+				isClear = false;
+			}
+		}
+	});
+	return isClear;
+}
+// Create a function to find valid coin positions
+function findValidCoinPositions(count) {
+	var positions = [];
+	var minDistanceFromWall = 50; // Minimum distance from any wall
+	var minDistanceBetweenCoins = 100; // Minimum distance between coins
+	var maxAttempts = 200; // Maximum attempts to find a valid position
+	// Try to find valid positions for all coins
+	for (var i = 0; i < count; i++) {
+		var validPosition = false;
+		var attempts = 0;
+		var x, y;
+		while (!validPosition && attempts < maxAttempts) {
+			// Generate a random position within the playable area
+			x = playableAreaLeft + cellWidth * (1 + Math.random() * (gridSizeX - 2));
+			y = playableAreaTop + cellHeight * (1 + Math.random() * (gridSizeY - 2));
+			// Check if position is clear of walls
+			validPosition = isPositionClear(x, y, minDistanceFromWall);
+			// Check if position is far enough from other coins
+			if (validPosition) {
+				for (var j = 0; j < positions.length; j++) {
+					if (Math.abs(positions[j].x - x) < minDistanceBetweenCoins && Math.abs(positions[j].y - y) < minDistanceBetweenCoins) {
+						validPosition = false;
+						break;
+					}
+				}
+			}
+			attempts++;
+		}
+		if (validPosition) {
+			positions.push({
+				x: x,
+				y: y
+			});
+		} else {
+			// Fallback position if we couldn't find a valid one
+			positions.push({
+				x: playableAreaLeft + (i + 1) * (playableWidth / (count + 1)),
+				y: playableAreaTop + (i % 2 === 0 ? playableHeight / 3 : playableHeight * 2 / 3)
+			});
+		}
+	}
+	return positions;
+}
+// Generate valid positions for 7 coins based on the current maze layout
+var coinPositions = findValidCoinPositions(7);
+// Create 7 new coin assets at positions that fit within maze corridors
 for (var i = 0; i < 7; i++) {
 	var newCoin = new Coin();
 	game.addChild(newCoin);
 	// Set the coins at positions within the maze corridors
-	if (i === 0) {
-		newCoin.x = playableAreaLeft + cellWidth * 1.5;
-		newCoin.y = playableAreaTop + cellHeight * 1.5;
-	} else if (i === 1) {
-		newCoin.x = playableAreaLeft + cellWidth * 3.5;
-		newCoin.y = playableAreaTop + cellHeight * 4.5;
-	} else if (i === 2) {
-		newCoin.x = playableAreaLeft + cellWidth * 6.5;
-		newCoin.y = playableAreaTop + cellHeight * 3.5;
-	} else if (i === 3) {
-		newCoin.x = playableAreaLeft + cellWidth * 8.5;
-		newCoin.y = playableAreaTop + cellHeight * 7.5;
-	} else if (i === 4) {
-		newCoin.x = playableAreaLeft + cellWidth * 10.5;
-		newCoin.y = playableAreaTop + cellHeight * 2.5;
-	} else if (i === 5) {
-		newCoin.x = playableAreaLeft + cellWidth * 2.5;
-		newCoin.y = playableAreaTop + cellHeight * 11.5;
-	} else if (i === 6) {
-		newCoin.x = playableAreaLeft + cellWidth * 9.5;
-		newCoin.y = playableAreaTop + cellHeight * 13.5;
-	} else {
-		newCoin.x = 200 + i * 200;
-		newCoin.y = 200 + i * 200;
-	}
+	newCoin.x = coinPositions[i].x;
+	newCoin.y = coinPositions[i].y;
 	console.log("Coin " + (i + 1) + " position: x=" + newCoin.x + ", y=" + newCoin.y);
 }
 game.up = function (x, y, obj) {
 	// Reset the dragged wall when the mouse is released