/**** 
* Plugins
****/ 
var tween = LK.import("@upit/tween.v1");

/**** 
* Classes
****/ 
var Bird = Container.expand(function () {
	var self = Container.call(this);
	self.speedX = 5;
	self.lastX = 0;
	var birdGraphics = self.attachAsset('bird', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.update = function () {
		// Store last position for edge detection
		self.lastX = self.x;
		// Move horizontally
		self.x += self.speedX;
		// Apply gravity
		if (!self.speedY) self.speedY = 0;
		self.speedY += 0.8; // Gravity acceleration
		self.y += self.speedY;
		// Keep bird within screen bounds
		if (self.y < 30) {
			self.y = 30;
			self.speedY = 0;
		}
		// Reverse direction when hitting screen edges and add scoring
		if (self.lastX <= 2048 - 40 && self.x > 2048 - 40) {
			self.x = 2048 - 40;
			self.speedX = -self.speedX; // Reverse horizontal direction
			// Flip bird image horizontally using scaleX
			birdGraphics.scaleX = self.speedX > 0 ? 1 : -1;
			// Reset rotation to 0 when changing direction
			birdGraphics.rotation = 0;
			// Add point and increase speed
			LK.setScore(LK.getScore() + 1);
			updateScoreText(LK.getScore());
			// Increase speed with smaller increment
			var newSpeed = Math.abs(self.speedX) + 0.5;
			if (self.speedX < 0) newSpeed = -newSpeed;
			tween(self, {
				speedX: newSpeed
			}, {
				duration: 500,
				easing: tween.easeOut
			});
			// Increase parachute speed slightly
			if (parachutes) {
				for (var i = 0; i < parachutes.length; i++) {
					if (parachutes[i] && !parachutes[i].destroyed) {
						parachutes[i].maxSpeed += 0.2;
						parachutes[i].gravity += 0.01;
					}
				}
			}
		} else if (self.lastX >= 40 && self.x < 40) {
			self.x = 40;
			self.speedX = -self.speedX; // Reverse horizontal direction
			// Flip bird image horizontally using scaleX
			birdGraphics.scaleX = self.speedX > 0 ? 1 : -1;
			// Reset rotation to 0 when changing direction
			birdGraphics.rotation = 0;
			// Add point and increase speed
			LK.setScore(LK.getScore() + 1);
			updateScoreText(LK.getScore());
			// Increase speed with smaller increment
			var newSpeed = Math.abs(self.speedX) + 0.5;
			if (self.speedX < 0) newSpeed = -newSpeed;
			tween(self, {
				speedX: newSpeed
			}, {
				duration: 500,
				easing: tween.easeOut
			});
			// Increase parachute speed slightly
			if (parachutes) {
				for (var i = 0; i < parachutes.length; i++) {
					if (parachutes[i] && !parachutes[i].destroyed) {
						parachutes[i].maxSpeed += 0.2;
						parachutes[i].gravity += 0.01;
					}
				}
			}
		}
	};
	self.propelUp = function () {
		if (!self.speedY) self.speedY = 0;
		self.speedY = -15; // Upward thrust velocity
	};
	return self;
});
var Cloud = Container.expand(function () {
	var self = Container.call(this);
	var cloudGraphics = self.attachAsset('Nubes', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 3,
		scaleY: 3
	});
	self.lastY = 0;
	self.update = function () {
		self.lastY = self.y;
		// Remove cloud when it goes off screen
		if (self.lastY <= 2732 + 350 && self.y > 2732 + 350) {
			self.destroy();
		}
	};
	return self;
});
var Parachute = Container.expand(function () {
	var self = Container.call(this);
	var bombGraphics = self.attachAsset('Bombas', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 2,
		scaleY: 2
	});
	self.speedY = 0;
	self.maxSpeed = 3; // Terminal velocity for parachute
	self.gravity = 0.1; // Reduced gravity for parachute effect
	self.lastY = 0;
	self.update = function () {
		self.lastY = self.y;
		// Apply parachute physics - slower acceleration and terminal velocity
		self.speedY += self.gravity;
		if (self.speedY > self.maxSpeed) {
			self.speedY = self.maxSpeed; // Cap at terminal velocity
		}
		self.y += self.speedY;
		// Add slight horizontal drift for realism
		self.x += Math.sin(self.y * 0.01) * 0.5;
		// Remove parachute when it goes off screen
		if (self.lastY <= 2732 + 100 && self.y > 2732 + 100) {
			self.destroy();
		}
	};
	return self;
});
var PowerUp = Container.expand(function () {
	var self = Container.call(this);
	var starGraphics = self.attachAsset('star', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 1.5,
		scaleY: 1.5
	});
	self.lastY = 0;
	self.speedY = 2;
	// Create pulsing star effect
	self.pulseDirection = 1;
	self.pulseSpeed = 0.05;
	self.update = function () {
		self.lastY = self.y;
		self.y += self.speedY;
		// Create pulsing effect
		starGraphics.scaleX += self.pulseSpeed * self.pulseDirection;
		starGraphics.scaleY += self.pulseSpeed * self.pulseDirection;
		if (starGraphics.scaleX >= 2) {
			self.pulseDirection = -1;
		} else if (starGraphics.scaleX <= 1) {
			self.pulseDirection = 1;
		}
		// Rotate star
		starGraphics.rotation += 0.1;
		// Remove when off screen
		if (self.lastY <= 2732 + 100 && self.y > 2732 + 100) {
			self.destroy();
		}
	};
	return self;
});

