/**** * Classes ****/ var Butterfly = Container.expand(function () { var self = Container.call(this); var butterflyTypes = ['GreenButterfly', 'PinkButterfly', 'YellowButterfly']; var selectedType = butterflyTypes[Math.floor(Math.random() * butterflyTypes.length)]; var butterflyGraphics = self.attachAsset(selectedType, { anchorX: 0.5, anchorY: 0.5 }); // Initialize butterfly properties self.speedX = -2; // Speed of the butterfly moving left self.flitAmplitude = 20; // Amplitude of the flitting motion self.flitFrequency = 0.1; // Frequency of the flitting motion self.startY = Math.random() * (2732 * 0.6) + 2732 * 0.2; // Random Y position within midground tree layer self.update = function () { // Move the butterfly left self.x += self.speedX * gameSpeed; // Apply flitting motion self.y = self.startY + Math.sin(self.x * self.flitFrequency) * self.flitAmplitude; // Simulate wing flapping by adjusting scale var flapScale = 0.2 * Math.sin(LK.ticks * 0.3) + 1; butterflyGraphics.scale.set(flapScale); // Destroy the butterfly if it goes off screen if (self.x < -butterflyGraphics.width / 2) { self.destroy(); } }; }); var Coin = Container.expand(function () { var self = Container.call(this); var coinGraphics = self.attachAsset('Coin', { anchorX: 0.5, anchorY: 0.5 }); // Initialize coin properties self.rotationSpeed = 0.05; // Rotation speed for the coin self.speedX = -5; // Speed of the coin moving left self.collecting = false; // Flag to check if the coin is being collected self.targetX = 0; // Target X position for collection animation self.targetY = 0; // Target Y position for collection animation self.update = function () { // Generate GoldSparkle particles if (Math.random() < 0.0525) { var sparkle = new GoldSparkle(); sparkle.x = self.x + (Math.random() * coinGraphics.width - coinGraphics.width / 2); sparkle.y = self.y + (Math.random() * coinGraphics.height - coinGraphics.height / 2); sparkle.coin = self; // Associate sparkle with the coin game.addChild(sparkle); } // Move the coin left self.x += self.speedX * gameSpeed; // Apply spin effect over Y axis coinGraphics.scale.x = Math.sin(self.x * 0.015); if (coot && coot.isMagnetActive && !self.collecting && self.x < 2048 * 0.9) { // Home in on Coot's location self.targetX = coot.x; self.targetY = coot.y; self.collecting = true; } if (self.collecting) { // Animate coin collection self.x += (self.targetX - self.x) * 0.1; self.y += (self.targetY - self.y) * 0.1; coinGraphics.scale.x *= 0.90; coinGraphics.scale.y *= 0.90; // Check if the coin has reached the target position or is small enough if (Math.abs(self.x - self.targetX) < 5 && Math.abs(self.y - self.targetY) < 5 || coinGraphics.scale.x < 0.1 && coinGraphics.scale.y < 0.1) { // Destroy all sparkles attached to the coin game.children.forEach(function (child) { if (child instanceof GoldSparkle && child.coin === self) { child.destroy(); } }); self.destroy(); coinCount++; coinCounter.setText(Math.min(coinCount, 999).toString()); coinIcon.x = -coinCounter.width - 10; // Update coin icon position to hug the coin counter // Check if 100 coins have been collected if (coinCount % 100 === 0) { // Add a heart icon and refill or add a life if (coot.lives < 3) { coot.lives++; heartIcons[coot.lives - 1].alpha = 1; // Restore the heart icon } } return; } } else if (self.x < -coinGraphics.width / 2) { // Destroy the coin if it goes off screen self.destroy(); } }; }); var CollisionBlock = Container.expand(function () { var self = Container.call(this); var collisionBlockGraphics = self.attachAsset('Collisionblock', { anchorX: 0.5, anchorY: 0.5, alpha: 0 }); }); // Assets will be automatically created and loaded by the LK engine based on their usage in the code. // Example assets: 'coot', 'obstacle', 'background' // Class for the main character, the American coot var Coot = Container.expand(function () { var self = Container.call(this); var cootGraphics = self.attachAsset('coot', { anchorX: 0.5, anchorY: 0.5 }); self.originalX = self.x; // Store original X position self.speed = 6.5; self.dashSpeed = 15; self.lives = 3; // Initialize Coot with three lives self.dashDelay = 30; self.isFalling = false; self.isDashing = false; self.fallRotation = 0; // Initialize fall rotation self.dashTimer = 0; self.jumpVelocity = 40; // Increased initial upward velocity for jump self.gravity = 1.0; // Gravity to apply during jump self.jumpHeight = 105; self.isJumping = false; self.isReturning = false; // New state to handle returning to top after diving self.isInvincible = false; // Initialize invincible state self.isShielded = false; // Initialize shielded state self.isMagnetActive = false; // Initialize magnet state self.isWarningActive = false; // Initialize warning state self.isPowerDashActive = false; // Initialize PowerDash state self.hasPhoenixFeather = false; // Initialize Phoenix Feather state self.powerUpTimers = { 'CoinMagnet': { endTime: 0 }, 'PowerDash': { endTime: 0 }, 'Warning': { endTime: 0 } }; self.update = function () { if (self.isJumping) { self.y -= self.jumpVelocity; self.jumpVelocity -= self.gravity; if (self.jumpVelocity <= 0) { self.isJumping = false; self.isFalling = true; self.fallStartY = self.y; self.fallRotation = 0; self.fallSpeed = 5; } } else if (self.isFalling) { handleFalling(); } else if (self.isDiving) { handleDiving(); } else if (self.returnDelay > 0) { handleReturnDelay(); } else if (self.isReturning) { handleReturning(); } // Define state key mapping for power-ups var stateKeyMap = { 'CoinMagnet': 'isMagnetActive', 'PowerDash': 'isPowerDashActive', 'Warning': 'isWarningActive' }; // Check power-up timers for (var powerUpType in self.powerUpTimers) { if (self.powerUpTimers.hasOwnProperty(powerUpType)) { var timer = self.powerUpTimers[powerUpType]; if (Date.now() >= timer.endTime) { var stateKey = stateKeyMap[powerUpType]; if (self[stateKey]) { self[stateKey] = false; // Deactivate the power-up console.log(powerUpType + " power-up deactivated"); } } } } function handleFalling() { if (self.lives <= 0) { self.y -= self.fallSpeed; self.fallRotation += 0.05; cootGraphics.rotation = -self.fallRotation; if (self.y <= self.fallStartY - 50) { self.fallSpeed = -10; } if (self.y > 2732) { LK.showGameOver(); } } else { self.y += self.gravity * 10; // Increase gravity effect during fall if (self.y >= self.originalY) { self.y = self.originalY; self.isFalling = false; self.jumpVelocity = 40; self.isJumping = false; } cootGraphics.rotation = 0; } } function handleDiving() { self.y += self.speed * 1.5; cootGraphics.alpha = Math.max(0.5, cootGraphics.alpha - 0.05); cootGraphics.tint = 0x0000ff; if (self.y >= 2732 * 0.90) { self.y = 2732 * 0.90; self.isDiving = false; self.returnDelay = Date.now() + 1000; } } function handleReturnDelay() { if (Date.now() >= self.returnDelay) { self.returnDelay = 0; if (self.y >= 2732 * 0.90) { self.isReturning = true; } } } function handleReturning() { self.y -= self.speed * 1.5; var transitionFactor = 1 - (self.y - self.originalY) / (2732 * 0.90 - self.originalY); cootGraphics.alpha = 0.5 + 0.5 * transitionFactor; var startTint = self.underwaterTint; var endTint = 0xffffff; var r = (startTint >> 16 & 0xff) + ((endTint >> 16 & 0xff) - (startTint >> 16 & 0xff)) * transitionFactor; var g = (startTint >> 8 & 0xff) + ((endTint >> 8 & 0xff) - (startTint >> 8 & 0xff)) * transitionFactor; var b = (startTint & 0xff) + ((endTint & 0xff) - (startTint & 0xff)) * transitionFactor; cootGraphics.tint = (r << 16) + (g << 8) + b; if (self.y <= self.originalY) { self.y = self.originalY; self.isReturning = false; cootGraphics.alpha = 1.0; cootGraphics.tint = 0xffffff; } if (self.isReturning) { self.x += (self.originalX - self.x) * 0.1; } } // Add wobble effect to the coot while running if (!self.isJumping && !self.isDiving && !self.isReturning && !self.isFalling) { cootGraphics.rotation = Math.sin(LK.ticks / 5) * 0.1; // Increase wobble speed by reducing the divisor // Generate 1-2 water splash particles every 60 ticks (1 second) only when not jumping, diving, or falling if (!self.isJumping && !self.isDiving && !self.isFalling && LK.ticks % 60 == 0) { var numParticles = Math.floor(Math.random() * 2) + 1; for (var i = 0; i < numParticles; i++) { var splashLeft = new Splash(); splashLeft.x = self.x - cootGraphics.width / 2; splashLeft.y = self.y + cootGraphics.height / 2; game.addChildAt(splashLeft, game.getChildIndex(foreground1) - 1); var splashRight = new Splash(); splashRight.x = self.x + cootGraphics.width / 2; splashRight.y = self.y + cootGraphics.height / 2; game.addChildAt(splashRight, game.getChildIndex(foreground1) - 1); } } } // Handle dash state if (self.isDashing) { if (self.dashTimer < self.dashDelay) { // Dash forward if (self.x < 2048 * 0.75) { // Stop at 3/4 of screen width self.x += self.dashSpeed * 1.1; } // Create echo trail effect only if PowerDash is active if (self.isPowerDashActive) { var echo = new EchoTrail(); echo.x = self.x; echo.y = self.y; game.addChild(echo); } self.dashTimer++; } else { var returnSpeed = 10; // Fixed return speed self.x += Math.sign(self.originalX - self.x) * Math.min(returnSpeed, Math.abs(self.originalX - self.x)); if (Math.abs(self.x - self.originalX) < returnSpeed) { self.x = self.originalX; self.isDashing = false; self.dashTimer = 0; } } } // Ensure smooth return to original position if falling and returning from a dash if (self.isFalling && self.isReturning) { var returnSpeed = 10; // Fixed return speed self.x += Math.sign(self.originalX - self.x) * Math.min(returnSpeed, Math.abs(self.originalX - self.x)); if (Math.abs(self.x - self.originalX) < returnSpeed) { self.x = self.originalX; self.isReturning = false; } } }; self.isDiving = false; self.isDashing = false; self.dashSpeed = 15; self.dashDelay = 60; self.dashTimer = 0; self.originalX = self.x; self.jump = function () { if (canPerformAction()) { self.isJumping = true; self.originalX = self.x; self.isReturning = false; self.originalY = self.y; } }; self.dash = function () { if (canPerformAction()) { self.isDashing = true; self.originalX = self.x; self.dashTimer = 0; } }; self.dive = function () { if (canPerformAction()) { self.isDiving = true; self.returnDelay = Date.now() + 5000; self.isReturning = false; self.underwaterTint = 0x4444ff; self.originalX = self.x; self.originalY = self.y; self.y += self.speed * 2; generateSplashParticles(2, 4); } }; function canPerformAction() { return !self.isJumping && !self.isDiving && !self.isReturning && !self.isDashing; } function generateSplashParticles(min, max) { var numParticles = Math.floor(Math.random() * (max - min + 1)) + min; for (var i = 0; i < numParticles; i++) { var splash = new Splash(); splash.x = self.x; splash.y = self.y + cootGraphics.height / 2; game.addChildAt(splash, game.getChildIndex(foreground1) - 1); } } }); var DayCountDisplay = Container.expand(function () { var self = Container.call(this); var dayText = new Text2('Day ' + DayCount, { size: 100, fill: "#ffffff" }); dayText.anchor.set(0.5, 0.5); dayText.alpha = 0; // Set alpha to 0 by default self.addChild(dayText); self.show = function () { dayText.setText('Day ' + DayCount); dayText.alpha = 1; LK.setTimeout(function () { dayText.alpha = 0; // Set alpha back to 0 instead of destroying }, 1500); // Set a timer to make the day count display visible for 3 seconds every time the day count increases LK.setTimeout(function () { dayText.alpha = 1; LK.setTimeout(function () { dayText.alpha = 0; }, 1500); }, 1500); }; }); var DuckWarningIcon = Container.expand(function () { var self = Container.call(this); var iconGraphics = self.attachAsset('DuckIcon', { anchorX: 0.5, anchorY: 0.5, alpha: 0.75 }); self.flashInterval = 0; self.update = function () { self.flashInterval++; if (coot.isWarningActive) { if (self.flashInterval % 30 < 15) { iconGraphics.alpha = 0.75; } else { iconGraphics.alpha = 0.5; } } else { iconGraphics.alpha = 0; } }; }); var EagleFeather = Container.expand(function () { var self = Container.call(this); var featherGraphics = self.attachAsset('Eaglefeather', { anchorX: 0.5, anchorY: 0.5 }); // Initialize feather properties self.rotationSpeed = Math.random() * 0.02 - 0.01; // Random rotation speed self.driftX = Math.random() * 2 - 1; // Random sideways drift self.driftY = Math.random() * -1 - 0.5; // Upward drift self.fadeRate = 0.005; // Fade out rate self.update = function () { self.x += self.driftX * gameSpeed; self.y += self.driftY * gameSpeed; featherGraphics.rotation += self.rotationSpeed; featherGraphics.alpha -= self.fadeRate; // Destroy feather when fully faded if (featherGraphics.alpha <= 0) { self.destroy(); } }; }); var EagleWarningIcon = Container.expand(function () { var self = Container.call(this); var iconGraphics = self.attachAsset('EagleIcon', { anchorX: 0.5, anchorY: 0.5, alpha: 0.75 }); self.flashInterval = 0; self.update = function () { self.flashInterval++; if (coot.isWarningActive) { if (self.flashInterval % 30 < 15) { iconGraphics.alpha = 0.75; } else { iconGraphics.alpha = 0.5; } } else { iconGraphics.alpha = 0; } }; }); var EchoTrail = Container.expand(function () { var self = Container.call(this); var echoGraphics = self.attachAsset('coot', { anchorX: 0.5, anchorY: 0.5, alpha: 0.5 // Set initial transparency }); self.fadeRate = 0.05; // Rate at which the echo fades self.update = function () { echoGraphics.alpha -= self.fadeRate; if (echoGraphics.alpha <= 0) { self.destroy(); } }; }); var Firefly = Container.expand(function () { var self = Container.call(this); var fireflyGraphics = self.attachAsset('Firefly', { anchorX: 0.5, anchorY: 0.5 }); // Initialize firefly properties self.speedX = Math.random() * 8 - 4; // Further increased random horizontal speed self.speedY = Math.random() * 8 - 4; // Further increased random vertical speed self.fadeRate = 0.005; // Much slower fade rate for slow pulsing self.flickerTimer = Math.random() * 240 + 120; // Random flicker timer between 2 to 4 seconds self.alphaDirection = 1; // Direction of alpha change (1 for fade in, -1 for fade out) self.lifetime = Math.random() * 180 + 180; // Random lifetime between 3 to 5 seconds self.update = function () { // Move the firefly self.x += self.speedX; self.y += self.speedY; // Create trail effect var trail = new FireflyTrail(); trail.x = self.x; trail.y = self.y; game.addChild(trail); // Loop around the screen if (self.x < 0) { self.x = 2048; } if (self.x > 2048) { self.x = 0; } if (self.y < 0) { self.y = 2732; } if (self.y > 2732) { self.y = 0; } // Flicker effect self.flickerTimer--; if (self.flickerTimer <= 0) { fireflyGraphics.alpha = Math.random(); // Random alpha for flicker self.flickerTimer = Math.random() * 60 + 30; // Reset flicker timer } // Fade in and out fireflyGraphics.alpha += self.fadeRate * self.alphaDirection; if (fireflyGraphics.alpha <= 0 || fireflyGraphics.alpha >= 1) { self.alphaDirection *= -1; // Reverse fade direction } // Destroy firefly after its lifetime self.lifetime--; if (self.lifetime <= 0) { self.destroy(); } }; }); var FireflyTrail = Container.expand(function () { var self = Container.call(this); var trailGraphics = LK.getAsset('FireflyTrail', { anchorX: 0.5, anchorY: 0.5, alpha: 1 // Initial transparency }); self.fadeRate = 0.02; // Rate at which the trail fades self.update = function () { trailGraphics.alpha -= self.fadeRate; if (trailGraphics.alpha <= 0) { self.destroy(); } }; }); var FishWarningIcon = Container.expand(function () { var self = Container.call(this); var iconGraphics = self.attachAsset('FishIcon', { anchorX: 0.5, anchorY: 0.5, alpha: 0.75 }); self.flashInterval = 0; self.update = function () { self.flashInterval++; if (coot.isWarningActive) { if (self.flashInterval % 30 < 15) { iconGraphics.alpha = 0.75; } else { iconGraphics.alpha = 0.5; } } else { iconGraphics.alpha = 0; } }; }); // Define a single obstacleTypes array as a constant // Class for the foreground var Foreground = Container.expand(function () { var self = Container.call(this); var foregroundGraphics = self.attachAsset('Foreground', { anchorX: 0.5, anchorY: 0.5 }); self.speed = 5; self.isFirst = false; // Will be set during initialization self.update = function () { // Only move the first piece if (self.isFirst) { self.x -= self.speed * gameSpeed; // Apply gameSpeed to movement // Move second piece to maintain fixed distance self.other.x = self.x + self.width; // Reset both pieces when first goes off screen if (self.x < -self.width / 1.5) { // Reset earlier - when piece is mostly off screen self.x += self.width; self.other.x = self.x + self.width; } } }; }); var GoldSparkle = Container.expand(function () { var self = Container.call(this); var sparkleGraphics = self.attachAsset('GoldSparkle', { anchorX: 0.5, anchorY: 0.5 }); self.speedX = (Math.random() * 2 - 1) * 0.75; // Reduced horizontal speed by 25% self.speedY = (Math.random() * 2 - 1) * 0.75; // Reduced vertical speed by 25% self.fadeRate = 0.02; // Rate at which the sparkle fades self.update = function () { self.x += self.speedX; self.y += self.speedY; sparkleGraphics.alpha -= self.fadeRate; if (sparkleGraphics.alpha <= 0) { self.destroy(); } }; }); var InstructionsButton = Container.expand(function () { var self = Container.call(this); var instructionsButtonGraphics = self.attachAsset('InstructionsButton', { anchorX: 0.5, anchorY: 0.5 }); self.down = function () { gameLogo.visible = false; if (gameLogo.playButton) { gameLogo.playButton.visible = false; } if (gameLogo.instructionsButton) { gameLogo.instructionsButton.visible = false; } showInstructions(); }; }); var InstructionsScreen = Container.expand(function () { var self = Container.call(this); var instructionsText = new Text2('Swipe up to jump,\ndown to dive,\nand right to dash!', { size: 80, fill: "#ffffff", align: "center" }); instructionsText.anchor.set(0.5, 0); instructionsText.x = 2048 / 2; instructionsText.y = 2732 * 0.15; self.addChild(instructionsText); // Add power-up icons and explanations var powerUpsInfo = [{ type: 'CoinMagnet', text: 'Coin Magnet: Attracts coins' }, { type: 'Shield', text: 'Shield: Protects from one hit' }, { type: 'PhoenixFeather', text: 'Phoenix Feather: Revive once' }, { type: 'PowerDash', text: 'Power Dash: Dash while jumping or diving' }, { type: 'Warning', text: 'Warning: Alerts of upcoming obstacles' }]; powerUpsInfo.forEach(function (info, index) { var icon = LK.getAsset(info.type, { anchorX: 0.5, anchorY: 0.5, x: 2048 / 2 - 300 - 2048 * 0.10, // Move icons further left y: 2732 * 0.30 + index * 200 }); self.addChild(icon); var text = new Text2(info.text, { size: 60, fill: "#ffffff", align: "left" }); text.anchor.set(0, 0.5); text.x = 2048 / 2 - 300 + 2048 * 0.035 - 2048 * 0.07; text.y = icon.y + 20; self.addChild(text); }); var instructionDetails = new Text2('Jump over the Duck,\nDive away from the Eagle/Owl,\nDash away from the Fish.\n100 Coot Coins = 1 heart.', { size: 70, fill: "#ffffff", align: "center" }); instructionDetails.anchor.set(0.5, 0); instructionDetails.x = 2048 / 2; instructionDetails.y = 2732 * 0.66; // Move up by 5% from the original position self.addChild(instructionDetails); var backButton = new Text2('Back', { size: 100, fill: "#ffffff", fontWeight: "bold" }); backButton.anchor.set(0.5, 0.5); backButton.x = 2048 / 2; backButton.y = 2732 * 0.88; // Move back button down by 1.5% self.addChild(backButton); backButton.down = function () { self.menuBackground.destroy(); // Remove the MenuBackground self.destroy(); isTitleScreen = true; gameLogo.visible = true; if (gameLogo.playButton) { gameLogo.playButton.visible = true; } if (gameLogo.instructionsButton) { gameLogo.instructionsButton.visible = true; } }; }); // Class for the midgroundtrees var Midgroundtrees = Container.expand(function () { var self = Container.call(this); var midgroundtreesGraphics = self.attachAsset('Midgroundtrees', { anchorX: 0.5, anchorY: 0.7 }); self.speed = 3; self.update = function () { self.x -= self.speed * gameSpeed; // self.y = coot.y; if (self.x <= -self.width / 2) { self.x += self.width * 2; } }; }); var Moon = Container.expand(function () { var self = Container.call(this); var moonGraphics = self.attachAsset('Moon', { anchorX: 0.5, anchorY: 0.5 }); // Initialize moon properties self.startX = -moonGraphics.width / 2; // Start off-screen to the left self.startY = 2732 * 0.25; // 25% from the top self.endX = 2048 + moonGraphics.width / 2; // End off-screen to the right self.arcHeight = 2732 * 0.1; // Arc height self.duration = 2 * 60 * 60; // 2 minutes in ticks (assuming 60 FPS) self.ticks = 0; self.update = function () { self.ticks++; var progress = self.ticks / self.duration; self.x = self.startX + (self.endX - self.startX) * progress; self.y = self.startY - Math.sin(progress * Math.PI) * self.arcHeight; // Calculate fade threshold and apply smooth fade based on moon's position var fadeThreshold = 0.8; // Start fade at 80% of moon's journey if (progress >= fadeThreshold) { var fadeProgress = (progress - fadeThreshold) / (1 - fadeThreshold); nightBackground.alpha = 1 - fadeProgress; } // Destroy the moon when it goes off-screen to the right if (self.x > self.endX) { self.destroy(); // Switch to day state isDay = true; isNight = false; DayCount += 1; // Increase day count by 1 dayCountDisplay.show(); // Show day count display // Stop spawning fireflies if (fireflySpawnInterval) { LK.clearInterval(fireflySpawnInterval); fireflySpawnInterval = null; } game.addChild(new Sun()); } }; }); // Moved Owl logic into Obstacle class var Obstacle = Container.expand(function (type) { var self = Container.call(this); var graphics; var collisionBlock = self.addChild(new CollisionBlock()); collisionBlock.x = 0; collisionBlock.y = 0; graphics = self.attachAsset(type, { anchorX: 0.5, anchorY: 0.5 }); // Add a Ripple instance to the Duck obstacle if (type === 'Duck') { self.lastRippleTime = Date.now(); var ripple = new Ripple(); ripple.x = 0; // Center the ripple on the Duck ripple.y = graphics.height / 2; // Position the ripple at the bottom of the Duck self.addChildAt(ripple, 0); // Add ripple below the Duck but above the water layer } self.speedX = -6; if (type === 'Fish') { self.isJumping = false; self.pauseTime = 0; graphics.tint = 0x4444ff; graphics.alpha = 0.7; } if (type === 'Fish') { self.speedX = -6; // Back to original fast swimming speed self.jumpSpeed = 0.05; // Slow jump speed control self.isJumping = false; self.isPausing = false; self.pauseTime = 0; self.lastSplashTime = Date.now(); // Add splash timer graphics.tint = 0x4444ff; // Set underwater blue tint initially graphics.alpha = 0.7; // Set underwater opacity initially self.isFalling = false; self.jumpVelocity = 0; self.jumpStartY = self.y; // Store original position self.jumpTime = 0; // Initialize jump time counter self.y = 2732 * 0.90; // Set Fish Y position to the bottom of the Coot's dive } if (type === 'Eagle') { self.lastFeatherTime = Date.now(); self.targetY = coot.isDiving || coot.isReturning ? coot.originalY : coot.y; self.speedY = (self.targetY - self.y) / 100; self.speedX = -8; // Add horizontal speed variable for eagle } if (type === 'Owl') { self.speedX = -6; // Speed of the owl moving left self.speedY = 0; // Initial vertical speed self.x = 2048 + graphics.width / 2; // Spawn at the top right of the screen self.isDiving = false; // Initialize isDiving state self.hasDived = false; // Initialize hasDived state to false by default } self.update = function () { self.x += self.speedX * gameSpeed; if (type === 'Fish') { // Move horizontally self.x += self.speedX; // Generate underwater splash effects if (!self.isJumping && Date.now() - self.lastSplashTime >= 200) { // Generate every 200ms var numSplashes = Math.floor(Math.random() * 2) + 1; // 1-2 splashes for (var i = 0; i < numSplashes; i++) { var splash = new Splash(); splash.x = self.x + (Math.random() * graphics.width - graphics.width / 2); // Random position along fish body splash.y = self.y; splash.tint = 0x4444ff; // Match fish's underwater tint game.addChildAt(splash, game.getChildIndex(self) - 1); } self.lastSplashTime = Date.now(); } // Check if crossing under Coot if (self.x <= coot.x && !self.isJumping) { self.speedX = 0; graphics.alpha = 0; self.pauseTime += 0.02; // Increase pause time by reducing increment rate } // Add this check for when to reappear if (self.pauseTime >= 1 && !self.isJumping) { graphics.alpha = 1; graphics.rotation = Math.PI / 2; // Changed from -Math.PI/2 to rotate the other way self.isJumping = true; self.jumpStartY = self.y; self.jumpTime = 0; } // Handle jumping motion if (self.isJumping) { self.jumpTime += self.jumpSpeed; // Use slower jumpSpeed var jumpHeight = -Math.sin(self.jumpTime) * 864; // Increased by 20% from 720 to 864 self.y = self.jumpStartY + jumpHeight; // Generate bigger splash burst when jumping out if (self.jumpTime < 0.1) { // Only on first frame of jump var burstSplashes = Math.floor(Math.random() * 4) + 6; // 6-9 splashes (increased from 4-6) for (var i = 0; i < burstSplashes; i++) { var splash = new Splash(); splash.x = self.x + (Math.random() * graphics.width - graphics.width / 2); splash.y = self.jumpStartY - Math.random() * 200; // Make splashes go higher game.addChildAt(splash, game.getChildIndex(self) - 1); } } // Change tint based on height above water if (self.y < self.jumpStartY - 50) { graphics.tint = 0xffffff; // Normal color above water graphics.alpha = 1.0; } else { graphics.tint = 0x4444ff; // Blue tint in water graphics.alpha = 0.7; } if (self.jumpTime > Math.PI) { Obstacle.lastDestroyTime = Date.now(); console.log("Fish destroyed after jump at " + Date.now()); currentObstacle = null; // Add this line self.destroy(); } } // Normal destroy check if (self.x <= -self.width / 2) { self.destroy(); Obstacle.lastDestroyTime = Date.now(); } } else if (type === 'Eagle') { self.y += self.speedY; if (Date.now() - self.lastFeatherTime >= 900) { // Feather spawn every 900ms var numFeathers = Math.floor(Math.random() * 2) + 2; // Spawn 2-3 feathers for (var i = 0; i < numFeathers; i++) { var feather = new EagleFeather(); feather.x = self.x + (Math.random() * 20 - 10); // Slight horizontal variation feather.y = self.y + graphics.height / 2; game.addChildAt(feather, game.getChildIndex(self) - 1); } self.lastFeatherTime = Date.now(); } if (self.x <= -self.width / 2) { console.log("Checking for destruction: Eagle at " + self.x); self.destroy(); // Destroy the obstacle when it moves off-screen Obstacle.lastDestroyTime = Date.now(); // Set lastDestroyTime when destroyed console.log("Obstacle destroyed at " + Obstacle.lastDestroyTime); } if (type === 'Eagle') { self.targetY = coot.originalY - coot.height / 2; // Aim slightly higher on the coot self.speedY = (self.targetY - self.y) / (50 / gameSpeed); } } else if (type === 'Duck') { // Add sinusoidal wave pattern travel for Duck if (type === 'Duck') { self.y += Math.sin(self.x * 0.00625) * 2.7; // Adjusted sinusoidal wave pattern with further reduced frequency and increased amplitude } // Ripple spawn logic if (Date.now() - self.lastRippleTime >= 500) { var ripple = new Ripple(); ripple.x = self.x; ripple.y = self.y + graphics.height / 2; game.addChildAt(ripple, game.getChildIndex(self) - 1); self.lastRippleTime = Date.now(); } // Existing destroy logic if (self.x <= -self.width / 2) { console.log("Checking for destruction: Duck at " + self.x); self.destroy(); Obstacle.lastDestroyTime = Date.now(); console.log("Obstacle destroyed at " + Obstacle.lastDestroyTime); } } else if (type === 'Owl') { if (coot) { if (!self.isDiving && self.x > coot.x) { self.x += self.speedX * gameSpeed; // Move Owl left until it reaches Coot's X position } else { if (!self.hasDived) { self.isDiving = true; // Set isDiving state if (coot.intersects(collisionBlock)) { self.hasDived = true; // Set hasDived state only on intersection with Coot } self.speedX = 0; // Stop left movement if (!coot.isDiving) { self.speedY = (coot.y - self.y) / 40; // Adjust speed to track Coot's Y position at half speed self.y += self.speedY * gameSpeed; // Move Owl towards Coot self.x += (coot.x - self.x) / 20 * gameSpeed; // Move Owl towards Coot's X position } if (self.y >= coot.originalY) { self.isDiving = false; // Remove isDiving state self.speedX = -6; // Set speed to fly away to the left self.speedY = -3; // Add upward movement } else if (self.isDiving) { var shadowClone = new ShadowClone(); shadowClone.x = self.x; shadowClone.y = self.y; game.addChild(shadowClone); } } } // Check if Coot's state requires Owl to fly off if (self.isDiving && (coot.isDiving || coot.isReturning || coot.returnDelay > 0 || coot.intersects(collisionBlock))) { self.isDiving = false; // Remove isDiving state self.speedX = -6; // Set speed to fly away to the left self.speedY = -3; // Add upward movement self.x += self.speedX * gameSpeed; self.y += self.speedY * gameSpeed; // Move Owl upwards as it flies away if (self.x < -self.width / 2) { self.destroy(); // Remove Owl from the game when off-screen } } } } collisionBlock.x = 0; collisionBlock.y = 0; }; }); var OwlWarningIcon = Container.expand(function () { var self = Container.call(this); var iconGraphics = self.attachAsset('OwlIcon', { anchorX: 0.5, anchorY: 0.5, alpha: 0.75 }); self.flashInterval = 0; self.update = function () { self.flashInterval++; if (coot.isWarningActive) { if (self.flashInterval % 30 < 15) { iconGraphics.alpha = 0.75; } else { iconGraphics.alpha = 0.5; } } else { iconGraphics.alpha = 0; } }; }); var PhoenixFeatherIcon = Container.expand(function () { var self = Container.call(this); var iconGraphics = self.attachAsset('PhoenixFeatherIcon', { anchorX: 0.5, anchorY: 0.5, alpha: 0.2 // Start dim, not opaque }); self.update = function () { iconGraphics.alpha = coot && coot.hasPhoenixFeather ? 1 : 0.2; // Set alpha based on possession }; }); var PlayButton = Container.expand(function () { var self = Container.call(this); var playButtonGraphics = self.attachAsset('PlayButton', { anchorX: 0.5, anchorY: 0.5 }); self.down = function () { // Exit title screen isTitleScreen = false; // Slide out all elements var slideOutInterval = LK.setInterval(function () { gameLogo.x += 50; self.x += 50; if (gameLogo.instructionsButton) { gameLogo.instructionsButton.x += 50; } if (gameLogo.x > 2048 + gameLogo.width / 2) { LK.clearInterval(slideOutInterval); self.destroy(); if (gameLogo.instructionsButton) { gameLogo.instructionsButton.destroy(); } // Start game after animations startGame(); } }, 16); }; }); var PowerUp = Container.expand(function (type) { var self = Container.call(this); var powerUpGraphics = self.attachAsset(type, { anchorX: 0.5, anchorY: 0.5 }); // Initialize power-up properties self.speedX = -5; // Speed of the power-up moving left self.collected = false; // Flag to check if the power-up is collected self.update = function () { // Add pulsating effect var pulseScale = 0.05 * Math.sin(LK.ticks * 0.1) + 1; powerUpGraphics.scale.set(pulseScale); // Add bobbing effect self.y += Math.sin(LK.ticks * 0.05) * 0.5; // Move the power-up left self.x += self.speedX * gameSpeed; // Check for collection by the Coot if (!self.collected && coot.intersects(self)) { if (type === 'PhoenixFeather' && coot.hasPhoenixFeather || type === 'Shield' && coot.isShielded) { return; // Do not collect if already active } self.collected = true; activatePowerUp(type); self.destroy(); } // Destroy the power-up if it goes off screen if (self.x < -powerUpGraphics.width / 2) { self.destroy(); } }; function activatePowerUp(type) { var powerUpConfig = { 'CoinMagnet': { duration: 15000, state: 'isMagnetActive' }, 'PowerDash': { duration: 30000, state: 'isPowerDashActive' }, 'Warning': { duration: 30000, state: 'isWarningActive' }, 'Shield': { duration: 0, // Shield is instant and doesn't have a duration state: 'isShielded' }, 'PhoenixFeather': { duration: 0, // Phoenix Feather is instant and doesn't have a duration state: 'hasPhoenixFeather' } }; var config = powerUpConfig[type]; var startTime = Date.now(); console.log("Starting activatePowerUp for", type, "State:", coot[config.state]); if (config) { // Removed interval-based state management if (type === 'Shield') { coot.isShielded = true; coot.shieldGraphics = coot.addChild(LK.getAsset('Shield', { anchorX: 0.5, anchorY: 0.5, scaleX: coot.width / 200, // Scale to cover Coot scaleY: coot.height / 204.2, // Scale to cover Coot alpha: 0.5 // Set opacity to 50% })); return; // Exit early as Shield doesn't need a timer } if (type === 'PhoenixFeather') { coot.hasPhoenixFeather = true; return; // Exit early as Phoenix Feather doesn't need a timer } coot[config.state] = true; // Ensure state is set to true coot.powerUpTimers[type].endTime = Date.now() + config.duration; // Set power-up end time var existingPowerUp = powerUpDisplay.activePowerUps.find(function (p) { return p.type === type; }); if (existingPowerUp) { // Calculate remaining time in milliseconds var timeRemaining = existingPowerUp.startTime + existingPowerUp.duration - Date.now(); if (timeRemaining > 0) { config.duration += timeRemaining; // Add remaining time to new duration startTime = Date.now(); // Reset start time to now for accurate duration } LK.clearInterval(existingPowerUp.interval); existingPowerUp.startTime = Date.now(); // Update startTime to reflect new total duration existingPowerUp.duration = config.duration; // Update duration existingPowerUp.interval = createInterval(config, existingPowerUp.startTime); existingPowerUp.timer = config.duration / 1000; // Update visual timer console.log("Ending activatePowerUp for", type, "State:", coot[config.state]); return; // Exit early as we have updated the existing power-up } powerUpDisplay.addPowerUp(type, config.duration / 1000, startTime); // Include startTime for accurate remaining time } } }); var PowerUpDisplay = Container.expand(function () { var self = Container.call(this); self.x = 2048 / 2; // Center horizontally self.y = 2732 * 0.9; // Position at bottom center self.activePowerUps = []; self.update = function () { // Update each power-up display self.activePowerUps.forEach(function (powerUp, index) { powerUp.timer -= (Date.now() - powerUp.lastUpdateTime) / 1000; // Decrease timer based on real time powerUp.lastUpdateTime = Date.now(); // Update the last update time powerUp.text.setText(Math.max(0, Math.ceil(powerUp.timer)) + 's'); // Ensure timer doesn't show negative values // Remove power-up if timer reaches 0 if (powerUp.timer <= 0) { powerUp.icon.destroy(); powerUp.text.destroy(); self.activePowerUps.splice(index, 1); self.repositionPowerUps(); } }); }; self.addPowerUp = function (type, duration) { var existingPowerUp = self.activePowerUps.find(function (p) { return p.type === type; }); if (existingPowerUp) { existingPowerUp.timer += duration; existingPowerUp.lastUpdateTime = Date.now(); existingPowerUp.text.setText(Math.max(0, Math.ceil(existingPowerUp.timer)) + 's'); // Update visual timer return; } var iconAssetMap = { 'CoinMagnet': 'CoinMagnet', 'PowerDash': 'PowerDash', 'Warning': 'Warning', 'Shield': 'Shield', 'PhoenixFeather': 'PhoenixFeather' }; if (iconAssetMap[type]) { var icon = LK.getAsset(iconAssetMap[type], { anchorX: 0.5, anchorY: 0.5, scaleX: 1.0, scaleY: 1.0 }); } else { console.error("Power-up type not found in iconAssetMap: ", type); return; } var text = new Text2(duration + 's', { size: 100, fill: "#ffffff" }); text.anchor.set(0.5, 0.5); self.addChild(icon); self.addChild(text); self.activePowerUps.push({ icon: icon, text: text, timer: duration, type: type, lastUpdateTime: Date.now() }); self.repositionPowerUps(); }; self.repositionPowerUps = function () { var totalWidth = self.activePowerUps.reduce(function (acc, powerUp) { return acc + powerUp.icon.width + powerUp.text.width + 40; // 40 is the new spacing }, 0); var startX = -totalWidth / 2; self.activePowerUps.forEach(function (powerUp) { powerUp.icon.x = startX + powerUp.icon.width / 2; powerUp.text.x = powerUp.icon.x + powerUp.icon.width / 2 + 40; // 40 is the new spacing between icon and text startX += powerUp.icon.width + powerUp.text.width + 20; }); }; }); var Ripple = Container.expand(function () { var self = Container.call(this); var rippleGraphics = self.attachAsset('Ripple', { anchorX: 0.5, anchorY: 0.5 }); self.initialScale = 0.05; self.growthRate = 0.02; self.fadeRate = 0.01; self.maxScale = 2.0; rippleGraphics.scaleX = self.initialScale; rippleGraphics.scaleY = self.initialScale; self.update = function () { console.log("Ripple update called"); rippleGraphics.scaleX += self.growthRate; rippleGraphics.scaleY += self.growthRate; rippleGraphics.alpha -= self.fadeRate; console.log("Ripple scale:", rippleGraphics.scaleX, "Ripple alpha:", rippleGraphics.alpha); if (rippleGraphics.scaleX >= self.maxScale || rippleGraphics.alpha <= 0) { console.log("Ripple destroyed"); self.destroy(); } }; }); var ShadowClone = Container.expand(function () { var self = Container.call(this); var cloneGraphics = self.attachAsset('Owl', { anchorX: 0.5, anchorY: 0.5, alpha: 0.5 // Set initial transparency }); self.fadeRate = 0.05; // Rate at which the clone fades self.update = function () { cloneGraphics.alpha -= self.fadeRate; if (cloneGraphics.alpha <= 0) { self.destroy(); } }; }); // Static respawn delay property // Class for the water splash particles var Splash = Container.expand(function () { var self = Container.call(this); var scale = Math.random() * 0.75 + 0.25; var splashGraphics = self.attachAsset('Watersplash', { anchorX: 0.5, anchorY: 0.5, scaleX: scale, scaleY: scale }); self.speedX = Math.random() * 2 - 1; // Random speed in X direction self.speedY = -Math.random() * 5; // Random upward speed in Y direction self.gravity = 0.1; // Gravity to pull the particle down self.update = function () { self.x += self.speedX * gameSpeed; self.y += self.speedY * gameSpeed; self.speedY += self.gravity; // Apply gravity // Add rotation based on the speed of the particle self.rotation += self.speedX / 10; if (self.y > 2732) { // If the particle is below the screen self.destroy(); // Destroy the particle } }; }); var Sun = Container.expand(function () { var self = Container.call(this); var sunGraphics = self.attachAsset('Sun', { anchorX: 0.5, anchorY: 0.5 }); // Initialize sun properties self.startX = -sunGraphics.width / 2; // Start off-screen to the left self.startY = 2732 * 0.25; // 25% from the top self.endX = 2048 + sunGraphics.width / 2; // End off-screen to the right self.arcHeight = 2732 * 0.1; // Arc height self.duration = 2 * 60 * 60; // 2 minutes in ticks (assuming 60 FPS) self.ticks = 0; self.update = function () { self.ticks++; var progress = self.ticks / self.duration; self.x = self.startX + (self.endX - self.startX) * progress; self.y = self.startY - Math.sin(progress * Math.PI) * self.arcHeight; // Calculate fade threshold and apply smooth fade based on sun's position var fadeThreshold = 0.8; // Start fade at 80% of sun's journey if (progress >= fadeThreshold) { var fadeProgress = (progress - fadeThreshold) / (1 - fadeThreshold); nightBackground.alpha = fadeProgress; } // Destroy the sun when it goes off-screen to the right if (self.x > self.endX) { self.destroy(); // Switch to night state isDay = false; isNight = true; // Start spawning fireflies fireflySpawnInterval = LK.setInterval(function () { var newFirefly = new Firefly(); newFirefly.x = Math.random() * 2048; newFirefly.y = Math.random() * 2732; game.addChild(newFirefly); }, 1000); // Spawn a firefly every second game.addChild(new Moon()); } }; }); // Class for the water var Water = Container.expand(function () { var self = Container.call(this); var waterGraphics = self.attachAsset('Water', { anchorX: 0.5, anchorY: 0.7 }); self.speed = 2; self.update = function () { self.x -= self.speed * gameSpeed; // self.y = midgroundtrees1.y + midgroundtrees1.height / 2; if (self.x <= -self.width / 2) { self.x += self.width * 2; } }; }); /**** * Initialize Game ****/ var game = new LK.Game({ backgroundColor: 0x000000 }); /**** * Game Code ****/ // Define createInterval function to fix ReferenceError function createInterval(config, startTime) { return LK.setInterval(function () { var timeRemaining = config.duration - (Date.now() - startTime); if (timeRemaining <= 0) { LK.clearInterval(this); } }, 1000); } function showInstructions() { var menuBackground = LK.getAsset('MenuBackground', { anchorX: 0.5, anchorY: 0.5, x: 2048 / 2, y: 2732 / 2 }); game.addChild(menuBackground); var instructionsScreen = new InstructionsScreen(); game.addChild(instructionsScreen); instructionsScreen.menuBackground = menuBackground; // Store reference for later removal } function startGame() { gameSpeed = 1.5; // Set initial game speed gameActive = true; // Set gameActive to true when gameplay starts Obstacle.lastDestroyTime = Date.now(); // Initialize lastDestroyTime when gameplay starts // Initialize Coot when exiting the title screen coot = new Coot(); coot.x = 2048 * 0.20; coot.y = 2732 * 0.75; coot.originalX = coot.x; // Initialize originalX position coot.originalY = coot.y; // Initialize originalY position game.addChildAt(coot, game.getChildIndex(foreground1) - 1); coot.phoenixFeatherIcon = phoenixFeatherIcon; // Store reference in coot // Initialize heart icons based on Coot's lives heartIcons.forEach(function (icon, index) { icon.alpha = index < coot.lives ? 1 : 0.2; // Dim the heart if life is lost }); // Initialize the day count display after exiting the title screen dayCountDisplay = new DayCountDisplay(); LK.gui.top.addChild(dayCountDisplay); dayCountDisplay.y = 2732 * 0.25; // Move down by 25% of the screen height // Set a timer to show the day count display after 3 seconds of game time LK.setTimeout(function () { dayCountDisplay.show(); }, 1500); // Initialize the sun after exiting the title screen sun = game.addChild(new Sun()); sun.x = sun.startX; sun.y = sun.startY; } function handleShieldHit() { // Remove shield asset if (coot.shieldGraphics) { coot.shieldGraphics.destroy(); coot.shieldGraphics = null; } coot.isShielded = false; coot.isInvincible = true; // Set Coot to invincible state // Flash effect for invincibility var flashInterval = LK.setInterval(function () { coot.children[0].alpha = coot.children[0].alpha === 1 ? 0.5 : 1; }, 100); LK.setTimeout(function () { LK.clearInterval(flashInterval); coot.children[0].alpha = 1; coot.isInvincible = false; }, 1500); } // Define a single obstacleTypes array as a constant var obstacleTypes = ['Duck', 'Eagle', 'Fish', 'Owl']; var obstacleSpawnChances = { Duck: 1, Eagle: 1, Fish: 1, Owl: 1 }; Obstacle.getRandomDelay = function (min, max) { return Math.floor(Math.random() * (max - min + 1)) + min; }; Obstacle.spawnDelay = 6750; // Reduce default spawn delay by 25% to 6.75 seconds Obstacle.respawnDelay = { Eagle: Obstacle.getRandomDelay(2250, 3750), // Reduce Eagle respawn delay by 25% Duck: Obstacle.getRandomDelay(2250, 3750), // Reduce Duck respawn delay by 25% Fish: Obstacle.getRandomDelay(2250, 3750), // Reduce Fish respawn delay by 25% Owl: Obstacle.getRandomDelay(2250, 3750) // Add Owl respawn delay }; Obstacle.lastDestroyTime = Date.now() - 5000; // Initialize to ensure first spawn check passes console.log("Initial lastDestroyTime: " + Obstacle.lastDestroyTime); var background = game.addChild(LK.getAsset('Background', { anchorX: 0.5, anchorY: 0.5, x: 2048 / 2, y: 2732 / 2, scaleX: 2048 / 2500, scaleY: 2732 / 2500 })); var nightBackground = game.addChild(LK.getAsset('NightBackground', { anchorX: 0.5, anchorY: 0.5, x: 2048 / 2, y: 2732 / 2, scaleX: 2048 / 2500, scaleY: 2732 / 2500, alpha: 0 })); var DayCount = 1; // Global variable to keep track of the number of days, initialized to 1 at game start // Initialize the sun after title screen var sun; var isDay = true; // Initialize day state var isNight = false; // Initialize night state // Initialize the midgroundtrees var midgroundtrees1 = game.addChild(new Midgroundtrees()); midgroundtrees1.x = 2048 / 2; midgroundtrees1.y = 2732 * 0.7; var midgroundtrees2 = game.addChild(new Midgroundtrees()); midgroundtrees2.x = 2048 / 2 + midgroundtrees2.width; midgroundtrees2.y = 2732 * 0.7; // Initialize the water var water1 = game.addChild(new Water()); water1.x = 2048 / 2; water1.y = midgroundtrees1.y + midgroundtrees1.height / 2; var water2 = game.addChild(new Water()); water2.x = 2048 / 2 + water2.width; water2.y = midgroundtrees2.y + midgroundtrees2.height / 2; // Initialize game logo var gameLogo = LK.getAsset('GameIcon', { anchorX: 0.5, anchorY: 0.5, x: -100, // Start off-screen to the left y: 2732 * 0.4 // Move up by 10% of the screen height }); game.addChild(gameLogo); // Initialize game variables var coot; var dragStartY = null; // Initialize dragStartY to null var dragStartX = null; // Initialize dragStartX to null var gameSpeed = 0; // Global variable for game speed, set to 0 during title screen var isTitleScreen = true; // Flag to indicate if the game is in the title screen state var gameActive = false; // Flag to indicate if the game is actively being played var speedIncreaseInterval = 30000; // 30 seconds in milliseconds var maxGameSpeed = 5.0; // Maximum game speed var lastSpeedIncreaseTime = Date.now(); // Track the last time speed was increased var score = 0; var coinCount = 0; // Global variable to keep track of collected coins var currentObstacle = null; var warningIcon = null; // Initialize the foreground var foreground1 = new Foreground(); var foreground2 = new Foreground(); // Removed duplicate addChild calls for foregrounds game.addChild(foreground1); game.addChild(foreground2); foreground1.x = 2048 / 2; foreground1.y = 2732 * 0.9; foreground2.x = foreground1.x + foreground1.width; foreground2.y = 2732 * 0.9; foreground1.isFirst = true; foreground1.other = foreground2; foreground2.other = foreground1; // Validate positioning if (Math.abs(foreground2.x - (foreground1.x + foreground1.width)) > 1) { console.error("Foreground pieces are not correctly positioned!"); } // Add coin counter display var coinCounter = new Text2('0', { size: 150, // Increased size for better visibility fill: "#ffffff" }); coinCounter.anchor.set(1, 0); // Anchor to the top right corner // Add coin asset beside the coin counter var coinIcon = LK.getAsset('Coin', { anchorX: 1, anchorY: 0, x: -coinCounter.width - 10, // Position to the left of the counter with some padding y: 0 }); LK.gui.topRight.addChild(coinIcon); LK.gui.topRight.addChild(coinCounter); // Add heart icons to represent Coot's lives var heartIcons = []; for (var i = 0; i < 3; i++) { // Always create 3 heart icons var heartIcon = LK.getAsset('HeartLife', { anchorX: 0, anchorY: 0, x: -coinCounter.width - 10 - i * 110, y: coinIcon.height + 10 }); LK.gui.topRight.addChild(heartIcon); heartIcons.push(heartIcon); } // Update heart icons based on remaining lives heartIcons.forEach(function (icon, index) { icon.alpha = coot && index < coot.lives ? 1 : 0.2; // Dim the heart if life is lost }); // Initialize PowerUpDisplay after foregrounds are set up var powerUpDisplay = new PowerUpDisplay(); game.addChild(powerUpDisplay); // Initialize Phoenix Feather icon at the start of the game var phoenixFeatherIcon = new PhoenixFeatherIcon(); // coot.phoenixFeatherIcon will be set after coot initialization phoenixFeatherIcon.x = heartIcons[0].x + heartIcons[0].width / 2 - phoenixFeatherIcon.width / 2; // Center below the leftmost heart icon phoenixFeatherIcon.y = heartIcons[0].y + heartIcons[0].height + 70; // Increase padding below the heart icon LK.gui.topRight.addChild(phoenixFeatherIcon); var dayCountDisplay; game.update = function () { if (DayCount > 1 && !dayCountDisplay.visible) { dayCountDisplay.show(); } if (isTitleScreen) { // Only update background, midground trees, water, and foreground during title screen [midgroundtrees1, midgroundtrees2, water1, water2, foreground1, foreground2].forEach(function (element) { element.update(); }); // Animate game logo sliding in from the left if (gameLogo.x < 2048 / 2) { gameLogo.x += 30; // Slide in quickly } else { gameLogo.x = 2048 / 2; // Stop at center } if (!gameLogo.playButton && !gameLogo.instructionsButton) { var playButton = new PlayButton(); playButton.x = 2048 / 2; playButton.y = gameLogo.y + gameLogo.height / 2 + 100 + 2732 * 0.06; // Move down by 6% of the screen height game.addChild(playButton); gameLogo.playButton = playButton; var instructionsButton = new InstructionsButton(); instructionsButton.x = 2048 / 2; instructionsButton.y = playButton.y + playButton.height; // Move up by 1% of the screen height game.addChild(instructionsButton); gameLogo.instructionsButton = instructionsButton; } return; // Exit update function to prevent further updates } if (coot) { coot.update(); } phoenixFeatherIcon.update(); // Increase game speed every 20 seconds if (!isTitleScreen && Date.now() - lastSpeedIncreaseTime >= speedIncreaseInterval) { if (gameSpeed < maxGameSpeed) { gameSpeed = Math.min(gameSpeed + 0.1, maxGameSpeed); // Decrease respawn delay for all obstacles Obstacle.respawnDelay.Eagle = Math.max(Obstacle.respawnDelay.Eagle - 500, 1000); Obstacle.respawnDelay.Duck = Math.max(Obstacle.respawnDelay.Duck - 500, 1000); Obstacle.respawnDelay.Fish = Math.max(Obstacle.respawnDelay.Fish - 500, 1000); Obstacle.respawnDelay.Owl = Math.max(Obstacle.respawnDelay.Owl - 500, 1000); } lastSpeedIncreaseTime = Date.now(); } // Define createInterval function to fix ReferenceError // Removed the timer counter increment and display logic // Check for collision between the Coot and the Collision Block of the current obstacle if (currentObstacle && coot.intersects(currentObstacle.children[0])) { if (coot.isShielded) { handleShieldHit(); } else if (coot.isInvincible) { // Do nothing, invincible state } else { coot.lives -= 1; if (coot.lives <= 0 && coot.hasPhoenixFeather) { coot.hasPhoenixFeather = false; // Remove Phoenix Feather phoenixFeatherIcon.update(); // Update Phoenix Feather icon coot.lives = 3; // Refill all lives heartIcons.forEach(function (icon) { icon.alpha = 1; // Restore all heart icons }); // Add Phoenix effect coot.isInvincible = true; // Set Coot to invincible state LK.effects.flashScreen(0xff0000, 1000); // Flash screen red for 1 second var phoenix = LK.getAsset('Phoenix', { anchorX: 0.5, anchorY: 0.5, alpha: 0.5 // Set initial opacity to 50% }); phoenix.x = 2048 / 2; phoenix.y = 2732 / 2; game.addChild(phoenix); LK.setTimeout(function () { phoenix.destroy(); // Destroy the Phoenix asset coot.isInvincible = false; // Remove invincibility after effect }, 1500); // Wait for 1.5 seconds } else if (coot.lives <= 0) { coot.isFalling = true; coot.fallStartY = coot.y; coot.fallRotation = 0; coot.fallSpeed = 5; heartIcons[0].alpha = 0.2; // Dim the last heart icon to indicate all lives lost } else { coot.isInvincible = true; heartIcons[coot.lives].alpha = 0.2; // Dim the heart icon to indicate a lost life // Flash effect for invincibility LK.effects.flashScreen(0xff0000, 100); // Flash screen red for 100ms var flashInterval = LK.setInterval(function () { coot.children[0].alpha = coot.children[0].alpha === 1 ? 0.5 : 1; }, 100); LK.setTimeout(function () { LK.clearInterval(flashInterval); coot.children[0].alpha = 1; coot.isInvincible = false; }, 1500); } } } // Update PowerUpDisplay powerUpDisplay.update(); // Update the midgroundtrees midgroundtrees1.update(); midgroundtrees2.update(); // Update the water water1.update(); water2.update(); // Update the current obstacle // Check if the current obstacle needs destruction if (currentObstacle && currentObstacle.x < -currentObstacle.width / 2) { currentObstacle.destroy(); Obstacle.lastDestroyTime = Date.now(); console.log("Obstacle destroyed at " + Obstacle.lastDestroyTime); currentObstacle = null; } // Check if it's time to spawn a new obstacle if (gameActive && !currentObstacle) { var timeSinceLastDestroy = Date.now() - Obstacle.lastDestroyTime; if (timeSinceLastDestroy >= Obstacle.spawnDelay - 1000 && !warningIcon) { var totalChance = obstacleSpawnChances.Duck + obstacleSpawnChances.Fish; if (isDay) { totalChance += obstacleSpawnChances.Eagle; } else if (isNight) { totalChance += obstacleSpawnChances.Owl; } var randomChance = Math.random() * totalChance; var cumulativeChance = 0; for (var i = 0; i < obstacleTypes.length; i++) { if (obstacleTypes[i] === 'Eagle' && isDay || obstacleTypes[i] === 'Owl' && isNight || obstacleTypes[i] !== 'Eagle' && obstacleTypes[i] !== 'Owl') { cumulativeChance += obstacleSpawnChances[obstacleTypes[i]]; if (randomChance < cumulativeChance) { currentObstacleType = obstacleTypes[i]; obstacleSpawnChances[currentObstacleType] = 1; // Reset chance on spawn break; } } } var warningIconClassMap = { 'Duck': DuckWarningIcon, 'Eagle': EagleWarningIcon, 'Fish': FishWarningIcon, 'Owl': OwlWarningIcon // Add OwlIcon to warning icons }; warningIcon = game.addChild(new warningIconClassMap[currentObstacleType]()); warningIcon.x = 2048 / 2; warningIcon.y = 2732 / 2; } if (timeSinceLastDestroy >= Obstacle.spawnDelay) { if (warningIcon) { warningIcon.destroy(); warningIcon = null; } console.log("Selected obstacle type: ", currentObstacleType); currentObstacle = game.addChild(new Obstacle(currentObstacleType)); currentObstacle.x = 2048 + currentObstacle.width / 2; // Ensure it starts off-screen currentObstacle.y = currentObstacleType === 'Duck' ? 2732 * 0.80 : currentObstacleType === 'Eagle' ? 2732 * 0.25 : currentObstacleType === 'Fish' ? 2732 * 0.85 : 2732 * 0.10; // Owl positioned at 10% from the top console.log("Spawned " + currentObstacleType + " at " + Date.now()); // Increase spawn chance for obstacles not selected obstacleTypes.forEach(function (type) { if (type !== currentObstacleType) { obstacleSpawnChances[type] += 0.5; // Increase chance by 0.5 for each non-selected obstacle } }); } } if (currentObstacle) { currentObstacle.update(); } // Check for collision between the Coot and Coins game.children.forEach(function (child) { if (child instanceof Coin && coot && coot.intersects(child) && !child.collecting) { child.collecting = true; child.targetX = 2048 + child.children[0].width; // Target off-screen to the right child.targetY = -child.children[0].height; // Target off-screen to the top } }); // Update the foreground foreground1.update(); foreground2.update(); // Spawn butterflies randomly if (isDay && LK.ticks % 720 == 0) { // Every 3 seconds at 60 FPS var newButterfly = new Butterfly(); newButterfly.x = 2048 + newButterfly.width / 2; // Start off-screen to the right newButterfly.y = Math.random() * (2732 * 0.6) + 2732 * 0.2; // Random Y position within midground tree layer game.addChild(newButterfly); } // Calculate spawn interval based on coin magnet state var baseSpawnRate = 120; // Normal 2-second spawn rate var magnetSpawnRate = 30; // 25% faster (120 * 0.75 = 90) var currentSpawnRate = coot && coot.hasCoinMagnet ? magnetSpawnRate : baseSpawnRate; if (LK.ticks % currentSpawnRate == 0) { var newCoin = new Coin(); newCoin.x = 2048 + newCoin.width / 2; newCoin.y = Math.random() * (2732 * 0.45) + 2732 * 0.35; game.addChild(newCoin); } // Spawn power ups randomly if (LK.ticks % 1080 == 0) { // Every 3 seconds at 60 FPS var powerUpTypes = [{ type: 'Shield', weight: 20 }, { type: 'PowerDash', weight: 25 }, { type: 'CoinMagnet', weight: 25 }, { type: 'Warning', weight: 20 }, { type: 'PhoenixFeather', weight: 10 }]; var totalWeight = powerUpTypes.reduce(function (acc, powerUp) { return acc + powerUp.weight; }, 0); var randomWeight = Math.random() * totalWeight; var cumulativeWeight = 0; var selectedPowerUpType; for (var i = 0; i < powerUpTypes.length; i++) { cumulativeWeight += powerUpTypes[i].weight; if (randomWeight < cumulativeWeight) { selectedPowerUpType = powerUpTypes[i].type; break; } } // Check if Coot already has a shield or Phoenix feather if (selectedPowerUpType === 'Shield' && coot.isShielded || selectedPowerUpType === 'PhoenixFeather' && coot.hasPhoenixFeather) { // Skip spawning this power-up return; } var newPowerup = new PowerUp(selectedPowerUpType); newPowerup.x = 2048 + newPowerup.width / 2; // Start off-screen to the right newPowerup.y = Math.random() * (2732 * 0.45) + 2732 * 0.35; // Random Y position between 35% and 80% of the screen height game.addChild(newPowerup); } }; // Handle touch events for jumping and diving game.down = function (x, y, obj) { dragStartY = y; // Record the initial y position when touch starts dragStartX = x; // Record the initial x position when touch starts }; game.move = function (x, y, obj) { if (!isTitleScreen && dragStartY !== null && dragStartX !== null) { if (x - dragStartX > 50) { // Only allow dash during these states if PowerDash is active if (coot.isJumping || coot.isFalling || coot.isDiving || coot.isReturning || coot.returnDelay > 0) { // Check for PowerDash before allowing if (coot.isPowerDashActive) { coot.isDashing = true; } } else { // Normal dash on ground, no PowerDash needed coot.isDashing = true; } dragStartX = null; // Reset dragStartX to prevent repeated dashes } if (y - dragStartY > 50 && coot && coot.originalY !== undefined && coot.y !== undefined && coot.y === coot.originalY) { // Check if the drag is downward and significant coot.dive(); dragStartY = null; // Reset dragStartY to prevent repeated dives } else if (dragStartY - y > 50 && coot.y === coot.originalY) { // Check if the drag is upward and significant coot.jump(); dragStartY = null; // Reset dragStartY to prevent repeated jumps } } }; game.up = function (x, y, obj) { dragStartY = null; // Reset dragStartY when touch ends dragStartX = null; // Reset dragStartX when touch ends };