/**** * Plugins ****/ var tween = LK.import("@upit/tween.v1"); var storage = LK.import("@upit/storage.v1"); /**** * Classes ****/ var Block = Container.expand(function (color, width) { var self = Container.call(this); // Default values if not provided color = color || 0x3498db; width = width || 512; // Create block graphics var blockGraphics = self.attachAsset('block', { anchorX: 0.5, anchorY: 0.5, width: width, tint: color }); // State tracking self.placed = false; self.originalWidth = width; self.fallDirection = 0; // 0: none, -1: left, 1: right self.movementSpeed = 8; self.movementDirection = 1; // 1: right, -1: left self.scale.y = 0; self.targetY = 0; self.initialY = 0; // Resize the block (used when block partially falls off) self.resize = function (newWidth, offsetX) { if (newWidth <= 0) { return; } // Immediately set the width to match exactly without animation blockGraphics.width = newWidth; // Update the original width to reflect the new truncated size self.originalWidth = newWidth; if (offsetX !== undefined) { // Immediately update position self.x += offsetX; } }; // Drop the block into position with animation self.dropIntoPlace = function (targetYPos) { self.targetY = targetYPos; self.initialY = self.y; // First expand the y-scale tween(self.scale, { y: 1 }, { duration: 400, easing: tween.bounceOut }); // Then animate moving down to its target position tween(self, { y: targetYPos }, { duration: 500, easing: tween.bounceOut }); }; // Update method called every frame self.update = function () { if (!self.placed) { // Move block back and forth self.x += self.movementSpeed * self.movementDirection; // Check if we need to change direction if (self.x > 2048 - self.originalWidth / 2) { self.movementDirection = -1; } else if (self.x < self.originalWidth / 2) { self.movementDirection = 1; } } else if (self.fallDirection !== 0) { // If block is set to fall, make it fall and rotate self.y += 15; self.rotation += 0.1 * self.fallDirection; // Remove the block when it's off-screen if (self.y > 2732 + 200) { self.destroy(); } } }; return self; }); var Fruit = Container.expand(function (type) { var self = Container.call(this); // Define fruit types and their properties - now as berry types var fruitTypes = { apple: { width: 60, height: 60, color: 0xe74c3c, shape: 'ellipse' }, banana: { width: 70, height: 70, color: 0xf1c40f, shape: 'ellipse' }, orange: { width: 55, height: 55, color: 0xf39c12, shape: 'ellipse' }, grape: { width: 45, height: 45, color: 0x9b59b6, shape: 'ellipse' }, watermelon: { width: 65, height: 65, color: 0x2ecc71, shape: 'ellipse' } }; // Set default if type not provided or invalid type = fruitTypes[type] ? type : 'apple'; // Initialize fruit properties var props = fruitTypes[type]; // Create main berry shape var fruitGraphics = self.attachAsset('fruit', { anchorX: 0.5, anchorY: 0.5, tint: props.color, width: props.width, height: props.height, alpha: 0.85 }); // Add a subtle glow effect tween(fruitGraphics, { alpha: 0.95 }, { duration: 1000 + Math.random() * 500, easing: tween.easeInOut, repeat: -1, yoyo: true }); // Add movement properties self.speedY = 2 + Math.random() * 3; self.speedX = (Math.random() * 2 - 1) * 2; self.rotationSpeed = Math.random() * 0.04 - 0.02; self.width = props.width; self.height = props.height; // Track last position for collision detection self.lastY = self.y; self.lastX = self.x; self.value = 0; switch (type) { case 'apple': self.value = 1; break; case 'banana': self.value = 2; break; case 'orange': self.value = 5; break; case 'grape': self.value = 3; break; case 'watermelon': self.value = 10; break; } // Update method called every frame self.update = function () { // Store last position self.lastY = self.y; self.lastX = self.x; // Move fruit self.y -= self.speedY; self.x += self.speedX; // Rotate fruit self.rotation += self.rotationSpeed; // Bounce off walls if (self.x < self.width / 2 || self.x > 2048 - self.width / 2) { self.speedX *= -1; } // Remove if off screen at top if (self.y < -100) { self.destroy(); } }; return self; }); var ScoreDisplay = Container.expand(function () { var self = Container.call(this); // Background for score var background = self.attachAsset('scoreBackground', { anchorX: 0.5, anchorY: 0.5, alpha: 0.7 }); // Score text self.scoreText = new Text2('0', { size: 60, fill: 0xFFFFFF }); self.scoreText.anchor.set(0.5, 0.5); self.addChild(self.scoreText); // Height text self.heightText = new Text2('Height: 0m', { size: 30, fill: 0xFFFFFF }); self.heightText.anchor.set(0.5, 0.5); self.heightText.y = 50; self.addChild(self.heightText); // Update score display self.updateScore = function (score, height) { self.scoreText.setText(score.toString()); self.heightText.setText('Height: ' + height.toFixed(1) + 'm'); }; return self; }); /**** * Initialize Game ****/ var game = new LK.Game({ backgroundColor: 0x000000 // Black background }); /**** * Game Code ****/ // Set real background with gradient game.setBackgroundColor(0x1e3c72); // Deep blue gradient start // Game state variables var score = 0; var towerHeight = 0; var gameActive = true; var level = 1; var blockSpeed = 8; var perfectMatches = 0; var blockColors = [0x3498db, // Blue 0xe74c3c, // Red 0x2ecc71, // Green 0xf39c12, // Orange 0x9b59b6, // Purple 0x1abc9c // Turquoise ]; // Background and music variables var backgrounds = []; var currentBackground = 0; var musicTracks = ['backgroundMusic', 'backgroundMusic1', 'backgroundMusic2']; var currentMusicTrack = 0; var backgroundChangeInterval = 22 * 60; // 22 seconds at 60fps var backgroundChangeTimer = 0; var backgroundUpdateTimer = 0; // Fruit variables var fruits = []; var fruitTypes = ['apple', 'banana', 'orange', 'grape', 'watermelon']; var lastFruitTime = 0; var fruitGenerationRate = 120; // frames between fruit generation // Game objects var blocks = []; var currentBlock = null; var baseFloor = null; var scoreDisplay = null; var lastBlockPosition = { x: 2048 / 2, width: 512 }; var dropY = 200; // Starting Y position for dropping blocks // Setup backgrounds and transition to next background function setupBackgrounds() { // Create all three backgrounds var bg1 = LK.getAsset('background1', { anchorX: 0.5, anchorY: 0.5, alpha: 0 }); bg1.x = 2048 / 2; bg1.y = 2732 / 2; var bg2 = LK.getAsset('background2', { anchorX: 0.5, anchorY: 0.5, alpha: 0 }); bg2.x = 2048 / 2; bg2.y = 2732 / 2; var bg3 = LK.getAsset('background3', { anchorX: 0.5, anchorY: 0.5, alpha: 0 }); bg3.x = 2048 / 2; bg3.y = 2732 / 2; // Add backgrounds to game and array game.addChild(bg1); game.addChild(bg2); game.addChild(bg3); backgrounds = [bg1, bg2, bg3]; // Show first background tween(backgrounds[0], { alpha: 1 }, { duration: 800, easing: tween.easeOut }); } // Change to next background function changeBackground() { var nextBg = (currentBackground + 1) % backgrounds.length; // Fade out current background tween(backgrounds[currentBackground], { alpha: 0 }, { duration: 1200, easing: tween.easeInOut }); // Fade in next background tween(backgrounds[nextBg], { alpha: 1 }, { duration: 1200, easing: tween.easeInOut }); currentBackground = nextBg; // Do not update music track here to avoid interrupting current music } // Change music to match current background function changeMusic() { // Each background has its associated music track // This function is no longer needed as we handle music transitions // in the onMusicEnd callback to ensure music is not interrupted } // Initialize the game function initGame() { // Setup backgrounds setupBackgrounds(); // Create base floor with animation baseFloor = LK.getAsset('baseFloor', { anchorX: 0.5, anchorY: 0.5, alpha: 0 }); baseFloor.x = 2048 / 2; baseFloor.y = 2732 - 300; baseFloor.scale.x = 0.5; game.addChild(baseFloor); // Animate the base floor appearing tween(baseFloor, { alpha: 1 }, { duration: 800, easing: tween.easeOut }); tween(baseFloor.scale, { x: 1 }, { duration: 800, easing: tween.elasticOut }); // Set last block position to be above the base floor (not overlapping) // Use the baseFloor width as the initial width for the first block lastBlockPosition = { x: baseFloor.x, width: baseFloor.width, // The first block will have the same width as baseFloor y: baseFloor.y - baseFloor.height / 2 // Position above the baseFloor with no overlap }; // Initialize score display with animation scoreDisplay = new ScoreDisplay(); scoreDisplay.x = 2048 / 2; scoreDisplay.y = -50; // Start off-screen scoreDisplay.alpha = 0; game.addChild(scoreDisplay); // Add "Glaud" text in the upper right corner var glaudText = new Text2('Glaud', { size: 54, fill: 0xFF8800 // Orange color for "Glaud" }); glaudText.anchor.set(1, 0); // Anchor to top right glaudText.x = 2048 - 20; // 20px from right edge glaudText.y = 20; // 20px from top edge glaudText.alpha = 0.7; // Slightly transparent game.addChild(glaudText); // Animate score display tween(scoreDisplay, { y: 100, alpha: 1 }, { duration: 800, easing: tween.easeOut }); // Reset game state variables score = 0; towerHeight = 0; gameActive = true; level = 1; blockSpeed = 8; perfectMatches = 0; blocks = []; fruits = []; lastFruitTime = 0; backgroundChangeTimer = 0; // Set the drop Y position to be above the base floor (not overlapping) dropY = baseFloor.y - baseFloor.height; // Create first block with a slight delay for better game flow LK.setTimeout(function () { createNewBlock(); }, 500); // Play only the first music track, the others will play sequentially currentMusicTrack = 0; LK.playMusic(musicTracks[currentMusicTrack], { loop: false, fade: { start: 0, end: 1, duration: 1000 } }); } // Create a new block to drop function createNewBlock() { if (!gameActive) { return; } // Choose a random color that's different from the last block var color; do { color = blockColors[Math.floor(Math.random() * blockColors.length)]; } while (blocks.length > 0 && blocks[blocks.length - 1].tint === color && blockColors.length > 1); // Use the width from lastBlockPosition directly - this is already properly updated after cutting var topBlockWidth = lastBlockPosition.width; // Create new block with the exact width of the last block position currentBlock = new Block(color, topBlockWidth); currentBlock.x = lastBlockPosition.x; // Position at the same x as the last block currentBlock.y = lastBlockPosition.y - currentBlock.height; // Position above the last block with no overlap currentBlock.movementSpeed = blockSpeed; // Scale initially set to 0 in y axis (will animate in) currentBlock.scale.y = 0; // Add block to the game and blocks array game.addChild(currentBlock); blocks.push(currentBlock); // Animate the block entry - already positioned correctly, just need a small animation tween(currentBlock, { y: currentBlock.y + 5 // Small bounce effect }, { duration: 500, easing: tween.bounceOut }); // Animate the scale of the block tween(currentBlock.scale, { y: 1 }, { duration: 400, easing: tween.easeOut }); // Apply a subtle shadow effect if (blocks.length > 1) { // Get reference to the top block in the tower var topBlock = null; for (var i = blocks.length - 2; i >= 0; i--) { if (blocks[i].placed && !blocks[i].fallDirection) { topBlock = blocks[i]; break; } } if (topBlock) { // Slight tint adjustment to create shadow effect on blocks beneath tween(topBlock, { alpha: 0.9 }, { duration: 500, easing: tween.linear }); } } } // Handle game clicks/taps function handleTap() { if (!currentBlock || !gameActive) { return; } // Calculate overlap with previous block var overlapLeft = Math.max(lastBlockPosition.x - lastBlockPosition.width / 2, currentBlock.x - currentBlock.originalWidth / 2); var overlapRight = Math.min(lastBlockPosition.x + lastBlockPosition.width / 2, currentBlock.x + currentBlock.originalWidth / 2); var overlapWidth = overlapRight - overlapLeft; // If blocks don't overlap at all, game over if (overlapWidth <= 0) { gameOver(); return; } // Play place block sound LK.getSound('placeBlock').play(); // Mark the block as placed currentBlock.placed = true; // Calculate the new position and width for the current block var newCenterX = overlapLeft + overlapWidth / 2; var newWidth = overlapWidth; // Handle partial block if (newWidth < currentBlock.originalWidth) { // Determine which side falls off var fallBlockWidth = currentBlock.originalWidth - newWidth; var fallBlock = new Block(currentBlock.tint, fallBlockWidth); if (currentBlock.x < newCenterX) { // Left part falls off fallBlock.x = overlapLeft - fallBlockWidth / 2; fallBlock.fallDirection = -1; currentBlock.resize(newWidth, newCenterX - currentBlock.x); } else { // Right part falls off fallBlock.x = overlapRight + fallBlockWidth / 2; fallBlock.fallDirection = 1; currentBlock.resize(newWidth, newCenterX - currentBlock.x); } fallBlock.y = currentBlock.y; fallBlock.placed = true; fallBlock.scale.y = 1; game.addChild(fallBlock); blocks.push(fallBlock); // Animate falling block with rotation tween(fallBlock, { rotation: fallBlock.fallDirection * Math.PI * 0.5 }, { duration: 800, easing: tween.easeIn }); // Play falling sound LK.getSound('fallBlock').play(); } else { // Perfect match! perfectMatches++; LK.getSound('perfectMatch').play(); // Enhanced visual effect for perfect match LK.effects.flashObject(currentBlock, 0xFFFFFF, 300); // Extra animation to emphasize perfect match tween(currentBlock.scale, { x: 1.1, y: 1.05 }, { duration: 150, easing: tween.easeOut, onFinish: function onFinish() { tween(currentBlock.scale, { x: 1, y: 1 }, { duration: 150, easing: tween.bounceOut }); } }); } // Smoothly move the current block to its final position tween.stop(currentBlock, { x: true }); tween(currentBlock, { x: newCenterX }, { duration: 300, easing: tween.easeOut }); // Calculate score based on match accuracy var accuracy = newWidth / currentBlock.originalWidth; var blockScore = Math.round(accuracy * 100); // Perfect bonus if (accuracy >= 0.95) { blockScore += 50; } score += blockScore; // Update tower height (each block adds height) towerHeight += currentBlock.height / 150; // Convert to "meters" // Update last block position for next block // Store the new width after cutting for the next block to be sized correctly lastBlockPosition = { x: newCenterX, // Use the new center position after resizing width: newWidth, // Use the exact new width after cutting y: currentBlock.y - currentBlock.height // Position above with no overlap }; // Update score display scoreDisplay.updateScore(score, towerHeight); // Move the tower down if it's getting too high if (currentBlock.y < 2732 / 2) { var shiftAmount = 100; for (var i = 0; i < blocks.length; i++) { if (blocks[i].placed && !blocks[i].fallDirection) { // Animate the shift tween.stop(blocks[i], { y: true }); tween(blocks[i], { y: blocks[i].y + shiftAmount }, { duration: 400, easing: tween.easeInOut }); } } lastBlockPosition.y += shiftAmount; } // Increase difficulty based on tower height increaseGameDifficulty(); // Create a new block with a slight delay for better game flow LK.setTimeout(function () { createNewBlock(); }, 300); } // Increase game difficulty as tower gets higher function increaseGameDifficulty() { // Increase movement speed based on tower height level = Math.floor(towerHeight / 10) + 1; blockSpeed = 8 + level; // Every 5 levels, reduce block width by 10% (min 30% of original) var widthReduction = Math.min(0.7, 1 - Math.floor(level / 5) * 0.1); lastBlockPosition.width = Math.max(150, baseFloor.width * widthReduction); } // Game over function function gameOver() { gameActive = false; // Play falling sound LK.getSound('fallBlock').play(); // Make current block fall with enhanced animation if (currentBlock) { currentBlock.fallDirection = currentBlock.x > 2048 / 2 ? 1 : -1; // Enhance the fall animation with tween tween(currentBlock, { y: currentBlock.y + 300, rotation: currentBlock.fallDirection * Math.PI }, { duration: 1000, easing: tween.easeIn }); } // Create a cascade effect where blocks fall one after another var fallDelay = 100; for (var i = blocks.length - 2; i >= 0; i--) { // Only animate placed blocks that aren't already falling if (blocks[i].placed && blocks[i].fallDirection === 0) { // Determine random fall direction var dir = Math.random() > 0.5 ? 1 : -1; // Create closure to preserve the block reference (function (block, delay, direction) { LK.setTimeout(function () { block.fallDirection = direction; // Add tween animation for falling tween(block, { y: block.y + 300, rotation: direction * Math.PI * (0.5 + Math.random() * 0.5) }, { duration: 800 + Math.random() * 400, easing: tween.easeIn }); }, delay); })(blocks[i], fallDelay * (blocks.length - i), dir); } } // Flash screen with animation LK.effects.flashScreen(0xff0000, 500); // Show game over after a 5 second delay LK.setTimeout(function () { LK.showGameOver(); }, 5000); } // Function to handle music end and play next track function onMusicEnd() { currentMusicTrack = (currentMusicTrack + 1) % musicTracks.length; LK.playMusic(musicTracks[currentMusicTrack], { loop: false, fade: { start: 0, end: 1, duration: 1000 } }); } // Listen for music end event to chain tracks LK.onMusicEnd = onMusicEnd; // Game tick update game.update = function () { // Update all blocks for (var i = blocks.length - 1; i >= 0; i--) { if (blocks[i]) { blocks[i].update(); } } // Change backgrounds at 22-second intervals instead of by tower height backgroundChangeTimer++; if (gameActive && backgroundChangeTimer >= backgroundChangeInterval) { backgroundChangeTimer = 0; changeBackground(); } // Background transition effect timer backgroundUpdateTimer++; if (backgroundUpdateTimer >= 300) { // Every 5 seconds backgroundUpdateTimer = 0; // Subtle animation for active background var activeBg = backgrounds[currentBackground]; tween(activeBg.scale, { x: 1.05, y: 1.05 }, { duration: 2000, easing: tween.easeInOut, onFinish: function onFinish() { tween(activeBg.scale, { x: 1.0, y: 1.0 }, { duration: 2000, easing: tween.easeInOut }); } }); } // Generate fruits periodically when game is active if (gameActive && LK.ticks - lastFruitTime > fruitGenerationRate) { lastFruitTime = LK.ticks; // Generate multiple berries at once for a richer background effect var batchSize = 1 + Math.floor(Math.random() * 3); // Generate 1-3 berries at once for (var b = 0; b < batchSize; b++) { // Create a random fruit var fruitType = fruitTypes[Math.floor(Math.random() * fruitTypes.length)]; var fruit = new Fruit(fruitType); // Position at bottom of screen with random x fruit.x = Math.random() * 2048; fruit.y = 2732 + 50 + Math.random() * 100; // Vary initial height // Vary initial velocity for more natural movement fruit.speedY = 1.5 + Math.random() * 2.5; fruit.speedX = (Math.random() * 2 - 1) * 2; // Scale randomly for variety var scale = 0.8 + Math.random() * 0.4; fruit.scale.set(scale, scale); // Add to game game.addChild(fruit); fruits.push(fruit); } // Adjust generation rate based on level (faster fruit generation at higher levels) fruitGenerationRate = Math.max(50, 100 - level * 5); } // Update fruits and check for collisions for (var i = fruits.length - 1; i >= 0; i--) { if (fruits[i]) { fruits[i].update(); // Check if fruit has been tapped if (fruits[i].tapped) { // Add points based on fruit value score += fruits[i].value; scoreDisplay.updateScore(score, towerHeight); // Remove the fruit fruits[i].destroy(); fruits.splice(i, 1); } // Remove if off screen if (fruits[i] && fruits[i].y < -100) { fruits[i].destroy(); fruits.splice(i, 1); } } } }; // Event handlers game.down = function (x, y, obj) { // First check if we tapped on a fruit var fruitTapped = false; for (var i = 0; i < fruits.length; i++) { // Convert tap position to fruit's parent coordinates // Check if parent exists before calling toLocal var localPos; if (fruits[i] && fruits[i].parent) { localPos = fruits[i].parent.toLocal({ x: x, y: y }); } else { localPos = { x: x, y: y }; // Fallback if parent doesn't exist } // Check if tap is within fruit bounds (slightly larger hit area for better UX) if (Math.abs(localPos.x - fruits[i].x) < fruits[i].width * 0.6 && Math.abs(localPos.y - fruits[i].y) < fruits[i].height * 0.6) { // Mark fruit as tapped fruits[i].tapped = true; // Enhanced visual effects for tapped fruit LK.effects.flashObject(fruits[i], 0xFFFFFF, 150); // Create a burst animation effect tween(fruits[i].scale, { x: fruits[i].scale.x * 1.5, y: fruits[i].scale.y * 1.5 }, { duration: 150, easing: tween.easeOut }); // Also make it fade out tween(fruits[i], { alpha: 0 }, { duration: 200, easing: tween.easeOut }); fruitTapped = true; break; } } // If no fruit was tapped, handle normal block tap if (!fruitTapped) { handleTap(); } }; // Initialize the game initGame();