/**** 
* Initialize Game
****/ 
var game = new LK.Game({
	backgroundColor: 0x87CEEB
});

/**** 
* Game Code
****/ 
// Add sky background that covers full screen
var skyBackground = game.attachAsset('Cielo', {
	anchorX: 0,
	anchorY: 0,
	x: 0,
	y: 0,
	width: 2048,
	height: 2732
});
// Create score display
var scoreTxt = new Text2('0', {
	size: 180,
	fill: 0xFFFFFF,
	font: "'Arial Black', Arial, sans-serif",
	stroke: 0x000000,
	strokeThickness: 15
});
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
scoreTxt.y = 100;
// Function to update score text with consistent styling
function updateScoreText(score) {
	scoreTxt.setText(score);
	scoreTxt.stroke = 0x000000;
	scoreTxt.strokeThickness = 15;
}
// Create bird
var bird = new Bird();
bird.x = 300;
bird.y = 2732 / 2;
game.addChild(bird);
// Gradually increase bird speed over time
tween(bird, {
	speedX: 15
}, {
	duration: 30000,
	easing: tween.easeInOut
});
// Instruction text
var instructionTxt = new Text2('Tap to propel the bird upward!', {
	size: 60,
	fill: 0xFFFFFF,
	font: "'Arial Black', Arial, sans-serif",
	stroke: 0x000000,
	strokeThickness: 4
});
instructionTxt.anchor.set(0.5, 0.5);
game.addChild(instructionTxt);
instructionTxt.x = 2048 / 2;
instructionTxt.y = 300;
// Touch controls
game.down = function (x, y, obj) {
	bird.propelUp();
	// Add rotation effect for jump to bird graphics only
	var birdGraphics = bird.children[0];
	// Rotate upward when moving left, downward when moving right
	var rotationDirection = bird.speedX < 0 ? 0.3 : -0.3;
	tween(birdGraphics, {
		rotation: birdGraphics.rotation + rotationDirection
	}, {
		duration: 200,
		easing: tween.easeOut,
		onFinish: function onFinish() {
			// Return to normal rotation
			tween(birdGraphics, {
				rotation: 0
			}, {
				duration: 300,
				easing: tween.easeInOut
			});
		}
	});
};
// Array to track clouds and parachutes
var clouds = [];
var parachutes = [];
var powerUps = [];
var lastParachuteSpawn = 0;
var parachuteSpawnDelay = 1000 + Math.random() * 2000; // 1-3 seconds between spawns
var lastPowerUpSpawn = 0;
var powerUpSpawnDelay = 15000 + Math.random() * 10000; // 15-25 seconds between power-ups
var isInvincible = false;
var invincibilityEndTime = 0;
game.update = function () {
	// Spawn clouds randomly - one at a time
	if (Math.random() < 0.001) {
		// 0.1% chance each frame
		var newCloud = new Cloud();
		newCloud.x = Math.random() * 2048; // Random X position across screen width
		newCloud.y = -50; // Start above screen
		newCloud.lastY = newCloud.y;
		clouds.push(newCloud);
		game.addChild(newCloud);
		// Animate cloud falling down with random speed
		var fallDuration = 8000 + Math.random() * 4000; // 8-12 seconds
		tween(newCloud, {
			y: 2732 + 300
		}, {
			duration: fallDuration,
			easing: tween.linear,
			onFinish: function onFinish() {
				// Remove from clouds array when finished
				for (var i = clouds.length - 1; i >= 0; i--) {
					if (clouds[i] === newCloud) {
						clouds.splice(i, 1);
						break;
					}
				}
			}
		});
	}
	// Spawn parachutes with timing control - multiple can exist
	var currentTime = Date.now();
	if (currentTime - lastParachuteSpawn > parachuteSpawnDelay) {
		var newParachute = new Parachute();
		newParachute.x = Math.random() * (2048 - 200) + 100; // Random X position with margin
		newParachute.y = -100; // Start above screen
		newParachute.lastY = newParachute.y;
		parachutes.push(newParachute);
		game.addChild(newParachute);
		lastParachuteSpawn = currentTime;
		// Set new random delay for next spawn (3-7 seconds)
		parachuteSpawnDelay = 3000 + Math.random() * 4000;
	}
	// Spawn power-ups occasionally
	if (currentTime - lastPowerUpSpawn > powerUpSpawnDelay) {
		var newPowerUp = new PowerUp();
		newPowerUp.x = Math.random() * (2048 - 200) + 100;
		newPowerUp.y = -100;
		newPowerUp.lastY = newPowerUp.y;
		powerUps.push(newPowerUp);
		game.addChild(newPowerUp);
		lastPowerUpSpawn = currentTime;
		// Set new random delay for next spawn (15-25 seconds)
		powerUpSpawnDelay = 15000 + Math.random() * 10000;
	}
	// Check invincibility timer
	if (isInvincible && currentTime > invincibilityEndTime) {
		isInvincible = false;
		// Stop any ongoing tween effects on bird
		tween.stop(bird, {
			tint: true
		});
		bird.tint = 0xFFFFFF; // Reset to normal color
	}
	// Check power-up collection
	var _loop = function _loop() {
			powerUp = powerUps[i];
			if (!powerUp.destroyed && bird.intersects(powerUp)) {
				// 8 seconds of invincibility
				// Start Mario-like rainbow color cycling effect
				var colorIndex = 0;
				var rainbowColors = [0xFF0000,
				// Red
				0xFF7F00,
				// Orange
				0xFFFF00,
				// Yellow
				0x00FF00,
				// Green
				0x0000FF,
				// Blue
				0x4B0082,
				// Indigo
				0x9400D3 // Violet
				];
				var _createRainbowEffect = function createRainbowEffect() {
					if (isInvincible) {
						tween(bird, {
							tint: rainbowColors[colorIndex]
						}, {
							duration: 150,
							onFinish: function onFinish() {
								if (isInvincible) {
									colorIndex = (colorIndex + 1) % rainbowColors.length;
									_createRainbowEffect();
								}
							}
						});
					}
				};
				// Activate invincibility
				isInvincible = true;
				invincibilityEndTime = currentTime + 8000;
				_createRainbowEffect();
				// Remove power-up
				powerUp.destroy();
				powerUps.splice(i, 1);
				return 1; // break
			}
		},
		powerUp;
	for (var i = powerUps.length - 1; i >= 0; i--) {
		if (_loop()) break;
	}
	// Clean up destroyed clouds from array
	for (var i = clouds.length - 1; i >= 0; i--) {
		if (clouds[i].destroyed) {
			clouds.splice(i, 1);
		}
	}
	// Check collision between bird and parachutes
	for (var i = parachutes.length - 1; i >= 0; i--) {
		var parachute = parachutes[i];
		if (!parachute.destroyed && bird.intersects(parachute)) {
			if (isInvincible) {
				// If invincible, just destroy the bomb without explosion
				parachute.destroy();
				parachutes.splice(i, 1);
				// Add bonus points for destroying bomb while invincible
				LK.setScore(LK.getScore() + 5);
				updateScoreText(LK.getScore());
			} else {
				// Hide the bomb
				parachute.visible = false;
				// Make bird turn black
				bird.tint = 0x000000;
				// Make bird fall by giving it strong downward velocity
				bird.speedY = 10; // Strong downward velocity
				// Create explosion at bomb position
				var explosion = game.attachAsset('Explosion', {
					anchorX: 0.5,
					anchorY: 0.5,
					scaleX: 3,
					scaleY: 3
				});
				explosion.x = parachute.x;
				explosion.y = parachute.y;
				// Animate explosion
				tween(explosion, {
					scaleX: 5,
					scaleY: 5,
					alpha: 0
				}, {
					duration: 800,
					easing: tween.easeOut,
					onFinish: function onFinish() {
						// Show game over when explosion finishes
						LK.showGameOver();
					}
				});
				// Remove parachute
				parachute.destroy();
				parachutes.splice(i, 1);
			}
			break; // Only handle one collision per frame
		}
	}
	// Check if bird falls below screen for game over
	if (bird.y > 2732 + 100) {
		LK.showGameOver();
	}
	// Clean up destroyed parachutes from array
	for (var i = parachutes.length - 1; i >= 0; i--) {
		if (parachutes[i].destroyed) {
			parachutes.splice(i, 1);
		}
	}
	// Clean up destroyed power-ups from array
	for (var i = powerUps.length - 1; i >= 0; i--) {
		if (powerUps[i].destroyed) {
			powerUps.splice(i, 1);
		}
	}
};
;

