/**** * 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(); // If all coins are collected, we don't regenerate coins - game is complete if (LK.getScore() === 7) { // Show a "you win" message since all coins are collected LK.showYouWin(); } } 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') { // Check if the point is too close to the wall 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; } // Create a function to check if a position is near a wall but not inside it function isPositionBesideWall(x, y) { var minDistanceInside = 50; // Minimum distance to consider inside a wall var maxDistanceOutside = 100; // Maximum distance to consider beside a wall var minProximity = 20; // Minimum distance a coin should be from a wall var isNearWall = false; var isInsideWall = false; // First check if the position is inside any wall game.children.forEach(function (child) { if (child.assetId === 'wall1' || child.assetId === 'wall2') { // Use the actual dimensions of the wall for precise collision detection var halfWidth = child.width / 2; var halfHeight = child.height / 2; if (Math.abs(child.x - x) < halfWidth && Math.abs(child.y - y) < halfHeight) { isInsideWall = true; } } }); if (isInsideWall) { return false; // Position is inside a wall, not valid } // Then check if the position is near any wall game.children.forEach(function (child) { if (child.assetId === 'wall1' || child.assetId === 'wall2') { // Calculate distance from edge of wall, not center var distX = Math.max(Math.abs(child.x - x) - child.width / 2, 0); var distY = Math.max(Math.abs(child.y - y) - child.height / 2, 0); var distance = Math.sqrt(distX * distX + distY * distY); if (distance >= minProximity && distance <= maxDistanceOutside) { isNearWall = true; } } }); return isNearWall; // Position is beside a wall, valid } // Modified findValidCoinPositions function to ensure coins are placed beside walls function findValidCoinPositionsNextToWalls(count) { var positions = []; var minDistanceBetweenCoins = 100; // Minimum distance between coins var maxAttempts = 500; // Increased max attempts to find valid positions // 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 beside a wall but not inside it // First verify if it's not inside any wall var insideWall = false; game.children.forEach(function (child) { if (child.assetId === 'wall1' || child.assetId === 'wall2') { if (Math.abs(x - child.x) < child.width / 2 + 10 && Math.abs(y - child.y) < child.height / 2 + 10) { insideWall = true; } } }); if (!insideWall) { // Then check if it's beside a wall validPosition = isPositionBesideWall(x, y); } // 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 { console.log("Could not find valid position for coin " + (i + 1) + ", using fallback"); // Fallback position if we couldn't find a valid one // For fallback, try to find a clear position that's far from walls var fallbackX = playableAreaLeft + (i + 1) * (playableWidth / (count + 1)); var fallbackY = playableAreaTop + (i % 2 === 0 ? playableHeight / 3 : playableHeight * 2 / 3); // Try to adjust the fallback position to be beside a wall for (var w = 0; w < game.children.length; w++) { var child = game.children[w]; if (child.assetId === 'wall2') { fallbackX = child.x + child.width / 2 + 50; fallbackY = child.y; var validFallback = true; // Check if this fallback position works game.children.forEach(function (otherChild) { if (otherChild.assetId === 'wall1' || otherChild.assetId === 'wall2') { if (Math.abs(fallbackX - otherChild.x) < otherChild.width / 2 + 10 && Math.abs(fallbackY - otherChild.y) < otherChild.height / 2 + 10) { validFallback = false; } } }); if (validFallback) { break; } } } positions.push({ x: fallbackX, y: fallbackY }); } } return positions; } // Function to generate coin positions on each level load function generateCoinPositions() { // Add randomness to ensure positions are different each time var randomSeed = Math.random() * 1000; // Generate valid positions for 7 coins based on the current maze layout var coinPositions = findValidCoinPositionsNextToWalls(7); // Verify each position is valid by checking if it's inside any wall for (var i = 0; i < coinPositions.length; i++) { var posX = coinPositions[i].x; var posY = coinPositions[i].y; var invalidPos = false; game.children.forEach(function (child) { if (child.assetId === 'wall1' || child.assetId === 'wall2') { if (Math.abs(posX - child.x) < child.width / 2 && Math.abs(posY - child.y) < child.height / 2) { console.log("Warning: Coin position inside wall at:", posX, posY); invalidPos = true; // Try to adjust the position to be beside the wall instead coinPositions[i].x = child.x + child.width / 2 + 40; // Verify the new position isn't inside another wall var stillInvalid = false; game.children.forEach(function (otherChild) { if (otherChild.assetId === 'wall1' || otherChild.assetId === 'wall2') { if (Math.abs(coinPositions[i].x - otherChild.x) < otherChild.width / 2 && Math.abs(posY - otherChild.y) < otherChild.height / 2) { stillInvalid = true; } } }); if (stillInvalid) { // Try a different adjustment coinPositions[i].x = child.x; coinPositions[i].y = child.y + child.height / 2 + 40; } } } }); } return coinPositions; } // Generate initial coin positions var coinPositions = generateCoinPositions(); // 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 };