/**** * Plugins ****/ var tween = LK.import("@upit/tween.v1"); var storage = LK.import("@upit/storage.v1", { highScore: 0 }); /**** * Classes ****/ var NonPerfectMessage = Container.expand(function () { var self = Container.call(this); var messageText = new Text2('Bad timing', { size: 120, fill: 0xFF0000, stroke: 0xffffff, strokeThickness: 8 }); messageText.anchor.set(0.5, 0.5); self.addChild(messageText); self.alpha = 1; self.scale.set(0.1); self.lifespan = 60; // 1 second at 60fps self.initialized = false; self.creationTime = Date.now(); // Track when message was created self.init = function () { if (self.initialized) { return; } self.initialized = true; // First tween: grow from small to large tween(self.scale, { x: 1.0, y: 1.0 }, { duration: 300, easing: tween.easeOut, onComplete: function onComplete() { // Second tween: wait a bit then fade out LK.setTimeout(function () { tween(self, { alpha: 0 }, { duration: 300, easing: tween.easeIn, onComplete: function onComplete() { // Find and remove from perfectMessages array var index = perfectMessages.indexOf(self); if (index > -1) { perfectMessages.splice(index, 1); } // Remove from game first before destroying if (self.parent) { self.parent.removeChild(self); } self.destroy(); } }); }, 600); } }); }; self.update = function () { if (!self.initialized) { self.init(); } // Manual animation as fallback if tweens fail if (!self.initialized) { self.lifespan--; if (self.lifespan <= 0) { // Find and remove from perfectMessages array var index = perfectMessages.indexOf(self); if (index > -1) { perfectMessages.splice(index, 1); } self.destroy(); return; } // Animation effect if (self.lifespan > 45) { // Growing phase self.scale.set(0.1 + (1.0 - 0.1) * (1 - (self.lifespan - 45) / 15)); } else if (self.lifespan < 15) { // Fading out phase self.alpha = self.lifespan / 15; } } }; return self; }); var Palm = Container.expand(function () { var self = Container.call(this); var palmGraphics = self.attachAsset('palm', { anchorX: 0.5, anchorY: 0.5 }); self.width = palmGraphics.width; self.height = palmGraphics.height; self.isMoving = false; self.direction = "left"; // Default direction self.lastY = 0; self.update = function () { // Animation will be handled by tweens // This just ensures we have an update method for tracking }; return self; }); var PerfectMessage = Container.expand(function () { var self = Container.call(this); var messageText = new Text2('PERFECT! +2!', { size: 120, fill: 0xFFF000, stroke: 0xFF0000, strokeThickness: 8 }); messageText.anchor.set(0.5, 0.5); self.addChild(messageText); self.alpha = 1; self.scale.set(0.1); self.lifespan = 60; // 1 second at 60fps self.initialized = false; self.creationTime = Date.now(); // Track when message was created self.init = function () { if (self.initialized) { return; } self.initialized = true; // First tween: grow from small to large tween(self.scale, { x: 1.0, y: 1.0 }, { duration: 300, easing: tween.easeOut, onComplete: function onComplete() { // Second tween: wait a bit then fade out LK.setTimeout(function () { tween(self, { alpha: 0 }, { duration: 300, easing: tween.easeIn, onComplete: function onComplete() { // Find and remove from perfectMessages array var index = perfectMessages.indexOf(self); if (index > -1) { perfectMessages.splice(index, 1); } // Remove from game first before destroying if (self.parent) { self.parent.removeChild(self); } self.destroy(); } }); }, 600); } }); }; self.update = function () { if (!self.initialized) { self.init(); } // Manual animation as fallback if tweens fail if (!self.initialized) { self.lifespan--; if (self.lifespan <= 0) { // Find and remove from perfectMessages array var index = perfectMessages.indexOf(self); if (index > -1) { perfectMessages.splice(index, 1); } self.destroy(); return; } // Animation effect if (self.lifespan > 45) { // Growing phase self.scale.set(0.1 + (1.0 - 0.1) * (1 - (self.lifespan - 45) / 15)); } else if (self.lifespan < 15) { // Fading out phase self.alpha = self.lifespan / 15; } } }; return self; }); var PlayerCar = Container.expand(function () { var self = Container.call(this); var carGraphics = self.attachAsset('playerCar', { anchorX: 0.5, anchorY: 0.5 }); self.width = carGraphics.width; self.height = carGraphics.height; self.speed = 0; self.maxSpeed = 15; self.steering = 0; self.crashed = false; self.lastX = 0; self.bubble = null; self.crash = function () { if (!self.crashed) { self.crashed = true; // 1. First, play the crash sound LK.getSound('crash').play(); // 2. Second, mirror vertically the player Car carGraphics.scaleY = -1; // Flash effect for visual feedback LK.effects.flashObject(self, 0xFF0000, 1000); // 3. Stop the game by setting speed to 0 self.speed = 0; // 4. After 2 seconds, show GameOver LK.setTimeout(function () { LK.showGameOver(); }, 2000); } }; self.update = function () { // Save last position for movement detection self.lastX = self.x; // Handle car physics if (!self.crashed) { self.speed = Math.min(self.maxSpeed, self.speed + 0.1); } // Apply steering if not crashed if (!self.crashed) { self.x += self.steering; } // Keep car within bounds if (self.x < self.width / 2) { self.x = self.width / 2; } if (self.x > 2048 - self.width / 2) { self.x = 2048 - self.width / 2; } // Check if car has moved horizontally and has a bubble if (Math.abs(self.x - self.lastX) > 0.1 && self.bubble && self.bubble.parent) { // Remove bubble immediately when car moves if (self.bubble.parent) { self.bubble.parent.removeChild(self.bubble); } self.bubble.destroy(); self.bubble = null; } }; return self; }); var RoadLine = Container.expand(function () { var self = Container.call(this); var lineGraphics = self.attachAsset('bullet', { anchorX: 0.5, anchorY: 0.5 }); self.width = lineGraphics.width; self.height = lineGraphics.height; self.isMoving = false; self.lastY = 0; self.update = function () { // Animation will be handled by tweens // This just ensures we have an update method for tracking }; return self; }); // RoadLine class removed as requested var TrafficCar = Container.expand(function () { var self = Container.call(this); // Randomly select one of the available traffic car assets var carAssets = ['trafficCar', 'trafficCar2', 'trafficCar3', 'trafficCar4']; var selectedCarAsset = carAssets[Math.floor(Math.random() * carAssets.length)]; self.direction = Math.random() > 0.5 ? 1 : -1; // Random direction: -1 = left, 1 = right var carGraphics = self.attachAsset(selectedCarAsset, { anchorX: 0.5, anchorY: 0.5, x: self.direction == -1 ? 0 : 200 }); self.width = carGraphics.width; self.height = carGraphics.height; self.speed = 0.1 * level * SPEED_LEVEL_FACTOR; self.direction = Math.random() > 0.5 ? 1 : -1; // Random direction: -1 = left, 1 = right self.startY = 1300; // Starting Y position (further up the screen) self.targetY = 2732 + self.height; // Y position when fully off-screen (bottom) self.initialScale = 0.1; self.targetScale = 2.0; // Set target X position in one of the specified ranges self.targetX = Math.random() > 0.5 ? Math.random() * 500 + 2000 : Math.random() * 100; // Set initial scale self.scale.set(self.initialScale); self.update = function () { // Calculate progress towards target Y var progress = (self.y - self.startY) / (self.targetY - self.startY); progress = Math.max(0, Math.min(1, progress)); // Clamp between 0 and 1 // Interpolate scale based on progress var currentScale = self.initialScale + (self.targetScale - self.initialScale) * progress; self.scale.set(currentScale); // Calculate X position based on progress (linear interpolation) var startX = 2048 / 2; // Center of screen self.x = startX + (self.targetX - startX) * progress; // Apply level-based speed increase self.speed += progress * level * SPEED_LEVEL_FACTOR; // Update Y position with speed that increases as the car grows self.y += self.speed; // Destroy if off screen if (self.y > self.targetY) { // Check against targetY // Find and remove self from trafficCars array var index = trafficCars.indexOf(self); if (index > -1) { trafficCars.splice(index, 1); // Check for perfect timing - if honk was within 1 second (1000ms) before or after car disappears var currentTime = Date.now(); var timeDifference = Math.abs(currentTime - lastHonkTime); if (timeDifference <= 500 * 2 / Math.min(3, level)) { // Perfect timing! Add 2 extra points LK.setScore(LK.getScore() + 3); // +1 for normal disappearance, +2 for perfect timing // Create and display perfect message var perfectMsg = new PerfectMessage(); perfectMsg.x = centerX; perfectMsg.y = centerY; perfectMsg.creationTime = Date.now(); // Set creation time game.addChild(perfectMsg); perfectMessages.push(perfectMsg); // Explicitly call init to ensure animation starts immediately perfectMsg.init(); } else if (timeDifference > 500 * 2 / Math.min(3, level) && lastHonkTime > 0 && lastHonkTime > currentTime - 3000) { // Bad timing! Show a non-perfect message only if honk was played AFTER this car crossed // (checking if honk happened within last 3 seconds to ensure it relates to this car) var nonPerfectMsg = new NonPerfectMessage(); nonPerfectMsg.x = centerX; nonPerfectMsg.y = centerY; nonPerfectMsg.creationTime = Date.now(); // Set creation time game.addChild(nonPerfectMsg); perfectMessages.push(nonPerfectMsg); // Add to the same array for cleanup // Explicitly call init to ensure animation starts immediately nonPerfectMsg.init(); // Normal score increment LK.setScore(LK.getScore() + 1); } else { // Normal score increment LK.setScore(LK.getScore() + 1); } scoreText.setText(LK.getScore().toString()); scoreText.setStyle({ tint: 0xffffff, stroke: 0xffffff, strokeThickness: 5 }); // List of available sounds excluding crash var sounds = ['blind', 'getOff', 'holdingTraffic', 'learnToDrive', 'license', 'moveOver', 'speedUp', 'whatAreYouDoing']; // Get current last played sound from game variable or initialize it var lastPlayedSound = game.lastPlayedSound || ''; // Filter out the last played sound if it exists var availableSounds = sounds.filter(function (sound) { return sound !== lastPlayedSound; }); // Select a random sound from the filtered list var randomSound = availableSounds[Math.floor(Math.random() * availableSounds.length)]; // Store the selected sound as the last played sound game.lastPlayedSound = randomSound; // Play the selected sound LK.getSound(randomSound).play(); // Check if player already has a bubble if (player.bubble && player.bubble.parent) { player.bubble.parent.removeChild(player.bubble); player.bubble.destroy(); } // Show bubble over player car var bubble = LK.getAsset('bubble', { anchorX: 0.5, anchorY: 1.0, x: player.x, y: player.y - player.height / 2 }); game.addChild(bubble); bubble.scale.set(0); // Store reference to the bubble in player object player.bubble = bubble; // Store creation time for auto-cleanup bubble.creationTime = Date.now(); // Animate the bubble appearing and disappearing tween(bubble.scale, { x: 0.8, y: 0.8 }, { duration: 200, easing: tween.easeOut, onComplete: function onComplete() { // Wait for 0.3 seconds then fade out (this happens if no movement removed it) LK.setTimeout(function () { // Check if bubble still exists and hasn't been removed by movement if (bubble && bubble.parent) { tween(bubble, { alpha: 0 }, { duration: 200, easing: tween.easeIn, onComplete: function onComplete() { if (bubble.parent) { bubble.parent.removeChild(bubble); } bubble.destroy(); // Clear reference in player if (player.bubble === bubble) { player.bubble = null; } } }); } }, 800); // Increased to ensure bubble shows for 1 second total } }); } self.destroy(); } }; return self; }); /**** * Initialize Game ****/ var game = new LK.Game({ backgroundColor: 0x000000 }); /**** * Game Code ****/ // Game state variables var gameStarted = false; var gameTime = 30; // Initial time in seconds var distance = 0; var level = 1; var checkpointDistance = 500; // Distance between checkpoints var nextCheckpointAt = checkpointDistance; var trafficCars = []; var obstacles = []; var checkpoints = []; var timeBonuses = []; var difficultyTimer; var lastHonkTime = 0; // Track when player last honked var perfectMessages = []; // Array to store perfect timing messages // Create container groups var palmGroup = new Container(); var roadLinesGroup = new Container(); var SPEED_LEVEL_FACTOR = 3; // Create road lines var ROAD_LINE_COUNT = 15; var roadLines = []; var BASE_ROAD_LINE_COOLDOWN = 20; // Base spawn cooldown var roadLineSpawnCooldown = 20; // Spawn a road line every 0.33 seconds if needed var roadLineSpawnTimer = 0; // Timer to track cooldown // Create palm trees var PALM_COUNT = 40; var palms = []; var centerX = 2048 / 2; // Center of screen X var centerY = 2732 / 2; // Center of screen Y var BASE_PALM_COOLDOWN = 10; // Base spawn cooldown var palmSpawnCooldown = 10; // Spawn a palm every 0.5 seconds if needed var palmSpawnTimer = 0; // Timer to track cooldown var lastSpawnSide = "right"; // Track the last side a palm was spawned on // Sway parameters var swayCounter = 0; // Create road var road = LK.getAsset('road', { anchorX: 0.5, anchorY: 0.5, x: 2048 / 2 + 50, y: 2732 / 2 - 100 // y: 1000 }); game.addChild(road); game.addChild(palmGroup); game.addChild(roadLinesGroup); // Road lines removed as requested // Create player car var player = new PlayerCar(); player.x = 2048 / 2; player.y = 2732 - 300; game.addChild(player); var scoreLabel = new Text2('Score:', { size: 80, fill: 0xFFFFFF, stroke: 0xFFFFFF, strokeThickness: 5 }); scoreLabel.anchor.set(0, 0); scoreLabel.x = -150; LK.gui.top.addChild(scoreLabel); var scoreText = new Text2('0', { size: 80, fill: 0xFFFFFF, stroke: 0xFFFFFF, strokeThickness: 5 }); scoreText.anchor.set(0, 0); scoreText.x = 100; LK.gui.top.addChild(scoreText); var levelLabel = new Text2('Level:', { size: 80, fill: 0xFFFFFF, stroke: 0xFFFFFF, strokeThickness: 5 }); levelLabel.anchor.set(0, 0); levelLabel.x = -150; levelLabel.y = 100; // Offset below time LK.gui.top.addChild(levelLabel); var levelText = new Text2('1', { size: 80, fill: 0xFFFFFF, stroke: 0xFFFFFF, strokeThickness: 5 }); levelText.anchor.set(0, 0); levelText.x = 100; levelText.y = 100; // Offset below time LK.gui.top.addChild(levelText); var startText = new Text2('TAP TO START\nTAP TO 🔊\nPERFECTLY TIMED 🔊 = +2', { size: 120, fill: 0xFFFFFF, stroke: 0xFFFFFF, strokeThickness: 8, align: 'center' }); startText.anchor.set(0.5, 0.5); LK.gui.center.addChild(startText); // Functions to spawn game elements function spawnTrafficCar() { // Only spawn a new car if there are no cars on screen if (trafficCars.length === 0) { var car = new TrafficCar(); car.x = 2048 / 2; // Start in the middle of the screen car.y = car.startY; // Start at the defined startY car.speed = 0.1 * level * SPEED_LEVEL_FACTOR; trafficCars.push(car); game.addChild(car); } // Schedule next check for spawning with faster spawns at higher levels var nextSpawnTime = Math.max(200, 1000 / level); // Faster spawns at higher levels LK.setTimeout(spawnTrafficCar, nextSpawnTime); } // Start game function function startGame() { gameStarted = true; gameTime = 30; distance = 0; level = 1; // Initial level starts at 1 nextCheckpointAt = checkpointDistance; LK.setScore(0); // Initialize road lines with pre-animated positions as if they had already been running for 10 seconds roadLines = []; for (var i = 0; i < roadLinesGroup.children.length; i++) { roadLinesGroup.children[i].destroy(); } roadLinesGroup.removeChildren(); roadLineSpawnTimer = 0; // Create pre-existing road lines as if they were already running for 10 seconds for (var i = 0; i < ROAD_LINE_COUNT; i++) { var newRoadLine = new RoadLine(); // Calculate a position along the animation path as if it had been running // Progress ranges from 0 (just started) to 1 (almost finished) var progress = i / ROAD_LINE_COUNT; // Start at center X and interpolate Y based on progress newRoadLine.x = centerX + 15; // Calculate Y position - from center-50 to beyond bottom of screen var startY = centerY - 50; var targetY = 2732 + 100; newRoadLine.y = startY + (targetY - startY) * progress; // Calculate scale based on progress (0.1 to 1.0) var startScale = 0.1; var endScale = 1.0; var currentScale = startScale + (endScale - startScale) * progress; newRoadLine.scale.set(currentScale); newRoadLine.lastY = newRoadLine.y; newRoadLine.isMoving = true; // Only add the road line and start animation if it's still on screen if (newRoadLine.y < 2732) { // Create tween animation with perspective effect - already in progress var remainingDuration = 4000 * (1 - progress) / level; tween(newRoadLine, { y: targetY, scaleX: endScale, scaleY: endScale }, { duration: remainingDuration, easing: tween.easeIn }); roadLines.push(newRoadLine); roadLinesGroup.addChild(newRoadLine); } else { newRoadLine.destroy(); } } // Update UI scoreText.setText('0'); levelText.setText(level.toString()); levelText.setStyle({ tint: 0xffffff, stroke: 0xffffff, strokeThickness: 5 }); // Remove start text LK.gui.center.removeChild(startText); // Start spawning game elements spawnTrafficCar(); // Level is now calculated based on score/10+1, no need for a timer to increase it // Play background music LK.playMusic('bgmusic'); // Palm spawning is handled in the update function } // Handle touch input game.down = function (x, y) { // Only play honk sound if game has started if (!gameStarted) { startGame(); return; } // Play honk sound when screen is clicked/tapped after game has started LK.getSound('honk').play(); // Record the time of honk for perfect timing detection lastHonkTime = Date.now(); // Remove any existing bubble when player honks if (player.bubble && player.bubble.parent) { player.bubble.parent.removeChild(player.bubble); player.bubble.destroy(); player.bubble = null; } }; game.move = function (x, y) { if (!gameStarted) { return; } // Move player car directly to mouse X position var targetX = x; // Apply smooth movement by calculating the difference var deltaX = targetX - player.x; player.steering = deltaX * 0.1; // Smooth movement factor }; game.up = function () { if (gameStarted) { // No need to reset steering as we'll continue to follow mouse } }; // Main game update function game.update = function () { if (!gameStarted) { return; } // Update road lines if (gameStarted) { // Update road line animations for (var r = roadLines.length - 1; r >= 0; r--) { var roadLine = roadLines[r]; // Check if roadLine exists before accessing its properties if (roadLine) { roadLine.lastY = roadLine.y; // Start a new roadLine animation if roadLine is not already moving if (roadLine.isMoving === false) { roadLine.isMoving = true; // Set target position - straight down the screen var targetY = 2732 + 100; // Below bottom of screen var targetScale = 1.0; // End larger // Create tween animation with perspective effect tween(roadLine, { y: targetY, scaleX: targetScale, scaleY: targetScale }, { duration: 4000 / level, easing: tween.easeIn }); } // Check if roadLine has moved significantly past the bottom of the screen and destroy it var destroyYPosition = 2732 - 300; // Check if center is below the bottom edge if (roadLine.isMoving && roadLine.y > destroyYPosition) { // RoadLine is off-screen, destroy it var index = roadLines.indexOf(roadLine); if (index > -1) { roadLinesGroup.removeChild(roadLine); roadLines.splice(index, 1); roadLine.destroy(); } // Skip to next roadLine as this one is destroyed continue; } } } // End of loop processing existing road lines // Calculate spawn cooldown based on level roadLineSpawnCooldown = Math.max(5, BASE_ROAD_LINE_COOLDOWN / level); // Update road line spawn timer and generate new road lines if needed roadLineSpawnTimer -= 1; if (roadLineSpawnTimer <= 0 && roadLines.length < ROAD_LINE_COUNT) { roadLineSpawnTimer = roadLineSpawnCooldown; // Reset timer var newRoadLine = new RoadLine(); // Start at center X and at center Y newRoadLine.x = centerX + 15; newRoadLine.y = centerY - 50; newRoadLine.scale.set(0.1); // Start small newRoadLine.lastY = newRoadLine.y; newRoadLine.isMoving = false; // Flag to track if road line is currently animating roadLines.push(newRoadLine); roadLinesGroup.addChild(newRoadLine); } } // Road lines removed as requested // Update game time gameTime -= 1 / 60; // Assuming 60 FPS // Calculate level based on score/10, but minimum of 1 level = Math.floor(LK.getScore() / 10) + 1; levelText.setText(level.toString()); // Update palm animations section if (gameStarted) { distance += 10 + level; // Don't update score based on distance anymore // Keep updating the distance for internal calculations if needed // Update palm animations for (var p = palms.length - 1; p >= 0; p--) { var palm = palms[p]; // Check if palm exists before accessing its properties if (palm) { palm.lastY = palm.y; // Start a new palm animation if palm is not already moving if (palm.isMoving === false) { palm.isMoving = true; // Set target position based on direction (left or right corner) var targetX = palm.direction === "left" ? -12000 : 14500; // Left or right edge var targetY = 2732 + 100; // Below bottom of screen var targetScale = 2.0; // End larger // Create tween animation with perspective effect - use same duration for all palms tween(palm, { x: targetX, y: targetY, scaleX: targetScale * (lastSpawnSide === "right" ? 1 : -1), scaleY: targetScale }, { duration: 7000 / level, // Duration decreases as level increases easing: tween.easeIn // Removed onFinish callback }); } // Check if palm has moved significantly past the bottom of the screen and destroy it var destroyYPosition = 2500; // Check if center is 150px below the bottom edge if (palm.isMoving && palm.y > destroyYPosition) { // Palm is off-screen, destroy it var index = palms.indexOf(palm); if (index > -1) { palmGroup.removeChild(palm); palms.splice(index, 1); palm.destroy(); } // Skip to next palm as this one is destroyed continue; } } } // End of loop processing existing palms // Calculate palm spawn cooldown based on level palmSpawnCooldown = Math.max(3, BASE_PALM_COOLDOWN / level); // Update palm spawn timer and generate new palms if needed palmSpawnTimer -= 1; if (palmSpawnTimer <= 0 && palms.length < PALM_COUNT) { palmSpawnTimer = palmSpawnCooldown; // Reset timer var newPalm = new Palm(); // Alternate spawn side based on the last spawned side lastSpawnSide = lastSpawnSide === "right" ? "left" : "right"; // Start from exact center point newPalm.x = centerX + (lastSpawnSide === "right" ? 50 : -50); newPalm.y = centerY - 100; // Start at center newPalm.scale.set(0.005); // Start small newPalm.scaleX *= lastSpawnSide === "right" ? 1 : -1; newPalm.lastY = newPalm.y; newPalm.direction = lastSpawnSide; // Use the determined side newPalm.isMoving = false; // Flag to track if palm is currently animating palms.push(newPalm); palmGroup.addChild(newPalm); } } // Game will continue indefinitely - removed game over condition gameTime = Math.max(gameTime, 0.1); // Keep time from reaching zero // Update perfect messages for (var m = perfectMessages.length - 1; m >= 0; m--) { perfectMessages[m].update(); } // Check for old perfect and non-perfect messages every 2 seconds if (LK.ticks % 60 === 0) { var currentTime = Date.now(); for (var i = perfectMessages.length - 1; i >= 0; i--) { // If message is older than 2 seconds and still exists if (perfectMessages[i] && perfectMessages[i].creationTime && currentTime - perfectMessages[i].creationTime > 500) { // Remove from game if it's still attached if (perfectMessages[i].parent) { perfectMessages[i].parent.removeChild(perfectMessages[i]); } // Destroy and remove from array perfectMessages[i].destroy(); perfectMessages.splice(i, 1); } } // Check for speech bubble timing if (player.bubble && player.bubble.creationTime && currentTime - player.bubble.creationTime > 1000) { // Remove bubble if it's been showing for more than 1 second if (player.bubble.parent) { player.bubble.parent.removeChild(player.bubble); } player.bubble.destroy(); player.bubble = null; } } // Check collisions with traffic cars for (var i = trafficCars.length - 1; i >= 0; i--) { var car = trafficCars[i]; if (player.intersects(car) && !player.crashed) { player.crash(); trafficCars.splice(i, 1); car.destroy(); // GameOver will be called after the crash sequence } } }; function endGame() { if (!gameStarted) { return; } // Just save high score without ending the game if (LK.getScore() > storage.highScore) { storage.highScore = LK.getScore(); } // Game continues - no game over screen }