===================================================================
--- original.js
+++ change.js
@@ -333,36 +333,43 @@
 	var _loop = function _loop() {
 			powerUp = powerUps[i];
 			if (!powerUp.destroyed && bird.intersects(powerUp)) {
 				// 8 seconds of invincibility
-				// Start Mario-like flashing effect
-				var _createFlashEffect = function createFlashEffect() {
+				// Start Mario-like rainbow color cycling effect
+				var colorIndex = 0;
+				var rainbowColors = [0xFF0000,
+				// Red
+				0xFF7F00,
+				// Orange
+				0xFFFF00,
+				// Yellow
+				0x00FF00,
+				// Green
+				0x0000FF,
+				// Blue
+				0x4B0082,
+				// Indigo
+				0x9400D3 // Violet
+				];
+				var _createRainbowEffect = function createRainbowEffect() {
 					if (isInvincible) {
 						tween(bird, {
-							tint: 0xFFFFFF
+							tint: rainbowColors[colorIndex]
 						}, {
-							duration: 100,
+							duration: 150,
 							onFinish: function onFinish() {
 								if (isInvincible) {
-									tween(bird, {
-										tint: 0xFFD700
-									}, {
-										duration: 100,
-										onFinish: function onFinish() {
-											if (isInvincible) {
-												_createFlashEffect();
-											}
-										}
-									});
+									colorIndex = (colorIndex + 1) % rainbowColors.length;
+									_createRainbowEffect();
 								}
 							}
 						});
 					}
 				};
 				// Activate invincibility
 				isInvincible = true;
 				invincibilityEndTime = currentTime + 8000;
-				_createFlashEffect();
+				_createRainbowEffect();
 				// Remove power-up
 				powerUp.destroy();
 				powerUps.splice(i, 1);
 				return 1; // break