Play
:quality(85)/https://cdn.frvr.ai/678c4643d8613e9e9372d82d.png)
:quality(85)/https://cdn.upit.com/ywm9keacalifwpnsplvo3iv3.jpeg)
:quality(85)/https://cdn.frvr.ai/678c4981d8613e9e9372d853.png)
#puzzle
#maze
#challenge
#brainteaser
#adventure
Creation History
User prompt
do level2 as another scene separated from level1
User prompt
Please fix the bug: 'ReferenceError: resetGame is not defined' in or related to this line: 'resetGame(); // Call a function to reset the game for the next level' Line Number: 51
User prompt
Please fix the bug: 'ReferenceError: resetGame is not defined' in or related to this line: 'resetGame(); // Call a function to reset the game for the next level' Line Number: 51
User prompt
Please fix the bug: 'ReferenceError: resetGame is not defined' in or related to this line: 'resetGame(); // Call a function to reset the game for the next level' Line Number: 51
User prompt
Please fix the bug: 'createMaze is not defined' in or related to this line: 'createMaze();' Line Number: 781
User prompt
Add level 2 after finishing level 1 go to level 2
User prompt
let doors each time you change the maze shape don't let any area closed
User prompt
create a list of walls and coins to know how much walls are in game
User prompt
check if the coins always between tow edges like corner not in middle of a wall or between edges of one wall
User prompt
make sure the coins not on the top of walls!
User prompt
change the position of the coins to reset in other position in space between walls.
User prompt
Do random position for coins
User prompt
don't respawn the coins again after collecting 7/7
User prompt
add the coins in different positions
User prompt
change position of coins when reloading each time
User prompt
I meant beside walls of wall2 they have to be in a space not inside any walls of wall2 on the maze!
User prompt
prevent placing coins inside any walls it must be placed beside them
User prompt
change the places of coins when changing the shape of maze too.
User prompt
don't reset scoretxt position in the middle then move it to its real one reset it to its real one.
Code edit (1 edits merged)
Please save this source code
User prompt
let the walls of wall2 be only between the 4 walls of wall1 from the inside.
User prompt
let the walls of wall2 be only between the 4 walls of wall1 from the inside.
User prompt
add more walls and change the shape of the maze let spaces between it as the size of coins.
User prompt
I didn't tell you to add diagonal walls remove them and add only H/V walls
/****
* 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: 3 // 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 = 8; // Number of vertical sections
var gridSizeY = 10; // Number of horizontal sections
var cellWidth = playableWidth / gridSizeX;
var cellHeight = playableHeight / gridSizeY;
var wallThickness = 0.8; // Wall thickness factor
// Create horizontal walls with strategic gaps for pathways
for (var y = 1; y < gridSizeY; y += 2) {
for (var x = 0; x < gridSizeX - 1; x++) {
// Create patterns of walls and gaps
if (y % 4 === 1 && x % 3 !== 1 || y % 4 === 3 && x % 3 !== 2) {
var horizontalWall = LK.getAsset('wall2', {
anchorX: 0.5,
anchorY: 0.5,
scaleX: cellWidth / 100,
scaleY: wallThickness
});
horizontalWall.x = playableAreaLeft + (x + 0.5) * cellWidth;
horizontalWall.y = playableAreaTop + y * cellHeight;
game.addChild(horizontalWall);
}
}
}
// Create vertical walls with strategic gaps for pathways
for (var x = 1; x < gridSizeX; x += 2) {
for (var y = 0; y < gridSizeY - 1; y++) {
// Create patterns of walls and gaps
if (x % 4 === 1 && y % 3 !== 1 || x % 4 === 3 && y % 3 !== 2) {
var verticalWall = LK.getAsset('wall2', {
anchorX: 0.5,
anchorY: 0.5,
scaleX: wallThickness,
scaleY: cellHeight / 100
});
verticalWall.x = playableAreaLeft + x * cellWidth;
verticalWall.y = playableAreaTop + (y + 0.5) * cellHeight;
game.addChild(verticalWall);
}
}
}
// Add some additional horizontal walls in specific positions
for (var i = 0; i < 5; i++) {
var specialHWall = LK.getAsset('wall2', {
anchorX: 0.5,
anchorY: 0.5,
scaleX: cellWidth * 1.5 / 100,
scaleY: wallThickness
});
specialHWall.x = playableAreaLeft + (1 + i * 1.5) * cellWidth;
specialHWall.y = playableAreaTop + (2 + i % 3) * cellHeight;
game.addChild(specialHWall);
}
// Add some additional vertical walls in specific positions
for (var i = 0; i < 5; i++) {
var specialVWall = LK.getAsset('wall2', {
anchorX: 0.5,
anchorY: 0.5,
scaleX: wallThickness,
scaleY: cellHeight * 1.5 / 100
});
specialVWall.x = playableAreaLeft + (2 + i % 3) * cellWidth;
specialVWall.y = playableAreaTop + (1 + i * 1.5) * cellHeight;
game.addChild(specialVWall);
}
// No diagonal walls or cross-shaped patterns to keep only horizontal and vertical walls
// No zigzag walls to keep the maze simpler with only horizontal and vertical walls
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 7 new coin assets at fixed 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;
}
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: 100,
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: 100,
fill: 0xFFFFFF
});
// Initialize score text to display the number of coins after a slash
var scoreTxt = new Text2('0/7', {
size: 100,
fill: 0xFFFFFF
});
scoreTxt.anchor.set(0.8, 0); // Sets anchor to the top center edge of the text.
LK.gui.top.addChild(scoreTxt);
statusTimeText.anchor.set(-0.8, 0); // Sets anchor to the top center edge of the text.
LK.gui.top.addChild(statusTimeText);
// 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();
}
// Update the score text position to be beside the status time text
scoreTxt.x = statusTimeText.x - statusTimeText.width / 2 - scoreTxt.width / 2 - 50; // Add some space between the status coin text and the time
}, 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
@@ -100,115 +100,73 @@
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 gridSizeX = 8; // Number of vertical sections
+var gridSizeY = 10; // 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 (var y = 0; y <= gridSizeY; y += 2) {
- for (var x = 0; x < gridSizeX; x++) {
- // Skip some walls to create paths (50% chance)
- if (Math.random() > 0.5 && x !== 0 && x !== gridSizeX - 1) {
- continue;
+// Create horizontal walls with strategic gaps for pathways
+for (var y = 1; y < gridSizeY; y += 2) {
+ for (var x = 0; x < gridSizeX - 1; x++) {
+ // Create patterns of walls and gaps
+ if (y % 4 === 1 && x % 3 !== 1 || y % 4 === 3 && x % 3 !== 2) {
+ var horizontalWall = LK.getAsset('wall2', {
+ anchorX: 0.5,
+ anchorY: 0.5,
+ scaleX: cellWidth / 100,
+ scaleY: wallThickness
+ });
+ horizontalWall.x = playableAreaLeft + (x + 0.5) * cellWidth;
+ horizontalWall.y = playableAreaTop + y * cellHeight;
+ game.addChild(horizontalWall);
}
- var horizontalWall = LK.getAsset('wall2', {
- anchorX: 0.5,
- anchorY: 0.5,
- scaleX: cellWidth / 100 * (0.7 + Math.random() * 0.3),
- scaleY: wallThickness
- });
- horizontalWall.x = playableAreaLeft + (x + 0.5) * cellWidth;
- horizontalWall.y = playableAreaTop + y * cellHeight;
- game.addChild(horizontalWall);
}
}
-// Create vertical walls with gaps
-for (var x = 0; x <= gridSizeX; x += 2) {
- for (var y = 0; y < gridSizeY; y++) {
- // Skip some walls to create paths (50% chance)
- if (Math.random() > 0.5 && y !== 0 && y !== gridSizeY - 1) {
- continue;
+// Create vertical walls with strategic gaps for pathways
+for (var x = 1; x < gridSizeX; x += 2) {
+ for (var y = 0; y < gridSizeY - 1; y++) {
+ // Create patterns of walls and gaps
+ if (x % 4 === 1 && y % 3 !== 1 || x % 4 === 3 && y % 3 !== 2) {
+ var verticalWall = LK.getAsset('wall2', {
+ anchorX: 0.5,
+ anchorY: 0.5,
+ scaleX: wallThickness,
+ scaleY: cellHeight / 100
+ });
+ verticalWall.x = playableAreaLeft + x * cellWidth;
+ verticalWall.y = playableAreaTop + (y + 0.5) * cellHeight;
+ game.addChild(verticalWall);
}
- var verticalWall = LK.getAsset('wall2', {
- anchorX: 0.5,
- anchorY: 0.5,
- scaleX: wallThickness,
- scaleY: cellHeight / 100 * (0.7 + Math.random() * 0.3)
- });
- verticalWall.x = playableAreaLeft + x * cellWidth;
- verticalWall.y = playableAreaTop + (y + 0.5) * cellHeight;
- game.addChild(verticalWall);
}
}
-// Add some diagonal walls for variety
-for (var i = 0; i < 8; i++) {
- var diagonalLength = Math.floor(Math.random() * 3) + 2; // Length 2-4 cells
- var diagonalWall = LK.getAsset('wall2', {
+// Add some additional horizontal walls in specific positions
+for (var i = 0; i < 5; i++) {
+ var specialHWall = LK.getAsset('wall2', {
anchorX: 0.5,
anchorY: 0.5,
- scaleX: diagonalLength * cellWidth / 100 * 0.8,
+ scaleX: cellWidth * 1.5 / 100,
scaleY: wallThickness
});
- var cellX = Math.floor(Math.random() * (gridSizeX - 2)) + 1;
- var cellY = Math.floor(Math.random() * (gridSizeY - 2)) + 1;
- diagonalWall.x = playableAreaLeft + (cellX + diagonalLength / 2) * cellWidth;
- diagonalWall.y = playableAreaTop + (cellY + 0.5) * cellHeight;
- diagonalWall.rotation = Math.PI / 4; // 45 degrees
- game.addChild(diagonalWall);
+ specialHWall.x = playableAreaLeft + (1 + i * 1.5) * cellWidth;
+ specialHWall.y = playableAreaTop + (2 + i % 3) * cellHeight;
+ game.addChild(specialHWall);
}
-// Add some circular/square wall patterns
-for (var i = 0; i < 4; i++) {
- // Create circular arrangement of walls
- var centerX = playableAreaLeft + (Math.floor(Math.random() * (gridSizeX - 4)) + 2) * cellWidth;
- var centerY = playableAreaTop + (Math.floor(Math.random() * (gridSizeY - 4)) + 2) * cellHeight;
- var radius = cellWidth * (1.5 + Math.random());
- // Create 4 walls in a square arrangement with a gap
- for (var j = 0; j < 4; j++) {
- var squareWall = LK.getAsset('wall2', {
- anchorX: 0.5,
- anchorY: 0.5,
- scaleX: j % 2 === 0 ? wallThickness : radius / 50,
- scaleY: j % 2 === 0 ? radius / 50 : wallThickness
- });
- var angle = j * Math.PI / 2;
- squareWall.x = centerX + Math.cos(angle) * radius / 2;
- squareWall.y = centerY + Math.sin(angle) * radius / 2;
- game.addChild(squareWall);
- }
-}
-// Add some long zigzag walls
-for (var i = 0; i < 3; i++) {
- var startX = playableAreaLeft + (1 + i * 3) * cellWidth;
- var startY = playableAreaTop + (2 + i * 4) * cellHeight;
- // Create zigzag pattern with 3 segments
- for (var j = 0; j < 3; j++) {
- var zigzagWall = LK.getAsset('wall2', {
- anchorX: 0.5,
- anchorY: 0.5,
- scaleX: j % 2 === 0 ? cellWidth * 2 / 100 : wallThickness,
- scaleY: j % 2 === 0 ? wallThickness : cellHeight * 2 / 100
- });
- zigzagWall.x = startX + (j % 2 === 0 ? cellWidth : 0);
- zigzagWall.y = startY + (j % 2 === 1 ? cellHeight : 0);
- game.addChild(zigzagWall);
- // Update start position for next segment
- startX = zigzagWall.x + (j % 2 === 0 ? cellWidth : 0);
- startY = zigzagWall.y + (j % 2 === 1 ? cellHeight : 0);
- }
- // Add one more horizontal wall to complete the zigzag
- var endWall = LK.getAsset('wall2', {
+// Add some additional vertical walls in specific positions
+for (var i = 0; i < 5; i++) {
+ var specialVWall = LK.getAsset('wall2', {
anchorX: 0.5,
anchorY: 0.5,
- scaleX: cellWidth * 1.5 / 100,
- scaleY: wallThickness
+ scaleX: wallThickness,
+ scaleY: cellHeight * 1.5 / 100
});
- endWall.x = startX + cellWidth * 0.75;
- endWall.y = startY;
- game.addChild(endWall);
+ specialVWall.x = playableAreaLeft + (2 + i % 3) * cellWidth;
+ specialVWall.y = playableAreaTop + (1 + i * 1.5) * cellHeight;
+ game.addChild(specialVWall);
}
+// No diagonal walls or cross-shaped patterns to keep only horizontal and vertical walls
+// No zigzag walls to keep the maze simpler with only horizontal and vertical walls
var point = LK.getAsset('point', {
anchorX: 0.5,
anchorY: 0.5
});
Images
:quality(85)/https://cdn.frvr.ai/6784fc10680de642ad63dde5.png%3F3)
:quality(85)/https://cdn.frvr.ai/678bca87b5906f5bade23fbc.png%3F3)
Used plugins
@upit/tween
