User prompt
Like the fontain, let the valve turn indefinetly
User prompt
Please fix the bug: 'Timeout.tick error: self.normalizeRotation is not a function' in or related to this line: 'var normalizedRotation = self.normalizeRotation(tile.rotation);' Line Number: 760
Code edit (1 edits merged)
Please save this source code
User prompt
Please fix the bug: 'Uncaught TypeError: self.normalizeRotation is not a function' in or related to this line: 'var normalizedRotation = self.normalizeRotation(tile.rotation);' Line Number: 752
Code edit (8 edits merged)
Please save this source code
User prompt
add detail logs using log() in flowThroughPipe enough to debug the water flow not working
Code edit (2 edits merged)
Please save this source code
User prompt
Please fix the bug: 'Uncaught TypeError: Cannot set properties of undefined (setting 'normalizeRotation')' in or related to this line: 'self.normalizeRotation = function (rotation) {' Line Number: 1134
User prompt
Please fix the bug: 'Uncaught TypeError: self.normalizeRotation is not a function' in or related to this line: 'var normalizedRotation = self.normalizeRotation(tile.rotation);' Line Number: 839
Code edit (1 edits merged)
Please save this source code
User prompt
log canReachEnd result (use log())
Code edit (1 edits merged)
Please save this source code
User prompt
also log canReachEnd
User prompt
add detailed logs inside checkWinCondition
User prompt
log states enter and change and the checkWinCondition
Code edit (1 edits merged)
Please save this source code
User prompt
add logs in checkWinCondition
User prompt
Please fix the bug: 'Uncaught TypeError: Set is not a constructor' in or related to this line: 'return self.canReachEnd(startX, startY, new Set());' Line Number: 676
Code edit (1 edits merged)
Please save this source code
User prompt
Please fix the bug: 'Uncaught TypeError: self.checkWinCondition is not a function' in or related to this line: 'if (self.checkWinCondition()) {' Line Number: 640
Code edit (1 edits merged)
Please save this source code
User prompt
add log in initPuzlle
User prompt
add a log in each initXXXState function
User prompt
add log on states changes
Code edit (1 edits merged)
Please save this source code
/****
* Classes
****/
var Tile = Container.expand(function () {
var self = Container.call(this);
// Properties
self.type = 'empty';
self.baseTint = 0x8FBE00;
self.baseTintLight = 0x5ED000;
self.maxWaterSize = 260;
self.flowSpeed = 12;
self.startFlowTicks = 0;
self.flow = false;
self.connections = [];
self.position = {
x: 0,
y: 0
};
self.rotation = 0;
// Methods
self.setType = function (type, x, y) {
self.type = type;
var baseTileAsset = type == 'start' || type == 'end' || puzzleManager && puzzleManager.levelConfigs && puzzleManager.levelConfigs[puzzleManager.currentLevel] && puzzleManager.levelConfigs[puzzleManager.currentLevel].fixedTiles.includes(x + ',' + y) ? 'baseTile' : 'baseMobileTile';
if (type == 'empty') {
return;
}
// Attach baseTile asset
self.baseTile = self.attachAsset(baseTileAsset, {
anchorX: 0.5,
anchorY: 0.5,
width: tileSize,
height: tileSize,
tint: 0xFFFFFF
});
self.width = tileSize;
self.height = tileSize;
switch (type) {
case 'start':
self.attachAsset('startPipeAsset', {
anchorX: 0.5,
anchorY: 0.5,
x: 20,
y: 55,
tint: self.baseTint
});
self.valve = self.attachAsset('vane', {
anchorX: 0.5,
anchorY: 0.5,
x: 20,
y: 15,
tint: self.baseTint
});
self.water = self.attachAsset('waterV', {
anchorX: 0.5,
anchorY: 0,
x: -0,
y: -120,
height: 0,
visible: false,
dir: ''
});
break;
case 'end':
self.attachAsset('endPipeAsset', {
anchorX: 0.5,
anchorY: 0.5,
x: 0,
y: 55,
tint: self.baseTint
});
self.water = self.attachAsset('waterV', {
anchorX: 0.5,
anchorY: 0,
x: -0,
y: -120,
height: 0,
visible: false,
dir: ''
});
self.fountain = self.attachAsset('fontain', {
anchorX: 0.5,
anchorY: 0.5,
x: 0,
y: 0,
width: 0,
height: 0,
visible: false
});
break;
case 'crossPipe':
self.attachAsset('straightPipeHAsset', {
anchorX: 0.5,
anchorY: 0.5,
y: -40,
tint: self.baseTint
});
self.attachAsset('straightPipeHAsset', {
anchorX: 0.5,
anchorY: 0.5,
scaleY: -1,
y: 30,
tint: self.baseTint
});
self.attachAsset('straightPipeVAsset', {
anchorX: 0.5,
anchorY: 0.5,
x: -30,
tint: self.baseTint
});
self.attachAsset('straightPipeVAsset', {
anchorX: 0.5,
anchorY: 0.5,
scaleX: -1,
x: 30,
tint: self.baseTint
});
self.water = self.attachAsset('waterV', {
anchorX: 0.5,
anchorY: 0,
x: -0,
y: -120,
height: 0,
visible: false,
dir: ''
});
break;
case 'straightPipeH':
self.attachAsset('straightPipeHAsset', {
anchorX: 0.5,
anchorY: 0.5,
y: -40,
tint: self.baseTint
});
self.attachAsset('straightPipeHAsset', {
anchorX: 0.5,
anchorY: 0.5,
scaleY: -1,
y: 30,
tint: self.baseTint
});
self.water = self.attachAsset('waterH', {
anchorX: 0,
anchorY: 0.5,
x: -130,
y: -5,
width: 0,
visible: false,
dir: 'lr'
});
break;
case 'straightPipeV':
self.attachAsset('straightPipeVAsset', {
anchorX: 0.5,
anchorY: 0.5,
x: -30,
tint: self.baseTint
});
self.attachAsset('straightPipeVAsset', {
anchorX: 0.5,
anchorY: 0.5,
scaleX: -1,
x: 30,
tint: self.baseTint
});
self.water = self.attachAsset('waterV', {
anchorX: 0.5,
anchorY: 0,
x: -0,
y: -120,
height: 0,
visible: false,
dir: 'tb'
});
break;
case 'cornerPipe':
self.attachAsset('cornerPipeAsset', {
anchorX: 0.5,
anchorY: 0.5,
x: -60,
y: -60,
tint: self.baseTintLight
});
// Corner part of the water
self.waterCorner = self.attachAsset('waterCorner', {
anchorX: 1,
anchorY: 1,
width: 108,
height: 108,
x: -65,
y: -65,
rotation: -Math.PI / 2,
//-Math.PI / 2, at start to -Math.PI,
visible: false,
dir: ''
});
// Vertical part of the water
self.waterV = self.attachAsset('waterV', {
anchorX: 0.5,
anchorY: 0,
width: 110,
x: -120,
y: -5,
rotation: -Math.PI / 2,
height: 0,
visible: false,
dir: ''
});
// Horizontal part of the water
self.waterH = self.attachAsset('waterH', {
anchorX: 0,
anchorY: 0.5,
x: -5,
y: -50,
//-15,
width: 0,
height: 112,
rotation: -Math.PI / 2,
visible: false,
dir: ''
});
// Corner part of the water
self.waterCornerCover = self.attachAsset('waterCorner', {
anchorX: 1,
anchorY: 1,
width: 108,
height: 108,
x: -65,
y: -65,
rotation: -Math.PI,
visible: false,
dir: ''
});
break;
}
};
self.updatePosition = function (x, y) {
self.position.x = x;
self.position.y = y;
if (self.baseTile) {
self.baseTile.width = tileSize;
self.baseTile.height = tileSize;
}
self.x = x * tileSize + gridBoard.x - gridBoard.width / 2 + tileSize / 2 + boardOffsetX;
self.y = y * tileSize + gridBoard.y - gridBoard.height / 2 + tileSize / 2 + boardOffsetY;
log('Tile index:', x, y, 'Tile position:', self.x, self.y, 'Tile dimensions:', self.width, self.height, ' self:', self);
};
self.setRotation = function (direction) {
switch (direction) {
case 'left':
self.rotation = Math.PI * 0.5;
break;
case 'right':
self.rotation = -Math.PI * 0.5;
break;
case 'up':
self.rotation = 0;
break;
case 'down':
self.rotation = Math.PI;
break;
}
log('Tile position:', self.x, self.y, 'Tile rotation:', self.rotation);
};
self.update = function () {
if (self.flow) {
if (!self.startFlowTicks) {
self.startFlowTicks = LK.ticks;
if (self.water) {
self.water.visible = true;
}
if (self.waterV) {
self.waterV.visible = true;
}
if (self.waterH) {
self.waterH.visible = true;
}
}
if (self.type === 'start') {
// Rotate valve for start pipe
var rotationValue = (LK.ticks - self.startFlowTicks) * 0.1;
if (self.valve) {
self.valve.rotation = rotationValue;
}
if (rotationValue >= Math.PI * 2) {
self.flow = false;
}
} else if (self.type === 'cornerPipe') {
// Corner pipe animation
var progress = (LK.ticks - self.startFlowTicks) * self.flowSpeed; // Accelerate water speed
var thirdSize = self.maxWaterSize / 3 - 10; // Split animation into three phases
var sidesSize = self.maxWaterSize / 3; //+ 40;
if (progress < self.maxWaterSize) {
// Phase 1: Vertical water grows
if (progress < thirdSize) {
if (self.waterV) {
self.waterV.height = progress;
}
}
// Phase 2: Corner water appears and rotates
else if (progress < thirdSize * 2) {
if (self.waterV) {
self.waterV.height = thirdSize; // Keep vertical at full first-phase height
}
if (self.waterCorner) {
self.waterCorner.visible = true;
self.waterCorner.alpha = Math.min(Math.max(0, ((progress - thirdSize) / thirdSize - 0.5) * 2, 0), 1); // Animate alpha from 0 to 1
// Calculate rotation from -PI/2 to -PI
var rotationProgress = (progress - thirdSize) / thirdSize; // 0 to 1
self.waterCorner.rotation = -Math.PI / 2 - rotationProgress * Math.PI / 2;
}
}
// Phase 3: Horizontal water grows
else {
if (self.waterV) {
self.waterV.height = thirdSize;
}
if (self.waterCorner) {
self.waterCorner.visible = true;
self.waterCorner.alpha = 1;
self.waterCorner.rotation = -Math.PI; // Keep at final rotation
}
if (self.waterH) {
self.waterH.visible = true;
self.waterH.width = Math.min(progress - thirdSize * 2, sidesSize);
}
}
} else {
self.flow = false;
}
} else if (self.type === 'end' && self.fountain) {
// Animate fountain growth
var sizeValue = (LK.ticks - self.startFlowTicks) * self.flowSpeed;
if (sizeValue < self.maxWaterSize) {
self.fountain.width = sizeValue;
self.fountain.height = sizeValue;
self.fountain.visible = true;
} else {
self.flow = false;
if (!waterDropInterval) {
createWaterDrops(self.x, self.y, game);
waterDropInterval = LK.setInterval(function () {
createWaterDrops(self.x, self.y, game);
}, 500 + Math.random() * 500);
}
}
} else if (self.water) {
// Regular pipe animation
var heightValue = (LK.ticks - self.startFlowTicks) * self.flowSpeed;
if (self.water.dir != '' && heightValue < self.maxWaterSize) {
if (self.water.dir == 'tb') {
self.water.height = heightValue;
}
if (self.water.dir == 'lr') {
self.water.width = heightValue;
}
} else {
self.flow = false;
}
}
}
if (self.type === 'end' && self.fountain && self.fountain.visible) {
self.fountain.rotation += 0.1; // Rotate the fountain indefinitely
}
};
self.setType(self.type);
return self;
});
var WaterDrop = Container.expand(function () {
var self = Container.call(this);
var waterDropGraphics = self.attachAsset('waterDrop', {
anchorX: 0.5,
anchorY: 0.5
});
// Set initial tint to a random color
var rainbowColors = [0xC7ECFE, 0xDDFDFF, 0xF4FFFF, 0xC8F8FF]; // Rainbow [0xFF0000, 0xFF7F00, 0xFFFF00, 0x00FF00, 0x0000FF, 0x4B0082, 0x8B00FF];
waterDropGraphics.tint = rainbowColors[Math.floor(Math.random() * rainbowColors.length)];
self.vx = 0;
self.vy = 0;
self.life = 0;
self.size = 7;
self.alpha = 0.75 + Math.random() * 0.25;
self.update = function () {
self.x += self.vx;
self.y += self.vy;
self.rotation = Math.atan2(self.vy, self.vx) + Math.PI * 0.55;
// Animate size
var sizeProgress = (120 - self.life) / 120; // Assuming life starts at 120
waterDropGraphics.width = self.size + sizeProgress * self.size * 2;
waterDropGraphics.height = self.size * 2 + sizeProgress * self.size * 4;
self.life--;
if (self.life <= 0) {
self.visible = false;
}
};
return self;
});
/****
* Initialize Game
****/
var game = new LK.Game({
backgroundColor: 0x000000
});
/****
* Game Code
****/
var PuzzleManager = function PuzzleManager() {
var self = this;
// Properties
self.currentLevel = 1;
self.selectedTile = null;
self.isComplete = false;
// Methods
self.selectTile = function (x, y) {
// Convert screen coordinates to grid coordinates
var gridX = Math.floor((x - boardOffsetX) / tileSize);
var gridY = Math.floor((y - boardOffsetY) / tileSize);
// Check if coordinates are within grid bounds
if (gridX >= 0 && gridX < 3 && gridY >= 0 && gridY < 3) {
self.selectedTile = self.grid[gridY][gridX];
}
};
self.reset = function () {
self.currentLevel = 1;
self.selectedTile = null;
self.isComplete = false;
self.initPuzzle();
};
self.initPuzzle = function () {
// Initialize grid
self.grid = [];
for (var i = 0; i < 3; i++) {
self.grid[i] = [];
for (var j = 0; j < 3; j++) {
var tile = new Tile();
self.grid[i][j] = tile;
game.addChild(tile);
}
}
};
self.moveTile = function (direction) {
if (!self.selectedTile) {
return;
}
var x = self.selectedTile.position.x;
var y = self.selectedTile.position.y;
var newX = x;
var newY = y;
// Calculate new position
switch (direction) {
case 'right':
newX++;
break;
case 'left':
newX--;
break;
case 'down':
newY++;
break;
case 'up':
newY--;
break;
}
// Swap tiles
var movingTile = self.selectedTile;
var emptyTile = self.grid[newY][newX];
// Update grid
self.grid[newY][newX] = movingTile;
self.grid[y][x] = emptyTile;
// Update positions
movingTile.updatePosition(newX, newY);
if (emptyTile) {
emptyTile.updatePosition(x, y);
}
// Clear selection
self.selectedTile = null;
};
self.checkWinCondition = function () {
// Find start position
var startX = -1,
startY = -1;
for (var i = 0; i < 3; i++) {
for (var j = 0; j < 3; j++) {
if (self.grid[i][j].type === 'start') {
startX = i;
startY = j;
break;
}
}
if (startX !== -1) {
break;
}
}
// Use a Set to track visited positions
var visited = [];
// Check if we can reach the end tile
return this.canReachEnd(startX, startY + 1, visited); // Start flowing down from start
};
self.canReachEnd = function (x, y, visited) {
// Check bounds
if (x < 0 || x >= 3 || y < 0 || y >= 3) {
return false;
}
// Create position key
var key = x + ',' + y;
if (visited.includes(key)) {
return false;
}
visited.push(key);
var tile = self.grid[x][y];
if (!tile || tile.type === 'empty') {
return false;
}
// If we reached the end, success!
if (tile.type === 'end') {
return true;
}
// Get next possible positions based on current tile type and rotation
var nextPositions = [];
switch (tile.type) {
case 'straightPipeV':
nextPositions.push([x, y - 1], [x, y + 1]); // Up and down
break;
case 'straightPipeH':
nextPositions.push([x - 1, y], [x + 1, y]); // Left and right
break;
case 'cornerPipe':
// Check rotation to determine flow direction
if (tile.rotation === Math.PI * 0.5) {
// Left rotation
nextPositions.push([x, y - 1], [x + 1, y]); // Up and right
}
// Add other rotations as needed
break;
case 'crossPipe':
nextPositions.push([x - 1, y], [x + 1, y], [x, y - 1], [x, y + 1]); // All directions
break;
}
// Try each possible next position
for (var i = 0; i < nextPositions.length; i++) {
var nextX = nextPositions[i][0];
var nextY = nextPositions[i][1];
if (this.canReachEnd(nextX, nextY, visited)) {
return true;
}
}
return false;
};
return self;
};
/****
* Game Variables
****/
var debug = true;
function log() {
if (debug) {
console.log.apply(console, arguments);
}
}
// Game constants
var tileSize = 400;
var boardOffsetX = 90;
var boardOffsetY = -100;
// Game state variables
var GAME_STATE = {
INIT: 'INIT',
MENU: 'MENU',
NEW_ROUND: 'NEW_ROUND',
PLAYING: 'PLAYING',
SCORE: 'SCORE'
};
var currentState = GAME_STATE.INIT;
var isPlaying = true;
var gridBoard;
var isMouseDown = false;
var startX = 0;
var startY = 0;
var selectedTile = null;
var dragThreshold = 20;
var levelText;
var waterDrops = [];
var waterDropInterval;
var puzzleManager;
/****
* Helper Functions
****/
function createWaterDrops(x, y, game) {
for (var i = 0; i < 10; i++) {
var waterDrop = waterDrops.find(function (drop) {
return !drop.visible;
});
if (!waterDrop) {
waterDrop = new WaterDrop();
waterDrops.push(waterDrop);
game.addChild(waterDrop);
}
waterDrop.x = x;
waterDrop.y = y;
var angle = Math.random() * Math.PI * 2;
var speed = Math.random() * 3 + 3;
var easeFactor = Math.random() * 0.05 + 0.95; // Random easing factor between 0.95 and 1.0
waterDrop.vx = Math.cos(angle) * speed * easeFactor;
waterDrop.vy = Math.sin(angle) * speed * easeFactor;
waterDrop.life = 120;
waterDrop.visible = true;
}
}
/****
* Game State Management
****/
function initMenuState() {
// Show level selection UI
isPlaying = false;
levelText.visible = true;
levelText.text = "Level 1\nTap to Start";
}
function handleMenuLoop() {
// Update any menu animations here
}
function cleanMenuState() {
levelText.text = "Level 1";
}
function initNewRoundState() {
// Reset puzzle manager for new round
if (puzzleManager) {
puzzleManager.reset();
}
// After a short delay, transition to PLAYING state
LK.setTimeout(function () {
changeGameState(GAME_STATE.PLAYING);
}, 1000);
}
function handleNewRoundLoop() {
// Any pre-game animations can go here
}
function cleanNewRoundState() {
// Clean up any new round state
}
function initPlayingState() {
// Start the gameplay
isPlaying = true;
}
function handlePlayingLoop() {
// Update game logic
if (puzzleManager) {
puzzleManager.update();
// Check if level is complete
if (puzzleManager.isComplete) {
changeGameState(GAME_STATE.SCORE);
}
}
}
function cleanPlayingState() {
isPlaying = false;
}
function initScoreState() {
// Show score screen
levelText.visible = true;
levelText.text = "Level Complete!\nTap to continue";
}
function handleScoreLoop() {
// Update any score animations
if (puzzleManager) {
puzzleManager.update();
}
}
function cleanScoreState() {
levelText.visible = false;
}
function changeGameState(newState) {
// Clean up current state
switch (currentState) {
case GAME_STATE.MENU:
cleanMenuState();
break;
case GAME_STATE.NEW_ROUND:
cleanNewRoundState();
break;
case GAME_STATE.PLAYING:
cleanPlayingState();
break;
case GAME_STATE.SCORE:
cleanScoreState();
break;
}
// Initialize new state
currentState = newState;
switch (newState) {
case GAME_STATE.MENU:
initMenuState();
break;
case GAME_STATE.NEW_ROUND:
initNewRoundState();
break;
case GAME_STATE.PLAYING:
initPlayingState();
break;
case GAME_STATE.SCORE:
initScoreState();
break;
}
}
/****
* Event Handlers
****/
game.down = function (x, y, obj) {
switch (currentState) {
case GAME_STATE.MENU:
changeGameState(GAME_STATE.NEW_ROUND);
break;
case GAME_STATE.PLAYING:
startX = x;
startY = y;
isMouseDown = true;
if (puzzleManager) {
puzzleManager.selectTile(x, y);
}
break;
case GAME_STATE.SCORE:
changeGameState(GAME_STATE.MENU);
break;
}
};
game.move = function (x, y, obj) {
if (currentState !== GAME_STATE.PLAYING || !isMouseDown || !puzzleManager || !puzzleManager.selectedTile) {
return;
}
var deltaX = x - startX;
var deltaY = y - startY;
// Only move if drag distance exceeds threshold
if (Math.abs(deltaX) > dragThreshold || Math.abs(deltaY) > dragThreshold) {
var direction = null;
if (Math.abs(deltaX) > Math.abs(deltaY)) {
direction = deltaX > 0 ? 'right' : 'left';
} else {
direction = deltaY > 0 ? 'down' : 'up';
}
puzzleManager.moveTile(direction);
isMouseDown = false; // Reset after move
}
};
game.up = function (x, y, obj) {
isMouseDown = false;
if (currentState === GAME_STATE.PLAYING && puzzleManager) {
puzzleManager.selectedTile = null;
}
};
/****
* Main Update Loop
****/
function update() {
// Handle state-specific updates
switch (currentState) {
case GAME_STATE.MENU:
handleMenuLoop();
break;
case GAME_STATE.NEW_ROUND:
handleNewRoundLoop();
break;
case GAME_STATE.PLAYING:
handlePlayingLoop();
break;
case GAME_STATE.SCORE:
handleScoreLoop();
break;
}
// Update water drops
for (var i = waterDrops.length - 1; i >= 0; i--) {
if (waterDrops[i].visible) {
waterDrops[i].update();
}
}
}
function initializeGame() {
gridBoard = LK.getAsset('gridBoard', {
anchorX: 0.5,
anchorY: 0.5
});
gridBoard.x = 2048 / 2;
gridBoard.y = 2732 / 2;
game.addChild(gridBoard);
// Initialize game assets and variables
puzzleManager = new PuzzleManager();
// Initialize level text
levelText = new Text2("Level 1", {
size: 100,
fill: "#ffffff"
});
levelText.x = 2048 / 2;
levelText.y = 200;
levelText.anchorX = 0.5;
// Add the level text to the game
game.addChild(levelText);
// Transition to menu state
changeGameState(GAME_STATE.MENU);
}
// Start the game
initializeGame();
straigth zenith view square light wooden pallet. Single Game Texture. In-Game asset. 2d. Blank background. High contrast. No shadows.
straigth zenith view square wooden pallet with big screws in each corner Single Game Texture. In-Game asset. 2d. Blank background. High contrast. No shadows.
simple yellow rating star. Modern video game style
tileSlide
Sound effect
levelWon
Sound effect
tileBlocked
Sound effect
fountain
Sound effect
waterInPipe
Sound effect
bgMusic
Music
logoBounce
Sound effect
levelStart
Sound effect
bgMusic2
Music
flowerPop
Sound effect
roundResult
Sound effect
gameWon
Sound effect
resetSound
Sound effect
birds
Sound effect
birds2
Sound effect
birds3
Sound effect