/**** * Classes ****/ // Assets will be automatically generated based on usage in the code. // Domino class var Domino = Container.expand(function () { var self = Container.call(this); // Assuming directionsList is a shuffled array of directions ['U', 'L', 'R', 'D'] repeated to match the number of dominos self.direction = directionsList.shift(); // Updated asset attachment logic based on direction switch (self.direction) { case 'U': dominoGraphics = self.attachAsset('D_Up', { anchorX: 0.5, anchorY: 0.5 }); break; case 'D': dominoGraphics = self.attachAsset('D_Down', { anchorX: 0.5, anchorY: 0.5 }); break; case 'L': dominoGraphics = self.attachAsset('D_Left', { anchorX: 0.5, anchorY: 0.5 }); break; case 'R': dominoGraphics = self.attachAsset('D_Right', { anchorX: 0.5, anchorY: 0.5 }); break; } self.isTipped = false; self.hiddenCoin = false; // Indicates whether a coin is hidden underneath // Direction is already set at the beginning of the constructor. // Direction label code removed as it's no longer necessary with direction-specific assets self.tip = function (projectile, isPlayerAction) { if (projectile) { projectilePool.put(projectile); // Recycle the projectile immediately var index = projectiles.indexOf(projectile); if (index !== -1) { projectiles.splice(index, 1); // Remove from tracking array } } if (!self.isTipped) { self.isTipped = true; if (self.hiddenCoin) { // Change appearance to a coin and increase score by 10 points self.destroy(); var coin = new Container(); // Initialize frame index and timestamps for animation coin.frameIndex = 0; coin.lastFrameTimestamp = 0; coin.frames = ['coin', 'Coin_1', 'Coin_2', 'Coin_3']; // Initialize frame index for animation and set last frame change time to 0 coin.frameIndex = 0; coin.lastFrameChangeTime = 0; coin.frames = ['coin', 'Coin_1', 'Coin_2', 'Coin_3']; // Attach the first frame of the coin animation coin.attachAsset(coin.frames[coin.frameIndex], { anchorX: 0.5, anchorY: 0.5 }); // Update method to handle frame change coin._update_migrated = function () { // Get current time in milliseconds var currentTime = Date.now(); // Change frame every second if (currentTime - coin.lastFrameChangeTime >= 200) { coin.frameIndex = (coin.frameIndex + 1) % coin.frames.length; coin.removeChildAt(0); // Remove the current frame // Attach the next frame coin.attachAsset(coin.frames[coin.frameIndex], { anchorX: 0.5, anchorY: 0.5 }); coin.lastFrameChangeTime = currentTime; } }; // Add the coin to the game's update loop LK.on('tick', function () { coin._update_migrated(); }); game.addChild(coin); coin.x = self.x; coin.y = self.y; score += 10; // Increase score by 10 points for revealing a coin // This block is intentionally left unchanged as it correctly implements the requirement. if (self.hiddenCoin) { replenishLife(); // Call replenishLife function only if a hidden coin is discovered LK.getSound('Gem').play(); // Play Gem sound when a tile containing a coin is destroyed } } else { // Destroy the domino after it shoots its projectile self.destroy(); LK.getSound('Pop').play(); // Play Pop sound when tile is destroyed } // directionLabel removal code has been deprecated // Tip animation logic here LK.effects.flashObject(self, 0xffa500, 500); // Decrement lives only for direct player actions and immediately refill if a coin is discovered if (isPlayerAction) { lives -= 1; // Deduct a life for the action of tipping // Update UI_Projectile color to indicate a life has been used if (lives >= 0 && lives < livesIndicators.length) { livesIndicators[lives].alpha = 0; // Hide the life indicator } // Refill life if a coin is discovered under the tipped domino if (self.hiddenCoin) { replenishLife(); } // Check for game over condition after the 3rd domino is tipped if (lives <= 0) { // Ensure this flag is checked in the projectile's edge collision logic isProjectileInMotion = true; } } // Increment score by 1 for all domino flips score += 1; scoreTxt.setText(score.toString()); background.alpha = Math.min(score * 0.0025, 1); // Increase alpha by 0.2 for each score point, up to a maximum of 1 // Shoot a projectile in the direction specified by the domino's symbol var projectile = projectilePool.get(); projectile.direction = self.direction; projectile.x = self.x; projectile.y = self.y; // Update the projectile's grid position projectile.gridX = Math.floor(projectile.x / 100); projectile.gridY = Math.floor(projectile.y / 100); game.addChild(projectile); projectiles.push(projectile); } // Update the domino's grid position self.gridX = Math.floor(self.x / 100); self.gridY = Math.floor(self.y / 100); }; }); // Factory class var Factory = Container.expand(function () { var self = Container.call(this); self.dominos = []; self.addDomino = function (x, y, hasHiddenCoin) { var domino = new Domino(); domino.x = x; domino.y = y; domino.hiddenCoin = hasHiddenCoin || false; self.addChild(domino); self.dominos.push(domino); }; self.reset = function () { self.dominos.forEach(function (domino) { domino.destroy(); // Destroy domino instance // Remove any event listeners attached to domino here if any }); self.dominos.length = 0; // Clear the array without creating a new one }; }); // Projectile class var Projectile = Container.expand(function () { var self = Container.call(this); var projectileGraphics = self.attachAsset('projectile', { anchorX: 0.5, anchorY: 0.5 }); self.direction = ''; self.speed = 20; self._move_migrated = function () { // Decrease acceleration factor var acceleration = 2; // Increased acceleration // Update speed with decreased acceleration self.speed += acceleration; switch (self.direction) { case 'U': self.y -= self.speed; break; case 'L': self.x -= self.speed; break; case 'R': self.x += self.speed; break; case 'D': self.y += self.speed; break; } // Update the projectile's grid position and check for collisions with dominos self.gridX = Math.floor(self.x / 100); self.gridY = Math.floor(self.y / 100); // Check for domino collisions after moving factory.dominos.forEach(function (domino) { if (!domino.isTipped && self.raycast(domino)) { domino.tip(self); // Pass this projectile to the domino's tip method // Reset projectile's speed to its original value after tipping a domino self.speed = 10; } }); }; self.raycast = function (domino) { // Calculate the distance between the projectile and the domino var dx = domino.x - self.x; var dy = domino.y - self.y; var distance = Math.sqrt(dx * dx + dy * dy); // If the distance is less than the sum of their radii, there is an intersection return distance < self.width / 2 + domino.width / 2; }; }); /**** * Initialize Game ****/ // Initialize a new projectile pool var game = new LK.Game({ backgroundColor: 0xd3d3d3 // Set game background to light grey }); /**** * Game Code ****/ // Function to replenish a life function replenishLife() { if (lives < 3) { lives += 1; // Update the visual indicator for lives to fully opaque and visible to signify an active life livesIndicators[lives - 1].alpha = 1; livesIndicators[lives - 1].visible = true; } } var backgroundAsset = LK.getAsset('background', { anchorX: 0.0, anchorY: 0.0 }); var baseBackground = game.addChild(LK.getAsset('background', { x: 0, y: 0, width: game.width, height: game.height, tint: 0x000000 })); var background = game.addChild(LK.getAsset('background', { x: 0, y: 0, width: game.width, height: game.height, alpha: 0 })); // Function to shuffle an array function shuffleArray(array) { for (var i = array.length - 1; i > 0; i--) { var j = Math.floor(Math.random() * (i + 1)); var _ref = [array[j], array[i]]; array[i] = _ref[0]; array[j] = _ref[1]; } } // Calculate total number of dominos based on grid size (16 columns * 20 rows) var totalDominos = 16 * 20; // Divide total by 4 to get number of dominos for each direction var dominosPerDirection = totalDominos / 4; // Create a list of directions with an equal number of 'U', 'L', 'R', 'D' var directionsList = []; ['U', 'L', 'R', 'D'].forEach(function (direction) { for (var i = 0; i < dominosPerDirection; i++) { directionsList.push(direction); } }); // Shuffle the directions list shuffleArray(directionsList); // Reset game flags and counters at the start of a new game session var score = 0; // Reset score to 0 var lives = 3; // Reset lives to 3 var isProjectileInMotion = false; // Reset projectile motion flag var awaitingLastProjectile = false; // Reset awaiting last projectile flag // Display score // Initialize UI_Projectile assets as lives indicators var livesIndicators = []; for (var i = 0; i < 3; i++) { var lifeIndicator = game.addChild(LK.getAsset('UI_Projectile', { x: 1600 + i * 150, // Moved 500 pixels to the right y: 130, anchorX: 0.5, anchorY: 0.5 })); livesIndicators.push(lifeIndicator); } var scoreTxt = new Text2(score.toString(), { size: 150, fill: "#ffffff", stroke: "#000000", // Black outline strokeThickness: 8 // Thickness of the outline }); scoreTxt.anchor.set(0.5, 0); // Center the score text horizontally LK.gui.top.addChild(scoreTxt); // Add the score text to the GUI overlay at the top-center of the screen // Custom intersects function for accurate collision detection function intersects(projectile, domino) { var projectileBounds = { left: projectile.x - projectile.width / 2, right: projectile.x + projectile.width / 2, top: projectile.y - projectile.height / 2, bottom: projectile.y + projectile.height / 2 }; var dominoBounds = { left: domino.x - domino.width / 2, right: domino.x + domino.width / 2, top: domino.y - domino.height / 2, bottom: domino.y + domino.height / 2 }; return !(projectileBounds.right < dominoBounds.left || projectileBounds.left > dominoBounds.right || projectileBounds.bottom < dominoBounds.top || projectileBounds.top > dominoBounds.bottom); } // Array to store all projectiles // ProjectilePool class var ProjectilePool = function ProjectilePool() { this.pool = []; this.get = function () { if (this.pool.length > 0) { return this.pool.pop(); } else { return new Projectile(); } }; this.put = function (projectile) { // Assuming projectiles might have event listeners attached // Remove event listeners from projectile here if any this.pool.push(projectile); }; }; // Initialize a new projectile pool var projectilePool = new ProjectilePool(); var projectiles = []; // Game tick function to move all projectiles and check for domino tipping LK.on('tick', function () { // Removed life replenishment every 100 points projectiles.forEach(function (projectile, i) { // Set isProjectileInMotion to true when a projectile starts moving isProjectileInMotion = true; // Move the projectile based on its direction projectile._move_migrated(); // Check for domino tipping within the same grid cell var tippedDomino = factory.dominos.find(function (domino) { return !domino.isTipped && domino.gridX === projectile.gridX && domino.gridY === projectile.gridY && projectile.intersects(domino); }); if (tippedDomino) { // Recycle the current projectile projectilePool.put(projectile); projectiles.splice(i, 1); // Trigger the projectile of the domino it just hit tippedDomino.tip(); } // Remove projectiles that have moved off screen if (projectile.x < 0 || projectile.x > 2048 || projectile.y < 0 || projectile.y > 2732) { projectile.destroy(); // Destroy the projectile when it hits the edge of the screen projectiles.splice(i, 1); // Remove from tracking array // Re-enable player input after projectile hits screen edge isProjectileInMotion = false; // Check if no lives are left and all projectiles have been processed before showing game over if (lives <= 0 && projectiles.length === 0 && !isProjectileInMotion) { awaitingLastProjectile = true; // Set the flag to true to wait for the last projectile } // Show game over screen if awaitingLastProjectile is true and all projectiles have been processed if (awaitingLastProjectile && projectiles.length === 0) { LK.showGameOver(); // Show game over screen awaitingLastProjectile = false; // Reset the flag after showing game over } } }); }); var factory = game.addChild(new Factory()); // Function to check and trigger domino tipping function checkAndTipDominos(x, y) { factory.dominos.forEach(function (domino) { if (Math.abs(domino.x - x) < 100 && Math.abs(domino.y - y) < 100) { domino.tip(); } }); } // Populate the factory with dominos and randomly select 20 to have hidden coins var dominoIndexesWithCoins = []; while (dominoIndexesWithCoins.length < 15) { var randomIndex = Math.floor(Math.random() * 320); // 320 is the total number of dominos (16*20) if (dominoIndexesWithCoins.indexOf(randomIndex) === -1) { dominoIndexesWithCoins.push(randomIndex); } } var dominoCounter = 0; for (var i = 0; i < 16; i++) { for (var j = 0; j < 20; j++) { factory.addDomino(2048 / 2 - 15 * 120 / 2 + i * 120, 2732 / 2 - 17.3 * 120 / 2 + j * 120, dominoIndexesWithCoins.includes(dominoCounter)); dominoCounter++; } } // Handle touch events to tip dominos // Flag to check if a projectile is in motion and if the game is awaiting the last projectile's conclusion after the last life is lost var isProjectileInMotion = false; var awaitingLastProjectile = false; game.on('down', function (x, y, obj) { // Check if a projectile is in motion before allowing domino tipping if (isProjectileInMotion) { return; } var pos = game.toLocal(obj.global); // Find the closest domino to the tap position var closestDomino = factory.dominos.reduce(function (closest, domino) { var distance = Math.sqrt(Math.pow(domino.x - pos.x, 2) + Math.pow(domino.y - pos.y, 2)); if (distance < closest.distance) { return { domino: domino, distance: distance }; } else { return closest; } }, { domino: null, distance: Infinity }); // Tip the closest domino if it is within 100 units of the tap position if (closestDomino.distance < 100) { closestDomino.domino.tip(null, true); } });