/**** * Plugins ****/ var storage = LK.import("@upit/storage.v1"); var tween = LK.import("@upit/tween.v1"); /**** * Classes ****/ var Butterfly = Container.expand(function () { var self = Container.call(this); var butterflyFrames = ['butterfly', 'butterfly2', 'butterfly3', 'butterfly4']; var niceColors = [0xFF5733, 0x33FF57, 0x3357FF, 0xFF33A1, 0x33FFF5, 0xF5FF33]; // List of nice colors var currentFrame = 0; var animationSpeed = 0.4; // Adjust speed as needed var frameCount = 0; // Attach the first frame of the butterfly var butterflyGraphics = []; var selectedColor = niceColors[Math.floor(Math.random() * niceColors.length)]; for (var i = 0; i < butterflyFrames.length; i++) { var graphic = self.attachAsset(butterflyFrames[i], { anchorX: 0.5, anchorY: 0.5, alpha: 0.9, tint: selectedColor, scaleX: 0.4 + Math.random() * 0.2, scaleY: 0.4 + Math.random() * 0.2, visible: i === currentFrame // Only the first frame is visible initially }); butterflyGraphics.push(graphic); } // Update function to animate the butterfly self.update = function () { frameCount += animationSpeed; if (frameCount >= 1) { frameCount = 0; butterflyGraphics[currentFrame].visible = false; // Hide current frame currentFrame = (currentFrame + 1) % butterflyFrames.length; butterflyGraphics[currentFrame].visible = true; // Show next frame } }; return self; }); // Removed the import statement for the tween plugin as it is causing an error var Flower = Container.expand(function (maxIndex, x, y) { var self = Container.call(this); var positionRange = 200; var sizeRatioRange = 50; var popSpeed = 0.05; self.popPlayed = false; var assetId = 'flower' + Math.min(10, Math.floor(Math.random() * maxIndex + 1)); var rand1 = Math.random(); var rand2 = Math.random(); // Define final scale values for the grow effect var finalScaleX = 1 + rand2 * (sizeRatioRange / 100); var finalScaleY = 1 + rand1 * (sizeRatioRange / 100); var randRot = -Math.PI * 0.25 + 0.5 * (rand1 + rand2) * Math.PI * 0.5; var randScaleX = rand1 > 0.5 ? 1 : -1; var flowerShadow = self.attachAsset(assetId, { anchorX: 0.5, anchorY: 0.5, x: 5 + 5 * rand1 + x + (rand1 * positionRange - positionRange / 2), y: 5 + 5 * rand2 + y + (rand2 * positionRange - positionRange / 2), scaleX: finalScaleX * randScaleX, // Start with scale 0 for grow effect scaleY: finalScaleY, // Start with scale 0 for grow effect alpha: 0.5, // Start with alpha 0 for fade-in effect rotation: randRot, // Random rotation tint: 0x222222 }); var flowerGraphics = self.attachAsset(assetId, { anchorX: 0.5, anchorY: 0.5, x: x + (rand1 * positionRange - positionRange / 2), y: y + (rand2 * positionRange - positionRange / 2), scaleX: 0, // Start with scale 0 for grow effect scaleY: 0, // Start with scale 0 for grow effect alpha: 0, // Start with alpha 0 for fade-in effect rotation: randRot }); // Implement fade-in effect by incrementing alpha and grow animation self.update = function () { if (flowerGraphics.alpha < 1) { flowerGraphics.alpha += popSpeed; // Adjust the increment for desired speed } else { flowerGraphics.alpha = 1; } if (Math.abs(flowerGraphics.scaleX) < finalScaleX) { flowerGraphics.scaleX += popSpeed * randScaleX; // Adjust the increment for desired speed } if (flowerGraphics.scaleY < finalScaleY) { flowerGraphics.scaleY += popSpeed; // Adjust the increment for desired speed } else { if (!self.popPlayed) { self.popPlayed = true; LK.setTimeout(function () { LK.getSound('flowerPop').play(); }, 0.5 * (rand1 + rand2) * 500); } } }; return self; }); var RatingStars = Container.expand(function (stars) { var self = Container.call(this); self.starsContainer = new Container(); self.addChild(self.starsContainer); var offset = 450; // Ensure stars is between 1 and 3 stars = Math.max(1, Math.min(stars, 3)); for (var j = 0; j < 3; j++) { var baseTile = self.starsContainer.attachAsset('baseTile', { anchorX: 0.5, anchorY: 0.5, x: j * offset - offset, // Position 1st at x = -400, 2nd at x = 0, 3rd at x = 400 y: 0 }); } for (var i = 0; i < stars; i++) { (function (i) { LK.setTimeout(function () { var starAsset = self.starsContainer.attachAsset('star', { anchorX: 0.5, anchorY: 0.5, x: i * offset - offset, // Adjust spacing as needed scaleX: 0, // Start with scale 0 for grow effect scaleY: 0, // Start with scale 0 for grow effect visible: i < stars // Only show the number of stars specified }); LK.setTimeout(function () { LK.getSound("roundResult").play(); }, 300); // Animate the starAsset to grow from 0 to its final size with easeIn tween(starAsset, { scaleX: 1, scaleY: 1 }, { duration: 400, easing: tween.easeIn }); }, i * 300); })(i); } return self; }); var ResetButton = Container.expand(function () { var self = Container.call(this); var buttonGraphics = self.attachAsset('resetButton', { anchorX: 0.5, anchorY: 0.5 }); self.interactive = true; self.buttonMode = true; self.down = function (x, y, obj) { log("Reset button pressed"); LK.getSound("resetSound").play(); // Reset the game or perform any reset action here puzzleManager.initPuzzle(); }; self.disable = function () { self.alpha = 0.5; self.interactive = false; }; self.enable = function () { self.alpha = 0.9; self.interactive = true; }; 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 = 10; 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 = (150 - self.life) / 150; // 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 ****/ /**** * Global level configurations ****/ var game = new LK.Game({ backgroundColor: 0x000000 }); /**** * Game Code ****/ function updateOverlayLayer() { game.addChildAt(overlayLayer, game.children.length - 1); } function _typeof2(o) { "@babel/helpers - typeof"; return _typeof2 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof2(o); } function _defineProperty2(e, r, t) { return (r = _toPropertyKey2(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; } function _toPropertyKey2(t) { var i = _toPrimitive2(t, "string"); return "symbol" == _typeof2(i) ? i : i + ""; } function _toPrimitive2(t, r) { if ("object" != _typeof2(t) || !t) { return t; } var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof2(i)) { return i; } throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } function playButterflyAnim() { if (!overlayLayer) { return; } // Create a butterfly instance at the right edge of the screen var butterfly = new Butterfly(); butterfly.x = 2048 + 50; // Start slightly off-screen to the right butterfly.y = Math.random() * 2732; // Random vertical position overlayLayer.addChild(butterfly); // Animate the butterfly to move from right to left var targetY = 100 + Math.random() * 2500; // Prepare target Y before tween call var direction = Math.atan2(targetY - butterfly.y, -50 - butterfly.x); // Calculate direction of movement butterfly.rotation = direction + Math.PI; // Rotate butterfly in the direction of the move tween(butterfly, { x: -50, // Move off-screen to the left y: targetY // Use prepared target Y }, { duration: 9000 + Math.random() * 3000, // Random duration between 8 to 11 seconds easing: tween.linear, onFinish: function onFinish() { // Remove the butterfly after animation completes overlayLayer.removeChild(butterfly); } }); } function playPlumesAnim() { if (!overlayLayer) { return; } // Create a plume asset at the right edge of the screen var plume = LK.getAsset('plumes', {}); // Add the plume to the game overlayLayer.addChild(plume); // Animate the plume to move from right to left tween(plume, { x: -50, // Move off-screen to the left, y: 100 + Math.random() * 2500 }, { duration: 8000 + Math.random() * 3000, // Random duration between 5 to 8 seconds easing: tween.linear, onFinish: function onFinish() { // Remove the plume after animation completes game.removeChild(plume); } }); } function playAmbiantSounds() { // Randomly choose between 'birds', 'birds2', and 'birds3' var soundId = ['birds', 'birds2', 'birds3'][Math.floor(Math.random() * 3)]; // Play the chosen sound LK.getSound(soundId).play(); } // Set an interval to play ambient sounds every 5 to 10 seconds LK.setInterval(playAmbiantSounds, 5000 + Math.random() * 10000); // Removed the import statement for the tween plugin as it is causing an error function finalAnimation() { var confettiCount = 200; var confettis = []; var spawnedCount = 0; LK.getSound("gameWon").play(); finalAnimationInterval = LK.setInterval(function () { if (spawnedCount >= confettiCount) { LK.clearInterval(finalAnimationInterval); isFinalAnimationFinished = true; return; } var rand1 = Math.random(); var rand2 = Math.random(); var confetti = LK.getAsset('star', { anchorX: 0.5, anchorY: 0.5, x: rand1 * 2048, y: rand2 * 2000 - 3000, scaleX: 0.25 + Math.random() * 0.75, scaleY: 0.25 + Math.random() * 0.75, rotation: 0.5 * (rand1 + rand2) * Math.PI * 2 }); confettis.push(confetti); game.addChild(confetti); var targetY = 2600; var duration = 2000 + rand1 * 2000; tween(confetti, { y: targetY, rotation: confetti.rotation + Math.PI * 2 }, { duration: duration, easing: tween.easeInOut /* onFinish: function (confetti) { return function () { LK.setTimeout(function () { game.removeChild(confetti); }, 1000); }; }(confetti) */ }); spawnedCount++; var x = rand1 * 2048; var y = 350 + rand2 * (2732 - 750); var flower = new Flower(puzzleManager.currentLevel, x, y); flowers.push(flower); game.addChild(flower); }, 20); LK.setTimeout(function () { game.removeChild(congratsText); var finalResultText = new Text2("All Solved!\nCongratulations!", { size: 250, anchorX: 0.5, fill: 0xFFFFFF, weight: 1000, dropShadow: true, align: 'center' }); finalResultText.x = 50; finalResultText.y = -1300; finalResultText.alpha = 0.9; finalResultText.visible = true; game.addChild(finalResultText); tween(finalResultText, { y: 400 }, { duration: 1000, easing: tween.easeInOut }); }, 2000); LK.setTimeout(function () { var finalResultText2 = new Text2("All Solved!\nCongratulations!", { size: 250, anchorX: 0.5, fill: 0xFFFFFF, alpha: 0, weight: 1000, dropShadow: true, align: 'center' }); finalResultText2.x = 50; finalResultText2.y = 400; finalResultText2.visible = true; game.addChild(finalResultText2); tween(finalResultText2, { alpha: 1 }, { duration: 3000, easing: tween.easeInOut }); }, 7000); } function calculateStarsScore() { log("Calculating stars score..."); // Log the start of the calculation log("Current round moves:", currentRoundMoves); // Log current round moves log("Level minimal moves for current level:", levelMinimalMoves[puzzleManager.currentLevel]); // Log minimal moves for current level if (currentRoundMoves <= levelMinimalMoves[puzzleManager.currentLevel]) { log("Awarding 3 stars"); // Log decision for 3 stars return 3; } else if (currentRoundMoves < levelMinimalMoves[puzzleManager.currentLevel] * 1.66) { log("Awarding 2 stars"); // Log decision for 2 stars return 2; } else { log("Awarding 1 star"); // Log decision for 1 star return 1; } } function assetExists(assetId) { try { LK.getAsset(assetId, {}); return true; } catch (e) { return false; } } function _slicedToArray5(r, e) { return _arrayWithHoles5(r) || _iterableToArrayLimit5(r, e) || _unsupportedIterableToArray5(r, e) || _nonIterableRest5(); } function _arrayWithHoles5(r) { if (Array.isArray(r)) { return r; } } function _iterableToArrayLimit5(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) { return; } f = !1; } else { for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0) { ; } } } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) { return; } } finally { if (o) { throw n; } } } return a; } } function _unsupportedIterableToArray5(r, a) { if (r) { if ("string" == typeof r) { return _arrayLikeToArray5(r, a); } var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray5(r, a) : void 0; } } function _arrayLikeToArray5(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) { n[e] = r[e]; } return n; } function _nonIterableRest5() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) { o = it; } var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) { return { done: true }; } return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) { it["return"](); } } finally { if (didErr) { throw err; } } } }; } /**** * Global level configurations ****/ function _slicedToArray2(r, e) { return _arrayWithHoles2(r) || _iterableToArrayLimit2(r, e) || _unsupportedIterableToArray2(r, e) || _nonIterableRest2(); } function _nonIterableRest2() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } function _unsupportedIterableToArray2(r, a) { if (r) { if ("string" == typeof r) { return _arrayLikeToArray2(r, a); } var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray2(r, a) : void 0; } } function _arrayLikeToArray2(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) { n[e] = r[e]; } return n; } function _iterableToArrayLimit2(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) { return; } f = !1; } else { for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0) { ; } } } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) { return; } } finally { if (o) { throw n; } } } return a; } } function _arrayWithHoles2(r) { if (Array.isArray(r)) { return r; } } function _slicedToArray4(r, e) { return _arrayWithHoles4(r) || _iterableToArrayLimit4(r, e) || _unsupportedIterableToArray4(r, e) || _nonIterableRest4(); } function _nonIterableRest4() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } function _unsupportedIterableToArray4(r, a) { if (r) { if ("string" == typeof r) { return _arrayLikeToArray4(r, a); } var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray4(r, a) : void 0; } } function _arrayLikeToArray4(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) { n[e] = r[e]; } return n; } function _iterableToArrayLimit4(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) { return; } f = !1; } else { for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0) { ; } } } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) { return; } } finally { if (o) { throw n; } } } return a; } } function _arrayWithHoles4(r) { if (Array.isArray(r)) { return r; } } function Tile() { var self = this; Container.call(self); self.type = null; self.fixed = false; self.gridRow = -1; self.gridCol = -1; self.flow = false; self.startFlowTicks = 0; self.baseTint = 0xaaaaaa; self.baseTintLight = 0xaaaaaa; self.maxWaterSize = 270; self.maxWaterCornerSize = 180; self.flowSpeed = 12; self.pipeContainer = new Container(); //self.addChild(self.pipeContainer); self.createStartPipe = function () { self.pipeContainer.attachAsset('startPipeAsset', { anchorX: 0.5, anchorY: 0.5, x: 20, y: 40, tint: self.baseTint }); self.valve = self.pipeContainer.attachAsset('vane', { anchorX: 0.5, anchorY: 0.5, x: 20, y: -8, tint: self.baseTint }); self.water = self.pipeContainer.attachAsset('waterV', { anchorX: 0.5, anchorY: 0, x: -0, y: -120, height: 0, visible: false, dir: '' }); }; self.createEndPipe = function () { self.pipeContainer.attachAsset('endPipeAsset', { anchorX: 0.5, anchorY: 0.5, x: 0, y: 55, tint: self.baseTint }); self.water = self.pipeContainer.attachAsset('waterV', { anchorX: 0.5, anchorY: 0, x: -0, y: -120, height: 0, visible: false, dir: '' }); self.fountain = self.pipeContainer.attachAsset('fontain', { anchorX: 0.5, anchorY: 0.5, x: 0, y: 0, width: 0, height: 0, visible: false }); }; self.createStraightPipe = function (isVertical) { if (isVertical) { self.pipeContainer.attachAsset('straightPipeVAsset', { anchorX: 0.5, anchorY: 0.5, x: -30, tint: self.baseTint }); self.pipeContainer.attachAsset('straightPipeVAsset', { anchorX: 0.5, anchorY: 0.5, scaleX: -1, x: 30, tint: self.baseTint }); self.water = self.pipeContainer.attachAsset('waterV', { anchorX: 0.5, anchorY: 0, x: -0, y: -120, height: 0, visible: false, dir: 'tb' }); } else { self.pipeContainer.attachAsset('straightPipeHAsset', { anchorX: 0.5, anchorY: 0.5, y: -40, tint: self.baseTint }); self.pipeContainer.attachAsset('straightPipeHAsset', { anchorX: 0.5, anchorY: 0.5, scaleY: -1, y: 30, tint: self.baseTint }); self.water = self.pipeContainer.attachAsset('waterH', { anchorX: 0, anchorY: 0.5, x: -130, y: -5, width: 0, visible: false, dir: 'lr' }); } }; self.createCornerPipe = function () { self.pipeContainer.attachAsset('cornerPipeAsset', { anchorX: 0.5, anchorY: 0.5, x: -60, y: -60, tint: self.baseTintLight }); // TODO : Remove self.waterCorner = self.pipeContainer.attachAsset('waterCorner', { anchorX: 1, anchorY: 1, width: 108, height: 108, x: -65, y: -65, rotation: -Math.PI / 2, visible: false, dir: '' }); self.waterV = self.pipeContainer.attachAsset('waterV', { anchorX: 0.5, anchorY: 0, width: 110, x: -120, y: -5, rotation: -Math.PI / 2, height: 0, visible: false, dir: '' }); self.waterH = self.pipeContainer.attachAsset('waterH', { anchorX: 0, anchorY: 0.5, x: -5, y: -50, width: 0, height: 112, rotation: -Math.PI / 2, visible: false, dir: '' }); // TODO : Remove? self.waterCornerCover = self.pipeContainer.attachAsset('waterCorner', { anchorX: 1, anchorY: 1, width: 108, height: 108, x: -65, y: -65, rotation: -Math.PI, visible: false, alpha: 0, dir: '' }); self.pipeContainer.attachAsset('cornerPipeSection', { anchorX: 0.5, anchorY: 0.5, width: 148, height: 148, x: -0, y: -0, tint: self.baseTintLight }); self.pipeContainer.attachAsset('pipeRing', { anchorX: 0.5, anchorY: 0.5, width: 144, height: 30, x: 0, y: -80, rotation: Math.PI * 0, tint: self.baseTintLight }); self.pipeContainer.attachAsset('pipeRing', { anchorX: 0.5, anchorY: 0.5, width: 144, height: 30, x: -80, y: -5, rotation: Math.PI * 0.5, tint: self.baseTintLight }); }; self.createCrossPipe = function () { self.pipeContainer.attachAsset('straightPipeHAsset', { anchorX: 0.5, anchorY: 0.5, y: -40, tint: self.baseTint }); self.pipeContainer.attachAsset('straightPipeHAsset', { anchorX: 0.5, anchorY: 0.5, scaleY: -1, y: 30, tint: self.baseTint }); self.pipeContainer.attachAsset('straightPipeVAsset', { anchorX: 0.5, anchorY: 0.5, x: -30, tint: self.baseTint }); self.pipeContainer.attachAsset('straightPipeVAsset', { anchorX: 0.5, anchorY: 0.5, scaleX: -1, x: 30, tint: self.baseTint }); self.water = self.pipeContainer.attachAsset('waterV', { anchorX: 0.5, anchorY: 0, x: -0, y: -120, height: 0, visible: false, dir: '' }); }; self.setType = function (type, row, col, fixed) { self.type = type; self.gridRow = row; self.gridCol = col; // Add base tile last so it appears under the pipes var baseTileAsset = fixed ? 'baseTile' : 'baseMobileTile'; log("setType : setting baseTile..."); self.baseTile = self.attachAsset(baseTileAsset, { anchorX: 0.5, anchorY: 0.5, width: tileSize, height: tileSize, tint: 0xFFFFFF }); self.addChild(self.pipeContainer); // Clear existing pipe graphics while (self.pipeContainer.children.length > 0) { self.pipeContainer.removeChildAt(0); } // Create pipe graphics based on type switch (type) { case TileFormat.TYPES.START: self.createStartPipe(); break; case TileFormat.TYPES.END: self.createEndPipe(); break; case TileFormat.TYPES.VERTICAL: self.createStraightPipe(true); break; case TileFormat.TYPES.HORIZONTAL: self.createStraightPipe(false); break; case TileFormat.TYPES.CORNER: self.createCornerPipe(); break; case TileFormat.TYPES.CROSS: self.createCrossPipe(); break; } }; self.getNextPositions = function (col, row, rotation, type, incomingDirection) { var positions = []; log("Getting next position for tile at", row, col, "type:", type, "rotation:", rotation, "incoming direction:", incomingDirection); //, "normalizedIncoming::", normalizedIncoming); switch (type) { case TileFormat.TYPES.START: // Start pipe flows in direction of rotation var dx = -Math.sin(rotation); var dy = Math.cos(rotation); positions.push([col + Math.round(dx), row + Math.round(dy)]); log("START: flowing in direction dx:", dx, "dy:", dy); break; case TileFormat.TYPES.VERTICAL: // For vertical pipes, we flow in the opposite direction of incoming // If water comes from top (π/2), we flow down // If water comes from bottom (3π/2), we flow up if (Math.abs(incomingDirection - 3 * Math.PI / 2) < 0.1) { positions.push([col, row + 1]); // Flow down log("VERTICAL: incoming from top, flowing down"); } else if (Math.abs(incomingDirection - Math.PI / 2) < 0.1) { positions.push([col, row - 1]); // Flow up log("VERTICAL: incoming from bottom, flowing up"); } else if (incomingDirection === 0) { // Initial flow from start - flow down positions.push([col, row + 1]); log("VERTICAL: initial flow, going down"); } break; case TileFormat.TYPES.HORIZONTAL: // For horizontal pipes, we flow in the opposite direction of incoming // If water comes from left (0), we flow right // If water comes from right (π), we flow left if (Math.abs(incomingDirection) < 0.1) { positions.push([col + 1, row]); // Flow right log("HORIZONTAL: incoming from left, flowing right"); } else if (Math.abs(incomingDirection - Math.PI) < 0.1 || incomingDirection === 0) { positions.push([col - 1, row]); // Flow left log("HORIZONTAL: incoming from right, flowing left"); } else { log("ERROR HORIZONTAL: incoming not matching!"); } break; case TileFormat.TYPES.CORNER: var outgoingDirection; var normalizedRotation = (rotation + Math.PI / 2) % (2 * Math.PI); log("CORNER PIPE with rotation:", rotation, " normalized rotation:", normalizedRotation, " with incoming:", incomingDirection); log("sin(rotation)=", Math.sin(rotation)); var isSinRot = !(Math.abs(Math.sin(rotation)) < 0.1); var acceptAngle1 = isSinRot ? rotation + Math.PI / 2 : rotation; var acceptAngle2 = isSinRot ? rotation + Math.PI : rotation - Math.PI / 2; acceptAngle1 = (2 * Math.PI + acceptAngle1) % (2 * Math.PI); acceptAngle2 = (2 * Math.PI + acceptAngle2) % (2 * Math.PI); log("Checking if incoming match pipe entry:", acceptAngle1, " or ", acceptAngle2, " vs ", incomingDirection); if (Math.abs(incomingDirection - acceptAngle1) < 0.1) { outgoingDirection = acceptAngle2 + Math.PI; } if (Math.abs(incomingDirection - acceptAngle2) < 0.1) { outgoingDirection = acceptAngle1 + Math.PI; } log("CORNER: turning from", incomingDirection, "to", outgoingDirection); if (outgoingDirection !== undefined) { // Convert angle to grid movement var dx = Math.round(Math.cos(outgoingDirection)); var dy = -Math.round(Math.sin(outgoingDirection)); positions.push([col + dx, row + dy]); log("CORNER: moving dx:", dx, "dy:", dy); } else { log("ERROR CORNER: incoming not matching!"); } break; case TileFormat.TYPES.END: // End tile doesn't flow anywhere log("END: no next position"); break; } log("Final next positions:", positions); return positions; }; self.normalizeRotation = function (rotation) { while (rotation < 0) { rotation += 2 * Math.PI; } return rotation % (2 * Math.PI); }; self.setRotation = function (rot, rotation) { if (typeof rotation === 'number') { self.pipeContainer.rot = rot; self.pipeContainer.rotation = self.normalizeRotation(rotation); //* Math.PI / 2 DBO } else { // Handle string rotations (legacy support) switch (rotation) { case 'up': self.pipeContainer.rotation = 0; break; case 'right': self.pipeContainer.rotation = Math.PI / 2; break; case 'down': self.pipeContainer.rotation = Math.PI; break; case 'left': self.pipeContainer.rotation = 3 * Math.PI / 2; break; } } }; self.updatePosition = function (row, col) { self.gridRow = row; self.gridCol = col; self.x = col * tileSize + gridBoard.x - gridBoard.width / 2 + tileSize / 2 + boardOffsetX; self.y = row * tileSize + gridBoard.y - gridBoard.height / 2 + tileSize / 2 + boardOffsetY; log('Tile row,col:', row, col, 'Tile position:', self.x, self.y, 'Tile dimensions:', self.width, self.height, ' self:', self); //log('pipeContainer:', self.pipeContainer.x, self.pipeContainer.y, ' child:', self.pipeContainer.children[0].x, self.pipeContainer.children[0].y); //log('gridBoard :', gridBoard.x, gridBoard.y, ' size:', gridBoard.width, gridBoard.height); }; // Water flow update methods self.updateStartTile = function () { if (self.valve) { var rotationValue = (LK.ticks - self.startFlowTicks) * 0.1; self.valve.rotation = rotationValue; if (rotationValue >= Math.PI * 3) { self.flow = false; } } }; self.updateEndTile = function () { if (self.fountain) { var sizeValue = (LK.ticks - self.startFlowTicks) * self.flowSpeed; if (sizeValue < self.maxWaterSize) { self.fountain.width = sizeValue; self.fountain.height = sizeValue; if (!self.fountain.visible) { self.fountain.visible = true; LK.getSound('fountain').play(); } } else { self.flow = false; if (!waterDropInterval) { createWaterDrops(self.x, self.y + 100, game); waterDropInterval = LK.setInterval(function () { createWaterDrops(self.x, self.y + 100, game); }, 250 + Math.random() * 250); } } } }; self.updateRegularPipe = function () { if (self.water) { var heightValue = (LK.ticks - self.startFlowTicks) * self.flowSpeed; if (heightValue < self.maxWaterSize) { //log("updateRegularPipe ", self.water.dir, self.rotation, self.pipeContainer.rotation, self); self.water.visible = true; if (self.water.dir === 'lr') { self.water.width = heightValue; self.water.x = -130; self.water.scaleX = 1; } else if (self.water.dir === 'rl') { self.water.width = heightValue; self.water.x = 130; self.water.scaleX = -1; } else if (self.water.dir === 'tb') { self.water.height = heightValue; self.water.y = -130; self.water.scaleY = 1; } else if (self.water.dir === 'bt') { log("=> bt", self.rotation, self.pipeContainer.rotation, self); self.water.height = heightValue; self.water.y = 130; self.water.scaleY = -1; } else { self.water.height = heightValue; } } else { self.flow = false; } } }; self.getFlowOrder = function (rot, dir) { // Specific function take rotation (x4) + dir(x4) => order (rot + dir + => final order) log("getFlowOrder rot=", rot, " / dir=", dir); var normalOrder = true; switch (rot) { case 0: normalOrder = dir == 'tb' ? false : true; break; case 1: normalOrder = dir == 'rl' ? false : true; break; case 2: normalOrder = dir == 'rl' ? true : false; break; case 3: normalOrder = dir == 'bt' ? true : false; break; default: log("ERROR in getFlowOrder : Unknown rotation ", rot); } return normalOrder; }; self.updateCornerPipe = function () { var progress = (LK.ticks - self.startFlowTicks) * self.flowSpeed; var thirdSize = self.maxWaterCornerSize / 3; var normalOrder = self.getFlowOrder(self.pipeContainer.rot, self.pipeContainer.dir); log("updateCornerPipe: Choosing order for tile:", self.pipeContainer.rotation, self.pipeContainer.dir); if (progress < thirdSize) { // 0 or PI/2 if (normalOrder) { self.updateCornerPipeVerticalPart(progress, thirdSize, false); } else { self.updateCornerPipeHorizontalPart(progress, thirdSize, true); } } else if (progress > thirdSize * 2 && progress < thirdSize * 3) { // 0 or PI/2 if (normalOrder) { self.updateCornerPipeHorizontalPart(progress, thirdSize, false); } else { self.updateCornerPipeVerticalPart(progress, thirdSize, true); } } if (progress >= self.maxWaterCornerSize) { self.flow = false; } }; self.getCornerVerticalAnimWay = function (rot, dir) { // Specific function take rotation (x4) + dir(x4) => way (true = exterior => interior / false = interior exterior) log("get Corner Vert Anim rot=", rot, " / dir=", dir); var normalWay = true; switch (rot) { case 0: normalWay = dir == 'tb' ? false : true; break; case 1: normalWay = dir == 'rl' ? false : true; break; case 2: normalWay = dir == 'bt' ? false : true; break; case 3: normalWay = dir == 'lr' ? false : true; break; default: log("ERROR in getCornerVerticalAnimWay : Unknown rotation ", rot); } return normalWay; }; self.updateCornerPipeVerticalPart = function (progress, thirdSize, reverted) { // Specific function take rotation (x4) + dir(x4) => revertedV (Log x,y + rot + dir + => final) if (!self.waterV) { return; } var currentProgress = reverted ? progress - thirdSize * 2 : progress; var normalWay = self.getCornerVerticalAnimWay(self.pipeContainer.rot, self.pipeContainer.dir); log("updateCornerPipeVerticalPart: normal way:", normalWay); log("updateCornerPipeVerticalPart: Updated waterV height to:", currentProgress); if (normalWay) { //self.waterV.tint = 0x0000FF; } else { //self.waterV.tint = 0x00FF00; self.waterV.y = -7; self.waterV.x = -80; self.waterV.rotation = Math.PI / 2; } self.waterV.visible = true; self.waterV.height = currentProgress; }; self.getCornerHorizontalAnimWay = function (rot, dir) { // Specific function take rotation (x4) + dir(x4) => way (true = exterior => interior / false = interior exterior) log("get Corner Horiz Anim rot=", rot, " / dir=", dir); var normalWay = true; switch (rot) { case 0: normalWay = dir == 'lr' ? false : true; // dir == 'tb' || break; case 1: normalWay = dir == 'tb' ? false : true; //dir == 'rl' || break; case 2: normalWay = dir == 'bt' ? true : false; break; case 3: normalWay = dir == 'lr' ? true : false; break; default: log("ERROR in getCornerHorizontalAnimWay : Unknown rotation ", rot); } return normalWay; }; self.updateCornerPipeHorizontalPart = function (progress, thirdSize, reverted) { if (!self.waterH) { return; } var currentProgress = reverted ? progress : progress - thirdSize * 2; var normalWay = self.getCornerHorizontalAnimWay(self.pipeContainer.rot, self.pipeContainer.dir); log("Upd Corner H: normal way:", normalWay); log("Upd Corner H: Updated waterH width to:", currentProgress, " reverted=", reverted); if (normalWay) { //self.waterH.tint = 0xF050A0; if (self.pipeContainer.rot == 0) { self.waterH.y = -140; self.waterH.x = -5; self.waterH.rotation = -Math.PI / 2; } if (self.pipeContainer.rot == 1) { self.waterH.y = -140; self.waterH.x = -5; self.waterH.rotation = -Math.PI / 2; } if (self.pipeContainer.rot == 2) { self.waterH.y = -140; self.waterH.x = -5; self.waterH.rotation = -Math.PI / 2; } if (self.pipeContainer.rot == 3) { self.waterH.y = -140; self.waterH.x = -5; self.waterH.rotation = Math.PI / 2; } } else { //self.waterH.tint = 0xFF0000; if (self.pipeContainer.rot == 1) { self.waterH.y = -90; self.waterH.x = -3; self.waterH.rotation = Math.PI / 2; } if (self.pipeContainer.rot == 0) { self.waterH.y = -90; self.waterH.x = -3; self.waterH.rotation = -Math.PI / 2; } if (self.pipeContainer.rot == 2) { self.waterH.y = -90; self.waterH.x = -3; self.waterH.rotation = Math.PI / 2; } if (self.pipeContainer.rot == 3) { self.waterH.y = -90; self.waterH.x = -3; self.waterH.rotation = Math.PI / 2; } } log("Upd Corner H: waterH position x:", self.waterH.x, "y:", self.waterH.y, "dir:", self.waterH.dir); self.waterH.visible = true; self.waterH.width = currentProgress; }; 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; } } switch (self.type) { case TileFormat.TYPES.START: self.updateStartTile(); break; case TileFormat.TYPES.END: self.updateEndTile(); break; case TileFormat.TYPES.CORNER: self.updateCornerPipe(); break; default: self.updateRegularPipe(); break; } } // Animate end tile fountain if (self.type === TileFormat.TYPES.END && self.fountain && self.fountain.visible) { self.fountain.rotation += 0.1; var sizeVariation = 30 * Math.sin(LK.ticks * 0.1); self.fountain.width = 250 + sizeVariation; self.fountain.height = 250 + sizeVariation; } }; } Tile.prototype = Object.create(Container.prototype); function _slicedToArray3(r, e) { return _arrayWithHoles3(r) || _iterableToArrayLimit3(r, e) || _unsupportedIterableToArray3(r, e) || _nonIterableRest3(); } function _nonIterableRest3() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } function _unsupportedIterableToArray3(r, a) { if (r) { if ("string" == typeof r) { return _arrayLikeToArray3(r, a); } var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray3(r, a) : void 0; } } function _arrayLikeToArray3(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) { n[e] = r[e]; } return n; } function _iterableToArrayLimit3(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) { return; } f = !1; } else { for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0) { ; } } } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) { return; } } finally { if (o) { throw n; } } } return a; } } function _arrayWithHoles3(r) { if (Array.isArray(r)) { return r; } } function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); } function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; } function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; } function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) { return t; } var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) { return i; } throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); } function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) { return _arrayLikeToArray(r, a); } var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } } function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) { n[e] = r[e]; } return n; } function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) { return; } f = !1; } else { for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0) { ; } } } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) { return; } } finally { if (o) { throw n; } } } return a; } } function _arrayWithHoles(r) { if (Array.isArray(r)) { return r; } } var SimpleSet = function SimpleSet() { this.items = {}; this.has = function (item) { return this.items.hasOwnProperty(item); }; this.add = function (item) { if (!this.has(item)) { this.items[item] = true; } }; }; var PuzzleManager = function PuzzleManager(game) { var self = this; self.game = game; self.grid = []; self.gridSize = 4; self.selectedTile = null; self.isComplete = false; self.waterFlowing = false; self.solutionPath = null; // Store the solution path for water flow self.reset = function () { // Clear grid for (var row = 0; row < self.gridSize; row++) { if (!self.grid[row]) { self.grid[row] = []; } for (var col = 0; col < self.gridSize; col++) { if (self.grid[row][col]) { self.grid[row][col].destroy(); } self.grid[row][col] = null; } } // Reset state self.selectedTile = null; // Remove all flowers for (var i = flowers.length - 1; i >= 0; i--) { if (flowers[i].parent) { flowers[i].parent.removeChild(flowers[i]); } } flowers = []; self.waterFlowing = false; // Clear water drops if (waterDropInterval) { LK.clearInterval(waterDropInterval); waterDropInterval = null; } // Reset water particles if (game.waterParticles) { for (var i = game.waterParticles.length - 1; i >= 0; i--) { var particle = game.waterParticles[i]; if (particle && particle.parent) { particle.parent.removeChild(particle); } } game.waterParticles = []; } currentRoundMoves = 0; if (self.isComplete) { self.currentLevel++; storage.currentLevel = self.currentLevel; // Store current level in storage } else { self.currentLevel = storage.currentLevel || (debug && levelConfigs[0] ? 0 : 1); //self.currentLevel = debug ? 0 : self.currentLevel; } self.isComplete = false; }; self.initPuzzle = function () { self.reset(); var level = levelConfigs[self.currentLevel]; if (!level) { log("Next Level not found:", self.currentLevel); changeGameState(GAME_STATE.SCORE); return; } resetButton.visible = true; resetButton.disable(); // Initialize grid with tiles from level configuration for (var row = 0; row < self.gridSize; row++) { self.grid[row] = []; for (var col = 0; col < self.gridSize; col++) { var tileStr = level[row][col]; var tile = createTile(tileStr, row, col); if (tile) { //gridBoard.addChild(tile); game.addChild(tile); self.grid[row][col] = tile; } } } updateOverlayLayer(); }; self.checkWinCondition = function () { log("=== Starting Win Condition Check ==="); log("Grid state:"); for (var row = 0; row < self.gridSize; row++) { var rowStr = []; for (var col = 0; col < self.gridSize; col++) { var tile = self.grid[row][col]; if (tile) { var rotIndex = TileFormat.getRotationIndex(tile.normalizeRotation(tile.pipeContainer.rotation)); rowStr.push("".concat(tile.fixed ? 'F' : 'M', "-").concat(tile.type, "-").concat(rotIndex)); } else { rowStr.push('empty'); } } log("Row ".concat(row, ":"), rowStr.join(' | ')); } // Find start tile var startTile = null; var startRow = -1, startCol = -1; for (var row = 0; row < self.gridSize; row++) { for (var col = 0; col < self.gridSize; col++) { if (self.grid[row][col] && self.grid[row][col].type === TileFormat.TYPES.START) { startTile = self.grid[row][col]; startRow = row; startCol = col; break; } } if (startTile) { break; } } if (!startTile) { log("No start tile found!"); return false; } log("Found start tile at row:", startRow, "col:", startCol); var visited = new SimpleSet(); var startDir = getFlowDirection(startTile); var toCheck = [[startRow, startCol, startDir]]; var pathMap = {}; // Store the path for each visited position // Store start position pathMap[startRow + "," + startCol] = { row: startRow, col: startCol, flowDirection: null, // Start doesn't have incoming //startDir, prevKey: null }; while (toCheck.length > 0) { var _toCheck$pop = toCheck.pop(), _toCheck$pop2 = _slicedToArray2(_toCheck$pop, 3), row = _toCheck$pop2[0], col = _toCheck$pop2[1], flowDirection = _toCheck$pop2[2]; var key = "".concat(row, ",").concat(col); if (visited.has(key)) { continue; } visited.add(key); log("======================= Checking position - row:", row, "col:", col, "========================="); // Store current position in path map //pathMap.set(key, { row, col, flowDirection }); // Check if coordinates are within grid if (row < 0 || row >= self.gridSize || col < 0 || col >= self.gridSize) { log("Position out of bounds"); continue; } var currentTile = self.grid[row][col]; if (!currentTile) { log("No tile at position"); continue; } var normalizedRotation = currentTile.normalizeRotation(currentTile.pipeContainer.rotation); log("Checking tile:", currentTile.type, "rotation:", TileFormat.getRotationIndex(normalizedRotation)); if (currentTile.type == TileFormat.TYPES.START) { flowDirection = null; // Start doesn't have incoming flow } var nextPositions = currentTile.getNextPositions(col, row, normalizedRotation, currentTile.type, flowDirection); log("Next positions to check:", nextPositions); var _iterator = _createForOfIteratorHelper(nextPositions), _step; try { for (_iterator.s(); !(_step = _iterator.n()).done;) { var nextPos = _step.value; var _nextPos = nextPos, _nextPos2 = _slicedToArray2(_nextPos, 2), nextCol = _nextPos2[0], nextRow = _nextPos2[1]; log("Trying next position - row:", nextRow, "col:", nextCol); if (nextRow < 0 || nextRow >= self.gridSize || nextCol < 0 || nextCol >= self.gridSize) { log("Next position out of bounds"); continue; } var nextTile = self.grid[nextRow][nextCol]; if (!nextTile) { log("No tile at next position"); continue; } var incomingDirection = Math.atan2(nextRow - row, col - nextCol); if (!canAcceptFlowFromDirection(nextTile, incomingDirection)) { log("Tile at row:", nextRow, "col:", nextCol, "cannot accept flow from direction:", incomingDirection); continue; } log("== OK. Prepare next tile with previous tile at ", incomingDirection, " (", nextRow, row, nextCol, col, ")"); // Update nextTile.water.dir depending on incomingDirection if (nextTile.water) { log("Updating water direction for tile at row:", nextRow, "col:", nextCol); if (nextTile.type === TileFormat.TYPES.VERTICAL) { if (Math.abs(incomingDirection - Math.PI / 2) < 0.1) { nextTile.water.dir = 'tb'; // Top to Bottom log("Set water direction to 'tb' (Top to Bottom)"); } else { //if (Math.abs(incomingDirection - 3 * Math.PI / 2) < 0.1) nextTile.water.dir = 'bt'; // Bottom to Top log("Set water direction to 'bt' (Bottom to Top)"); } } else if (nextTile.type === TileFormat.TYPES.HORIZONTAL) { if (Math.abs(incomingDirection - Math.PI) < 0.1) { nextTile.water.dir = 'lr'; // Left to Right log("Set water direction to 'lr' (Left to Right)"); } else { // if (Math.abs(incomingDirection) < 0.1) nextTile.water.dir = 'rl'; // Right to Left log("Set water direction to 'rl' (Right to Left)"); } } } if (nextTile.type === TileFormat.TYPES.CORNER) { // For corner store water dir in pipeContainer if (Math.abs(incomingDirection - Math.PI / 2) < 0.1) { nextTile.pipeContainer.dir = 'tb'; // Top to Bottom log("Set Corner water direction to 'tb' (Top to Bottom)"); } else if (Math.abs(incomingDirection + Math.PI / 2) % (2 * Math.PI) < 0.1) { nextTile.pipeContainer.dir = 'bt'; // Bottom to Top log("Set Corner water direction to 'bt' (Bottom to Top)"); } else if (Math.abs(incomingDirection - Math.PI) < 0.1) { nextTile.pipeContainer.dir = 'lr'; // Left to Right log("Set Corner water direction to 'lr' (Left to Right)"); } else { nextTile.pipeContainer.dir = 'rl'; // Right to Left log("Set Corner water direction to 'rl' (Right to Left)"); } } if (nextTile.type === TileFormat.TYPES.END) { log("Found path to end!"); // Start reconstruction from the end position self.solutionPath = []; // Add all tiles from pathMap to solution path Object.keys(pathMap).forEach(function (key) { var _key$split$map = key.split(",").map(Number), _key$split$map2 = _slicedToArray5(_key$split$map, 2), row = _key$split$map2[0], col = _key$split$map2[1]; var tile = self.grid[row][col]; if (tile) { self.solutionPath.push({ row: row, col: col, flowDirection: tile.normalizeRotation(tile.pipeContainer.rotation), tile: tile }); log("Added tile from pathMap:", row, col); } }); // Add the end tile self.solutionPath.push({ row: nextRow, col: nextCol, flowDirection: nextTile.normalizeRotation(nextTile.pipeContainer.rotation), tile: nextTile }); log("Added end tile:", nextRow, nextCol); log("Solution path reconstructed with", self.solutionPath.length, "tiles"); return true; } //var nextFlowDirection = getFlowDirection(nextTile, incomingDirection); var nextFlowDirection = getFlowDirection(currentTile, flowDirection); // incomingDirection); var nextKey = nextRow + "," + nextCol; log("Set next tile ", nextKey, " flow dir:", nextFlowDirection); toCheck.push([nextRow, nextCol, nextFlowDirection]); pathMap[nextKey] = { row: nextRow, col: nextCol, flowDirection: nextFlowDirection, prevKey: key }; } } catch (err) { _iterator.e(err); } finally { _iterator.f(); } } log("No valid path found"); return false; }; self.selectTile = function (x, y) { if (!isPlaying) { return; } // Convert screen coordinates to grid coordinates var boardX = gridBoard.x - gridBoard.width / 2 + boardOffsetX; var boardY = gridBoard.y - gridBoard.height / 2 + boardOffsetY; var row = Math.floor((y - boardY) / tileSize); var col = Math.floor((x - boardX) / tileSize); log("Click at ", x, ",", y, " => Grid coordinates - row:", row, "col:", col); // Check if coordinates are within grid if (row >= 0 && row < this.gridSize && col >= 0 && col < this.gridSize) { var tile = this.grid[row][col]; log("Clicked tile ", tile); // Check if tile exists, is mobile, and not start/end if (tile && !tile.fixed && tile.type !== TileFormat.TYPES.START && tile.type !== TileFormat.TYPES.END) { this.selectedTile = { row: row, col: col, tile: tile }; log("Selected tile row:", this.selectedTile.row, "col:", this.selectedTile.col, this.selectedTile.tile); // Check possible moves this.checkPossibleMoves(); } } // If no tile is found, search nearby tiles using tapOffset if (!this.selectedTile) { var nearbyOffsets = [{ dx: tapOffset, dy: 0 }, { dx: -tapOffset, dy: 0 }, { dx: 0, dy: tapOffset }, { dx: 0, dy: -tapOffset }]; for (var _i = 0, _nearbyOffsets = nearbyOffsets; _i < _nearbyOffsets.length; _i++) { var offset = _nearbyOffsets[_i]; var nearbyRow = Math.floor((y - boardY + offset.dy) / tileSize); var nearbyCol = Math.floor((x - boardX + offset.dx) / tileSize); if (nearbyRow >= 0 && nearbyRow < this.gridSize && nearbyCol >= 0 && nearbyCol < this.gridSize) { var nearbyTile = this.grid[nearbyRow][nearbyCol]; if (nearbyTile && !nearbyTile.fixed && nearbyTile.type !== TileFormat.TYPES.START && nearbyTile.type !== TileFormat.TYPES.END) { this.selectedTile = { row: nearbyRow, col: nearbyCol, tile: nearbyTile }; log("Selected nearby tile row:", this.selectedTile.row, "col:", this.selectedTile.col, this.selectedTile.tile); this.checkPossibleMoves(); break; } } } } }; self.checkPossibleMoves = function () { if (!this.selectedTile) { return; } var row = this.selectedTile.row; var col = this.selectedTile.col; var possibleMoves = []; // Check each direction // Right if (col < this.gridSize - 1 && !this.grid[row][col + 1]) { possibleMoves.push('right'); } // Left if (col > 0 && !this.grid[row][col - 1]) { possibleMoves.push('left'); } // Down if (row < this.gridSize - 1 && !this.grid[row + 1][col]) { possibleMoves.push('down'); } // Up if (row > 0 && !this.grid[row - 1][col]) { possibleMoves.push('up'); } this.selectedTile.possibleMoves = possibleMoves; }; self.moveTile = function (direction) { if (!isPlaying || !this.selectedTile || !this.selectedTile.possibleMoves.includes(direction)) { LK.getSound('tileBlocked').play(); log("Invalid move attempt in direction:", direction); return; } currentRoundMoves++; resetButton.enable(); var oldRow = this.selectedTile.row; var oldCol = this.selectedTile.col; var newRow = oldRow; var newCol = oldCol; // Calculate new position switch (direction) { case 'right': newCol++; break; case 'left': newCol--; break; case 'down': newRow++; break; case 'up': newRow--; break; } // Play tile slide sound LK.getSound('tileSlide').play(); // Move tile with tween animation var movingTile = this.grid[oldRow][oldCol]; this.grid[oldRow][oldCol] = null; this.grid[newRow][newCol] = movingTile; // Use tween to animate the tile movement tween(movingTile, { x: newCol * tileSize + gridBoard.x - gridBoard.width / 2 + tileSize / 2 + boardOffsetX, y: newRow * tileSize + gridBoard.y - gridBoard.height / 2 + tileSize / 2 + boardOffsetY }, { duration: 300, easing: tween.easeInOut, onFinish: function onFinish() { // Update tile position after animation completes movingTile.updatePosition(newRow, newCol); } }); // Clear selection this.selectedTile = null; // Check if puzzle is solved if (this.checkWinCondition()) { this.isComplete = true; resetButton.disable(); isPlaying = false; isGameFinished = puzzleManager.currentLevel == nbLevels; // || debug && puzzleManager.currentLevel == 1; LK.setTimeout(function () { puzzleManager.startWaterFlow(); LK.getSound('levelWon').play(); }, 300); } }; self.startWaterFlow = function () { if (!self.solutionPath || self.solutionPath.length === 0) { log("No solution path available!"); return false; } // Reset any existing flow states for (var row = 0; row < self.gridSize; row++) { for (var col = 0; col < self.gridSize; col++) { if (self.grid[row][col]) { self.grid[row][col].flow = false; if (self.grid[row][col].water) { self.grid[row][col].water.visible = false; } if (self.grid[row][col].waterV) { self.grid[row][col].waterV.visible = false; } if (self.grid[row][col].waterH) { self.grid[row][col].waterH.visible = false; } } } } self.waterFlowing = true; log("Starting water flow through solution path:", self.solutionPath.length, "tiles"); var currentIndex = 0; waterFlowReachedEnd = false; function animateNextTile() { if (currentIndex >= self.solutionPath.length) { // End of path reached - start end game sequence LK.setTimeout(function () { animateSoil(); }, 300); return; } var currentTile = self.solutionPath[currentIndex].tile; currentTile.flow = true; // Show appropriate water animation based on tile type if (currentTile.water) { currentTile.water.visible = true; } if (currentTile.waterV) { currentTile.waterV.visible = true; } if (currentTile.waterH) { currentTile.waterH.visible = true; // Set water flow direction based on path if (currentIndex > 0) { var prevTile = self.solutionPath[currentIndex - 1].tile; currentTile.waterH.scaleX = prevTile.gridCol < currentTile.gridCol ? 1 : -1; } } // Special handling for start tile if (currentTile.type === TileFormat.TYPES.START) { LK.getSound('waterInPipe').play(); var waterFlowSoundInterval = LK.setInterval(function () { if (!waterFlowReachedEnd) { LK.getSound('waterInPipe').play(); } else { LK.clearInterval(waterFlowSoundInterval); } }, 2000); } // Special handling for end tile if (currentTile.type === TileFormat.TYPES.END) { waterFlowReachedEnd = true; createWaterDrops(currentTile.x, currentTile.y + 100, game); } currentIndex++; LK.setTimeout(animateNextTile, 400); } // Start the animation animateNextTile(); return true; }; return this; }; /**** * Game Variables ****/ var debug = false; function log() { if (debug) { console.log.apply(console, arguments); } } // Game constants var tileSize = 400; var boardOffsetX = 100; 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 backgroundLayer; var backgroundImage1; var backgroundImage2; var middleLayer; var frontLayer; var overlayLayer; var gridBoard; var gridBoardSoil; var gridBoardSoilOffset = 20; var growGrass; var growGrassOffsetX = 20; var isMouseDown = false; var startX = 0; var startY = 0; var selectedTile = null; var dragThreshold = 100; // Lower threshold for easier movement detection var tapOffset = 50; // Offset for searching nearby tiles when no tile is found var levelText; var levelTextXOffset = -50; var resetButton; var congratsText; var congratsTextOffset = 300; var nbMovesText; var nbMovesTextOffset = 800; var waterDrops = []; var flowers = []; var waterDropInterval; var waterFlowReachedEnd = false; var logo; var logoShadow; var logoMaze; var logoMazeShadow; var puzzleManager; var isLogoAnimInFinished = false; var isLogoAnimOutFinished = false; var isRoundExitAnimFinished = false; var isGameFinished = false; var isFinalAnimationFinished = false; var finalAnimationInterval; var currentRoundMoves = 0; var congratsMessages = { 1: "Well Done!", 2: "Great Job!", 3: "Marvelous!" }; // Initialize the game initializeGame(); /**** * Helper Functions ****/ function getFlowDirection(tile, incomingDirection) { //var rotation = tile.normalizeRotation(tile.pipeContainer.rotation); var flowDir; //(incomingDirection + Math.PI) % (2 * Math.PI); log("Get Output flow dir:", tile.type, "Rotation:", tile.pipeContainer.rotation, "incomingDirection:", incomingDirection); //, "Normalized incoming:", rotation); switch (tile.type) { case TileFormat.TYPES.START: log("Start detail: ", Math.PI * 2, " + ", tile.pipeContainer.rotation, " + ", Math.PI / 2, " * (", Math.abs(Math.sin(tile.pipeContainer.rotation)), " - ", Math.abs(Math.cos(tile.pipeContainer.rotation)), ")"); flowDir = Math.PI * 2 + tile.pipeContainer.rotation + Math.PI / 2 * (Math.abs(Math.sin(tile.pipeContainer.rotation)) - Math.abs(Math.cos(tile.pipeContainer.rotation))); break; case TileFormat.TYPES.CORNER: if (Math.abs(tile.pipeContainer.rotation - incomingDirection) < 0.1 || Math.abs((tile.pipeContainer.rotation + Math.PI) % (2 * Math.PI) - incomingDirection) < 0.1) { flowDir = incomingDirection + Math.PI / 2; } else { flowDir = incomingDirection - Math.PI / 2; } break; default: flowDir = incomingDirection; // + Math.PI; // From side to oposite side break; } flowDir = (2 * Math.PI + flowDir) % (2 * Math.PI); log("Returned output flow direction:", flowDir); return flowDir; } function canAcceptFlowFromDirection(tile, incomingDirection) { var normalizedIncoming = (incomingDirection + Math.PI) % (2 * Math.PI); var tileRotation = tile.normalizeRotation(tile.pipeContainer.rotation); log("Checking if tile can accept flow. Tile type:", tile.type, "Tile rotation:", tileRotation, " previous tile at:", incomingDirection, " => Incoming flow dir:", normalizedIncoming); var angleDiff = null; switch (tile.type) { case TileFormat.TYPES.START: log("No => Tile type is START. Cannot accept flow."); return false; case TileFormat.TYPES.END: angleDiff = Math.abs(normalizedIncoming - tileRotation + (Math.abs(Math.sin(tileRotation)) - Math.abs(Math.cos(tileRotation))) * Math.PI / 2) % (2 * Math.PI); log("Yes => Tile type is END.", angleDiff, angleDiff < 0.1); return angleDiff < 0.1; case TileFormat.TYPES.VERTICAL: angleDiff = Math.abs(normalizedIncoming - Math.PI / 2) % (2 * Math.PI); log("Yes => Tile type is VERTICAL"); return angleDiff < 0.1 || Math.abs(angleDiff - Math.PI) < 0.1; case TileFormat.TYPES.HORIZONTAL: angleDiff = normalizedIncoming % (2 * Math.PI); log("Yes => Tile type is HORIZONTAL"); return angleDiff < 0.1 || Math.abs(angleDiff - Math.PI) < 0.1; case TileFormat.TYPES.CORNER: angleDiff = (normalizedIncoming - tileRotation - Math.PI) % (2 * Math.PI); log("Yes => Tile type is CORNER."); return angleDiff < 0.1 || Math.abs(angleDiff - Math.PI / 2) < 0.1; default: log("No => Tile type is unknown. Cannot accept flow."); return false; } } function createWaterDrops(x, y, game) { for (var i = 0; i < 30; i++) { var waterDrop = waterDrops.find(function (drop) { return !drop.visible; }); if (!waterDrop) { waterDrop = new WaterDrop(); waterDrops.push(waterDrop); frontLayer.addChild(waterDrop); } waterDrop.x = x; waterDrop.y = y; var angle = Math.random() * Math.PI * 2; var speed = Math.random() * 5 + 5; 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 = 150; waterDrop.visible = true; } } function animateSoil() { log("Animate soil..."); var alphaIncrement = 0.05; // Adjust the increment for desired speed // Animate all baseTile tiles' alpha from 1 to 0 puzzleManager.grid.forEach(function (row) { row.forEach(function (tile) { log("animate tile:", tile); if (tile && tile.baseTile) { tile.baseTile.alpha = 1; LK.setInterval(function () { if (tile.baseTile.alpha > 0) { tile.baseTile.alpha -= alphaIncrement; } }, 30); } }); }); growGrass.visible = true; var stars = calculateStarsScore(); // Spawn a Flower in each grid cell for (var i = 0; i < puzzleManager.gridSize; i++) { for (var j = 0; j < puzzleManager.gridSize; j++) { for (var k = 0; k < stars; k++) { var x = i * tileSize + gridBoard.x - gridBoard.width / 2 + tileSize / 2 + boardOffsetX; var y = j * tileSize + gridBoard.y - gridBoard.height / 2 + tileSize / 2 + boardOffsetY; var flower = new Flower(puzzleManager.currentLevel, x, y); flowers.push(flower); game.addChild(flower); } } } // Animate all pipeContainer tiles' alpha from 1 to 0 puzzleManager.grid.forEach(function (row) { row.forEach(function (tile) { log("animate pipeContainer tile:", tile); if (tile && tile.pipeContainer) { tile.pipeContainer.alpha = 1; LK.setInterval(function () { if (tile.pipeContainer.alpha > 0) { tile.pipeContainer.alpha -= alphaIncrement * 0.5; } }, 30); } }); }); // Animate growGrass alpha from 0 to 1 var grassAnimation = LK.setInterval(function () { if (growGrass.alpha < 1) { growGrass.alpha += alphaIncrement; // Adjust the increment for desired speed } else { LK.clearInterval(grassAnimation); LK.setTimeout(function () { if (isGameFinished) { changeGameState(GAME_STATE.SCORE); } else { changeGameState(GAME_STATE.NEW_ROUND); } }, 2000); } }, 80); // Adjust the interval for desired speed } /**** * Game State Management ****/ function initializeGame() { // Init and Add backgroundLayer backgroundLayer = new Container(); middleLayer = new Container(); frontLayer = new Container(); overlayLayer = new Container(); game.addChild(backgroundLayer); // Add backgroundPlaying1 to the menu state backgroundImage1 = LK.getAsset('backgroundPlaying1', { anchorX: 0.5, anchorY: 0.5 }); backgroundImage1.x = 2048 / 2; backgroundImage1.y = 2732 / 2; backgroundLayer.addChild(backgroundImage1); backgroundImage2 = LK.getAsset('backgroundPlaying1', { anchorX: 0.5, anchorY: 0.5, scaleX: -1 }); backgroundImage2.x = 2048 + 2048 / 2; backgroundImage2.y = 2732 / 2; backgroundLayer.addChild(backgroundImage2); // Initialize grid board shadow gridBoardSoil = LK.getAsset('gridBoardSoil', { anchorX: 0.5, anchorY: 0.5, visible: false, alpha: 0.75, tint: 0x000000 }); gridBoardSoil.x = 2048 / 2 + 2048 + gridBoardSoilOffset; gridBoardSoil.y = 2732 / 2 + gridBoardSoilOffset; game.addChild(gridBoardSoil); // Initialize grid board gridBoard = LK.getAsset('gridBoard', { anchorX: 0.5, anchorY: 0.5, visible: false }); gridBoard.x = 2048 / 2 + 2048; gridBoard.y = 2732 / 2; game.addChild(gridBoard); game.addChild(middleLayer); game.addChild(frontLayer); game.addChild(overlayLayer); // Create growGrass asset growGrass = LK.getAsset('growGrass', { anchorX: 0.5, anchorY: 0.5, visible: false, alpha: 0 }); growGrass.x = 2048 / 2 + growGrassOffsetX; growGrass.y = 2732 / 2; middleLayer.addChild(growGrass); // Initialize game assets and variables puzzleManager = new PuzzleManager(game); // Initialize level text levelText = new Text2("1", { size: 200, fill: 0x222222, weight: 1000, dropShadow: false }); levelText.x = 2048 / 2 + 2048 + levelTextXOffset; levelText.y = 250; levelText.anchorX = 0.5; levelText.blendMode = 3; levelText.visible = false; // Add the level text to the game game.addChild(levelText); congratsText = new Text2(congratsMessages[3], { size: 300, fill: 0xFFFFFF, // Green Color 0x00cd20, weight: 1000, dropShadow: true }); congratsText.x = congratsTextOffset + 2048; congratsText.y = 750; congratsText.anchorX = 0.5; congratsText.blendMode = 0; congratsText.visible = true; // Add the level text to the game game.addChild(congratsText); // Nb Moves Text nbMovesText = new Text2("0/0 moves", { size: 150, fill: 0xFFFFFF, // Green Color 0x00cd20, weight: 1000, align: 'center', dropShadow: true }); nbMovesText.x = nbMovesTextOffset + 2048; nbMovesText.y = 1750; nbMovesText.anchorX = 0.5; nbMovesText.alpha = 0.55; nbMovesText.blendMode = 0; nbMovesText.visible = true; game.addChild(nbMovesText); // reset button resetButton = new ResetButton(); resetButton.x = 2048 - 180; resetButton.y = 120; resetButton.visible = false; // Add the level text to the game game.addChild(resetButton); // Set an interval to play plumes animation every 5 to 10 seconds LK.setInterval(playPlumesAnim, 1000 + Math.random() * 1000); // Set an interval to play butterfly animation every 5 to 10 seconds LK.setInterval(playButterflyAnim, 5000 + Math.random() * 5000); // Transition to menu state changeGameState(GAME_STATE.MENU); } function initMenuState() { log("Entering Menu State..."); isPlaying = false; // Add logo to the menu state logoShadow = LK.getAsset('logo', { anchorX: 0.5, anchorY: 0.5, width: 1480, height: 1480, tint: 0x000000, alpha: 0.5 }); logoShadow.x = 2048 / 2 + 20; logoShadow.y = -logoShadow.height + 20; // Initialize logo out of screen middleLayer.addChild(logoShadow); // Add logo to the menu state logo = LK.getAsset('logo', { anchorX: 0.5, anchorY: 0.5, width: 1480, height: 1480 }); logo.x = 2048 / 2; logo.y = -logo.height; // Initialize logo out of screen middleLayer.addChild(logo); // logoMaze Shadow logoMazeShadow = LK.getAsset('logoMaze', { anchorX: 0.5, anchorY: 0.5, width: 1400, height: 400, tint: 0x000000, alpha: 0.5 }); logoMazeShadow.x = 2048 / 2 + 20; logoMazeShadow.y = -3000 + 20; // Initialize logo out of screen middleLayer.addChild(logoMazeShadow); // logoMaze logoMaze = LK.getAsset('logoMaze', { anchorX: 0.5, anchorY: 0.5, width: 1400, height: 400 }); logoMaze.x = 2048 / 2; logoMaze.y = -3000; // Initialize logo out of screen middleLayer.addChild(logoMaze); // Update any menu animations here // Define a simple tween function to animate the logo // Use the tween function to animate the logo tween(logoShadow, { x: 2048 / 2 + 20, // Center horizontally y: 2732 / 2 - 30 // Center vertically with offset }, { duration: 1000, easing: tween.bounceOut }); tween(logo, { x: 2048 / 2, // Center horizontally y: 2732 / 2 - 50 // Center vertically with offset }, { duration: 1000, easing: tween.bounceOut, // Simple ease-out function onFinish: function onFinish() { isLogoAnimInFinished = true; } }); tween(logoMaze, { x: 2048 / 2, // Center horizontally y: 2732 - 450 }, { duration: 2000, easing: tween.bounceOut }); tween(logoMazeShadow, { x: 2048 / 2 + 20, // Center horizontally y: 2732 - 450 + 20 }, { duration: 2000, easing: tween.bounceOut }); LK.getSound('logoBounce').play(); } function handleMenuLoop() {} function cleanMenuState() { if (logo) { tween(logo, { x: -logo.width }, { // Animate logo out to the left duration: 1000, // Duration of 1 second easing: tween.easeInOut, // Easing function for smooth animation onFinish: function onFinish() { logo.visible = false; // Hide logo after animation game.removeChild(logo); // Remove logo from game isLogoAnimOutFinished = true; } }); } if (logoShadow) { tween(logoShadow, { x: -logoShadow.width }, { // Animate logo out to the left duration: 1000, // Duration of 1 second easing: tween.easeInOut, // Easing function for smooth animation onFinish: function onFinish() { logoShadow.visible = false; // Hide logo after animation game.removeChild(logoShadow); // Remove logo from game } }); } if (logoMaze) { tween(logoMaze, { x: -logoMaze.width }, { // Animate logo out to the left duration: 1000, // Duration of 1 second easing: tween.easeInOut, // Easing function for smooth animation onFinish: function onFinish() { logoMaze.visible = false; // Hide logo after animation game.removeChild(logoMaze); // Remove logo from game } }); } if (logoMazeShadow) { tween(logoMazeShadow, { x: -logoMazeShadow.width }, { // Animate logo out to the left duration: 1000, // Duration of 1 second easing: tween.easeInOut, // Easing function for smooth animation onFinish: function onFinish() { logoMazeShadow.visible = false; // Hide logo after animation game.removeChild(logoMazeShadow); // Remove logo from game } }); } } function animateRoundEntrance() { // Animate background images to slide to the left tween(backgroundImage1, { x: -2048 / 2 }, { duration: 1000, easing: tween.easeInOut }); tween(backgroundImage2, { x: 2048 / 2 }, { duration: 1000, easing: tween.easeInOut }); tween(gridBoard, { x: 2048 / 2 }, { duration: 1000, easing: tween.easeInOut }); tween(gridBoardSoil, { x: 2048 / 2 }, { duration: 1000, easing: tween.easeInOut }); // Initialize grid with tiles from level configuration for (var row = 0; row < puzzleManager.gridSize; row++) { for (var col = 0; col < puzzleManager.gridSize; col++) { var tile = puzzleManager.grid[row][col]; if (tile) { tween(tile, { x: tile.x - 2048 // Animate entrance }, { duration: 1000, easing: tween.easeInOut }); } } } tween(levelText, { x: 2048 / 2 + ("" + puzzleManager.currentLevel).length * levelTextXOffset }, { duration: 1000, easing: tween.easeInOut }); } function initNewRoundState() { log("Entering New Round State..."); LK.getSound('levelStart').play(); // Reset puzzle manager for new round if (puzzleManager) { puzzleManager.initPuzzle(); } if (isGameFinished) { return; } // Show gridBoard gridBoardSoil.visible = true; gridBoard.visible = true; levelText.visible = true; levelText.setText(puzzleManager.currentLevel); log("Levels is now ", puzzleManager.currentLevel); animateRoundEntrance(); // 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 log("Entering Playing State..."); isPlaying = true; } function handlePlayingLoop() { // Update game logic if (puzzleManager) { puzzleManager.grid.forEach(function (row) { row.forEach(function (tile) { if (tile) { tile.update(); } }); }); // Check if level is complete if (puzzleManager.isComplete) { changeGameState(GAME_STATE.NEW_ROUND); } } } function animateRoundExit(callBack) { log("animateRoundExit...with callback=", !!callBack); // Animate background images to slide to the left backgroundImage1.x = 2048 + 2048 / 2; tween(backgroundImage1, { x: 2048 / 2 }, { duration: 1000, easing: tween.easeInOut }); tween(backgroundImage2, { x: -2048 / 2 }, { duration: 1000, easing: tween.easeInOut }); tween(gridBoard, { x: -2048 / 2 }, { duration: 1000, easing: tween.easeInOut }); tween(gridBoardSoil, { x: -2048 / 2 }, { duration: 1000, easing: tween.easeInOut }); // Initialize grid with tiles from level configuration for (var row = 0; row < puzzleManager.gridSize; row++) { for (var col = 0; col < puzzleManager.gridSize; col++) { var tile = puzzleManager.grid[row][col]; if (tile) { tween(tile, { x: tile.x - 2048 // Animate }, { duration: 1000, easing: tween.easeInOut }); } } } if (growGrass) { tween(growGrass, { x: -2048 / 2 }, { duration: 1000, easing: tween.easeInOut }); } if (flowers && flowers.length) { for (var i = flowers.length - 1; i >= 0; i--) { if (flowers[i]) { var destX = flowers[i].x - 2048; tween(flowers[i], { x: destX }, { duration: 1000, easing: tween.easeInOut }); } } } tween(levelText, { x: -2048 / 2 }, { duration: 1000, easing: tween.easeInOut, onFinish: function onFinish() { callBack(); //LK.setTimeout(function () { }, 2300); } }); // Calculate the number of stars based on moves var stars = calculateStarsScore(); // Create a new RatingStars instance var ratingStars = new RatingStars(stars); // Set initial position off-screen ratingStars.x = 2048 + 2048 / 2; ratingStars.y = 2732 / 2; game.addChild(ratingStars); updateOverlayLayer(); // Animate the RatingStars to the center of the screen tween(ratingStars, { x: 2048 / 2 }, { duration: 1000, easing: tween.easeInOut, onFinish: function onFinish() { LK.setTimeout(function () { tween(ratingStars, { x: -2048 / 2 }, { duration: 1000, easing: tween.easeInOut }); }, 1700); } }); congratsText.setText(congratsMessages[stars]); congratsText.visible = true; congratsText.x = congratsTextOffset + 2048; tween(congratsText, { x: congratsTextOffset }, { duration: 1000, easing: tween.easeInOut, onFinish: function onFinish() { LK.setTimeout(function () { tween(congratsText, { x: congratsTextOffset - 2048 }, { duration: 1000, easing: tween.easeInOut, onFinish: function onFinish() { congratsText.visible = false; } }); }, 1700); } }); // Nb Moves text nbMovesText.setText("level " + puzzleManager.currentLevel + "\nmoves\n" + currentRoundMoves + "/" + levelMinimalMoves[puzzleManager.currentLevel]); nbMovesText.visible = true; nbMovesText.x = nbMovesTextOffset + 2048; tween(nbMovesText, { x: nbMovesTextOffset }, { duration: 1000, easing: tween.easeInOut, onFinish: function onFinish() { LK.setTimeout(function () { tween(nbMovesText, { x: nbMovesTextOffset - 2048 }, { duration: 1000, easing: tween.easeInOut, onFinish: function onFinish() { nbMovesText.visible = false; } }); }, 1700); } }); } function cleanPlayingState() { log("cleanPlayingState..."); isPlaying = false; isRoundExitAnimFinished = false; animateRoundExit(function () { log("animateRoundExit Callback..."); // Hide growGrass if (growGrass) { growGrass.visible = false; growGrass.alpha = 0; growGrass.x = 2048 / 2 + growGrassOffsetX; } // Stop waterdrops animations if any if (waterDropInterval) { LK.clearInterval(waterDropInterval); waterDropInterval = null; } // Remove remaining waterdrops if any for (var i = waterDrops.length - 1; i >= 0; i--) { if (waterDrops[i].visible) { waterDrops[i].destroy(); waterDrops.splice(i, 1); } } backgroundImage1.x = 2048 / 2; backgroundImage2.x = 2048 + 2048 / 2; gridBoard.x = 2048 + 2048 / 2; gridBoardSoil.x = 2048 + 2048 / 2 + gridBoardSoilOffset; levelText.x = 2048 + 2048 / 2; isRoundExitAnimFinished = true; }); } function initScoreState() { // Show score screen log("Entering Score State"); LK.setTimeout(finalAnimation, 2000); } function handleScoreLoop() { // Update any score animations } function cleanScoreState() { levelText.visible = false; if (finalAnimationInterval) { LK.clearInterval(finalAnimationInterval); } } function changeGameState(newState) { // Clean up current state log("Changing state from", currentState, "to", newState); 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: if (!isLogoAnimOutFinished) { LK.setTimeout(initNewRoundState, 1000); break; } if (!isRoundExitAnimFinished) { log("Wait exit anim before new round..."); LK.setTimeout(initNewRoundState, 2700); break; } initNewRoundState(); break; case GAME_STATE.PLAYING: initPlayingState(); break; case GAME_STATE.SCORE: initScoreState(); break; } } /**** * Event Handlers ****/ game.down = function (x, y, obj) { if (!isLogoAnimInFinished) { return; } switch (currentState) { case GAME_STATE.MENU: changeGameState(GAME_STATE.NEW_ROUND); break; case GAME_STATE.PLAYING: startX = x; startY = y; isMouseDown = true; if (puzzleManager) { log("Down at ", x, y); puzzleManager.selectTile(x, y); } break; case GAME_STATE.SCORE: //changeGameState(GAME_STATE.MENU); if (isFinalAnimationFinished) { storage.currentLevel = 1; // Reset current level in storage LK.showGameOver(); } 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; log("Move at ", x, y, " => dx,dy: ", deltaX, deltaY); // 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)) { // Allow some vertical drag for horizontal moves direction = deltaX > 0 ? 'right' : 'left'; } else if (Math.abs(deltaY) > Math.abs(deltaX)) { // Allow some horizontal drag for vertical moves direction = deltaY > 0 ? 'down' : 'up'; } log("=> Move Tile to direction:", direction); puzzleManager.moveTile(direction); isMouseDown = false; // Reset after move } }; game.up = function (x, y, obj) { isMouseDown = false; if (currentState === GAME_STATE.PLAYING && puzzleManager) { log("Up at ", x, y); 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(); } } } // Tile Format Utilities var TileFormat = { // Constants FIXED: 'F', MOBILE: 'M', TYPES: { START: 'S', END: 'E', VERTICAL: 'V', HORIZONTAL: 'H', CORNER: 'C', CROSS: 'X', BLANK: 'B' }, // Parse a tile string into its components parse: function parse(tileStr) { if (!tileStr || tileStr === "") { return null; } var parts = tileStr.split('-'); if (parts.length !== 3) { log("ERROR !!! Invalid tile format:", tileStr); return null; } return { fixed: parts[0] === this.FIXED, type: parts[1], rot: parseInt(parts[2]), rotation: parseInt(parts[2]) * (Math.PI / 2) // Convert to radians }; }, // Create a tile string from components create: function create(fixed, type, rotationIndex) { return "".concat(fixed ? this.FIXED : this.MOBILE, "-").concat(type, "-").concat(rotationIndex); }, // Convert old tile type to new format convertOldType: function convertOldType(oldType) { switch (oldType) { case 'start': return this.TYPES.START; case 'end': return this.TYPES.END; case 'straightPipeV': return this.TYPES.VERTICAL; case 'straightPipeH': return this.TYPES.HORIZONTAL; case 'cornerPipe': return this.TYPES.CORNER; default: return this.TYPES.BLANK; } }, // Convert rotation in radians to index (0-3) getRotationIndex: function getRotationIndex(radians) { if (typeof radians !== 'number') { return 0; } return Math.round(radians % (2 * Math.PI) / (Math.PI / 2)) % 4; }, // Convert old level format to new format convertOldLevel: function convertOldLevel(oldLevel) { var newGrid = []; for (var row = 0; row < 4; row++) { newGrid[row] = []; for (var col = 0; col < 4; col++) { var oldTile = oldLevel.tiles[row][col]; if (!oldTile) { newGrid[row][col] = ""; continue; } var isFixed = oldLevel.fixedTiles && oldLevel.fixedTiles.includes("".concat(row, ",").concat(col)); var type = this.convertOldType(oldTile); var rotation = oldLevel.rotations["".concat(row, ",").concat(col)] || 'up'; var rotationIndex = this.getRotationIndex(rotation); newGrid[row][col] = this.create(isFixed, type, rotationIndex); } } return newGrid; } }; // Update tile creation to use new format function createTile(tileStr, row, col) { if (!tileStr || tileStr === "") { return null; } var tileData = TileFormat.parse(tileStr); if (!tileData) { return null; } var tile = new Tile(); tile.type = tileData.type; tile.fixed = tileData.fixed; tile.gridRow = row; tile.gridCol = col; // Set type and create pipe graphics tile.setType(tileData.type, row, col, tileData.fixed); // Set initial rotation log("Set initial rotation:", tileData.rot); tile.setRotation(tileData.rot, tileData.rotation); // Set position tile.updatePosition(row, col); return tile; } /* All Corners : 0: [["F-E-0", "F-C-2", "F-C-3", ""], ["F-C-1", "F-C-0", "F-C-1", "F-C-3"], ["F-C-2", "F-C-3", "F-C-2", "F-C-0"], ["F-S-2", "F-C-1", "", "M-C-0"]], 0: [["F-S-0", "F-C-2", "F-C-3", ""], ["F-C-1", "F-C-0", "F-C-1", "F-C-3"], ["F-C-2", "F-C-3", "F-C-2", "F-C-0"], ["F-E-2", "F-C-1", "", "M-C-0"]], */ var nbLevels = 20; var levelMinimalMoves = { 0: 33, 1: 1, 2: 6, 3: 8, 4: 10, 5: 12, 6: 15, 7: 16, 8: 16, 9: 16, 10: 16, 11: 19, 12: 24, 13: 25, 14: 26, 15: 24, 16: 27, 17: 30, 18: 33, 19: 35, 20: 38 }; var levelConfigs = { 0: [["M-C-1", "M-C-2", "M-C-0", "F-S-0"], ["M-C-2", "M-V-0", "F-V-0", "M-C-0"], ["F-V-0", "", "", ""], ["F-E-2", "", "", "M-C-3"]], // Level 1 - 1 1: [["F-S-0", "", "", ""], ["F-V-0", "", "", ""], ["F-V-0", "", "M-H-0", ""], ["F-C-1", "F-H-0", "", "F-E-1"]], // Level 2 - 6 2: [["", "M-V-0", "F-E-0", ""], ["", "M-C-0", "F-V-0", ""], ["", "", "", ""], ["F-S-3", "F-H-0", "", ""]], // Level 3 - 8 3: [["", "", "", ""], ["F-S-3", "F-C-3", "F-C-2", "F-E-1"], ["", "M-V-0", "F-V-0", ""], ["", "M-C-0", "M-C-1", ""]], // Level 4 - 10 4: [["M-V-0", "F-C-2", "F-C-3", ""], ["M-C-1", "M-V-0", "F-V-0", "F-E-0"], ["F-S-0", "", "", "F-C-0"], ["F-C-1", "", "", "M-C-0"]], // Level 5 - 12 5: [["M-C-2", "M-H-0", "F-H-0", "F-E-1"], ["M-C-0", "", "", ""], ["M-H-0", "M-C-1", "M-C-3", ""], ["F-S-3", "F-H-0", "M-V-0", ""]], // Level 6 - 15 6: [["M-H-0", "", "M-V-0", "F-E-1"], ["", "", "", "M-H-0"], ["", "", "", ""], ["F-S-2", "", "M-V-0", "M-C-2"]], // Level 7 - 16 7: [["M-C-3", "F-C-2", "", ""], ["", "F-E-2", "", ""], ["", "", "", "F-V-0"], ["M-V-0", "M-H-0", "", "F-S-2"]], // Level 8 - 16 8: [["F-S-0", "F-E-0", "M-C-0", "F-C-3"], ["F-V-0", "F-C-1", "", "M-C-2"], ["M-H-0", "M-V-0", "", "M-V-0"], ["F-C-1", "M-V-0", "F-H-0", "F-C-0"]], // Level 9 - 16 9: [["F-S-3", "M-V-0", "F-C-3", "M-H-0"], ["", "", "", ""], ["", "", "", ""], ["F-E-3", "M-V-0", "F-C-0", "M-H-0"]], // Level 10 - 16 10: [["M-C-2", "M-V-0", "M-V-0", "F-C-3"], ["M-V-0", "M-H-0", "M-H-0", "M-V-0"], ["M-C-1", "F-S-0", "F-E-0", "M-C-0"], ["", "F-C-0", "F-C-1", ""]], // Level 11 - 19 11: [["F-E-0", "M-V-0", "", "M-V-0"], ["M-H-0", "M-C-0", "", "F-S-0"], ["M-H-0", "", "", ""], ["F-C-1", "", "M-V-0", ""]], // Level 12 - 24 12: [["F-S-0", "M-V-0", "M-C-3", "M-C-0"], ["F-C-1", "F-C-0", "M-C-2", "M-C-2"], ["F-E-0", "", "F-C-0", "M-C-1"], ["", "", "", ""]], // Level 13 - 25 13: [["", "M-V-0", "M-H-0", "F-C-3"], ["", "F-S-0", "M-C-2", "F-E-2"], ["", "F-C-0", "", ""], ["M-H-0", "", "", "M-C-1"]], // Level 14 - 26 14: [["M-V-0", "F-C-2", "F-H-0", "F-C-3"], ["", "F-E-2", "", ""], ["", "M-V-0", "F-S-0", ""], ["", "M-C-1", "M-C-0", ""]], // Level 15 - 27 15: [["M-C-2", "F-S-0", "M-H-0", "M-C-0"], ["M-C-1", "", "", "F-V-0"], ["M-C-0", "", "", "F-V-0"], ["M-C-3", "F-E-3", "", ""]], // Level 16 - 29 16: [["M-H-0", "F-C-2", "", "F-C-3"], ["M-V-0", "F-E-2", "", ""], ["", "", "F-S-3", "M-C-0"], ["", "", "", ""]], // Level 17 - 32 17: [["F-E-3", "M-H-0", "M-C-2", "F-C-3"], ["", "", "F-C-2", "M-H-0"], ["M-H-0", "M-H-0", "M-C-0", ""], ["F-C-1", "M-H-0", "M-C-0", "F-S-1"]], // Level 18 - 36 18: [["M-C-1", "M-C-2", "M-C-0", "F-S-0"], ["M-C-2", "M-V-0", "F-V-0", "M-C-0"], ["F-V-0", "", "", ""], ["F-E-2", "", "", "M-C-3"]], // Level 19 - 37 19: [["M-C-2", "M-H-0", "M-H-0", "M-C-3"], ["M-V-0", "", "", ""], ["F-E-0", "F-C-1", "F-S-1", ""], ["F-C-1", "M-C-0", "M-H-0", ""]], // Level 20 - 38 20: [["M-H-0", "", "", "F-S-1"], ["M-H-0", "F-V-0", "", ""], ["M-H-0", "F-C-0", "M-C-2", "M-C-2"], ["", "", "M-C-1", "F-E-1"]] };

Water Pipe Maze by Abder

Images

Sounds