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

/**** 
* Classes
****/ 
// Branch asset
// Bird1 class to represent the first kind of bird
var Bird1 = Container.expand(function () {
	var self = Container.call(this);
	var birdGraphics = self.attachAsset('bird1-right', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = Math.random() * 1.6 + 1;
	self.lastY = self.y; // Initialize lastY for tracking changes on Y
	self.lastX = self.x; // Initialize lastX for tracking changes on X
	self.update = function () {
		self.y += self.speed;
		self.x += Math.sin(self.y / 100) * 6.5; // Increase the swooping motion of the bird's movement by 30%
		// Check if the bird has moved off-screen
		if (self.lastY <= 2732 && self.y > 2732) {
			self.y = -self.height;
			self.x = Math.random() < 0.33 ? Math.random() * 2048 : Math.random() < 0.5 ? 0 : 2048;
		}
		if (self.lastX <= 2048 / 2 && self.x > 2048 / 2) {
			birdGraphics.texture = LK.getAsset('bird1-right', {}).texture;
		} else if (self.lastX > 2048 / 2 && self.x <= 2048 / 2) {
			birdGraphics.texture = LK.getAsset('bird1-left', {}).texture;
		}
		self.lastY = self.y; // Update lastY after movement
		self.lastX = self.x; // Update lastX after movement
	};
});
// Bird2 class to represent the second kind of bird
var Bird2 = Container.expand(function () {
	var self = Container.call(this);
	var birdGraphics = self.attachAsset('bird2-right', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = Math.random() * 1.6 + 1;
	self.lastY = self.y; // Initialize lastY for tracking changes on Y
	self.lastX = self.x; // Initialize lastX for tracking changes on X
	self.update = function () {
		self.y += self.speed;
		self.x += Math.sin(self.y / 100) * 6.5; // Increase the swooping motion of the bird's movement by 30%
		if (self.lastX <= 2048 / 2 && self.x > 2048 / 2) {
			birdGraphics.texture = LK.getAsset('bird2-right', {}).texture;
		} else if (self.lastX > 2048 / 2 && self.x <= 2048 / 2) {
			birdGraphics.texture = LK.getAsset('bird2-left', {}).texture;
		}
		self.lastX = self.x; // Update lastX after movement
		// Check if the bird has moved off-screen
		if (self.lastY <= 2732 && self.y > 2732) {
			self.y = Math.random() * 2732; // Random initial y position within the screen height
			self.x = Math.random() < 0.5 ? 0 : 2048; // Start from either the left or right side
		}
		self.lastY = self.y; // Update lastY after movement
	};
});
// Cat class to manage cat behavior
var Cat = Container.expand(function () {
	var self = Container.call(this);
	self.lastX = self.x; // Initialize lastX for tracking changes on X
	var catGraphics = self.attachAsset('cat', {
		anchorX: 0.5,
		anchorY: 1
	});
	self.update = function () {
		// Add any specific update logic for the cat here
	};
});
// Cloud class to represent cloud behavior
var Cloud = Container.expand(function () {
	var self = Container.call(this);
	var cloudGraphics = self.attachAsset('cloud', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0.8 // Set default opacity to 80%
	});
	self.speed = Math.random() * 0.55 + 0.25; // Adjust speed to range between 0.25 and 0.8
	self.hasAccelerated = false; // Track if the cloud has already accelerated
	self.direction = Math.random() < 0.5 ? 1 : -1; // Random direction: 1 for right, -1 for left
	self.lastX = self.x; // Track last X position for future checks
	self.lastIntersecting = false; // Initialize lastIntersecting for tracking changes on intersections
	self.update = function () {
		self.x += self.speed * self.direction;
		// If the cloud moves off-screen, reposition it to the opposite side
		if (self.lastX <= 2048 + self.width / 2 && self.x > 2048 + self.width / 2) {
			self.x = -self.width / 2;
		} else if (self.lastX >= -self.width / 2 && self.x < -self.width / 2) {
			self.x = 2048 + self.width / 2;
		}
		// Check for overlap with other clouds
		for (var i = 0; i < clouds.length; i++) {
			if (clouds[i] !== self && self.intersects(clouds[i])) {
				if (!self.hasAccelerated) {
					self.speed *= 1.5; // Increase speed by 50%
					self.hasAccelerated = true; // Mark as accelerated
				}
				break;
			} else if (self.hasAccelerated && !self.intersects(clouds[i])) {
				self.speed /= 1.5; // Reset speed to original
				self.hasAccelerated = false; // Reset acceleration state
			}
		}
		// Check if the cloud intersects with the sun
		if (!self.lastIntersecting && self.intersects(sun)) {
			self.speed *= 2; // Double the speed when touching the sun
			tween(cloudGraphics, {
				alpha: 0.5
			}, {
				duration: 3000,
				easing: tween.linear
			});
		} else if (self.lastIntersecting && !self.intersects(sun)) {
			self.speed /= 2; // Reset speed to original when not touching the sun
			tween(cloudGraphics, {
				alpha: 1.0
			}, {
				duration: 3000,
				easing: tween.linear
			});
		}
		self.lastIntersecting = self.intersects(sun);
		self.lastX = self.x; // Update lastX after movement
	};
});
// CloudMovement class to handle cloud movement and fade effects
var CloudMovement = Container.expand(function () {
	var self = Container.call(this);
	var cloudGraphics = self.attachAsset('cloud', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0.8 // Set default opacity to 80%
	});
	self.speed = Math.random() * 0.55 + 0.25; // Adjust speed to range between 0.25 and 0.8
	self.hasAccelerated = false; // Track if the cloud has already accelerated
	self.direction = Math.random() < 0.5 ? 1 : -1; // Random direction: 1 for right, -1 for left
	self.lastX = self.x; // Track last X position for future checks
	self.lastIntersecting = false; // Initialize lastIntersecting for tracking changes on intersections
	self.update = function () {
		self.x += self.speed * self.direction;
		// If the cloud moves off-screen, reposition it to the opposite side
		if (self.lastX <= 2048 + self.width / 2 && self.x > 2048 + self.width / 2) {
			self.x = -self.width / 2;
		} else if (self.lastX >= -self.width / 2 && self.x < -self.width / 2) {
			self.x = 2048 + self.width / 2;
		}
		// Check for overlap with other clouds
		for (var i = 0; i < clouds.length; i++) {
			if (clouds[i] !== self && self.intersects(clouds[i])) {
				if (!self.hasAccelerated) {
					self.speed *= 1.5; // Increase speed by 50%
					self.hasAccelerated = true; // Mark as accelerated
				}
				break;
			} else if (self.hasAccelerated && !self.intersects(clouds[i])) {
				self.speed /= 1.5; // Reset speed to original
				self.hasAccelerated = false; // Reset acceleration state
			}
		}
		// Check if the cloud intersects with the sun
		if (!self.lastIntersecting && self.intersects(sun)) {
			self.speed *= 2; // Double the speed when touching the sun
			tween(cloudGraphics, {
				alpha: 0.5
			}, {
				duration: 3000,
				easing: tween.linear
			});
		} else if (self.lastIntersecting && !self.intersects(sun)) {
			self.speed /= 2; // Reset speed to original when not touching the sun
			tween(cloudGraphics, {
				alpha: 1.0
			}, {
				duration: 3000,
				easing: tween.linear
			});
		}
		self.lastIntersecting = self.intersects(sun);
		self.lastX = self.x; // Update lastX after movement
	};
});
// Grass class to represent the grass image
var Grass = Container.expand(function () {
	var self = Container.call(this);
	var grassGraphics = self.attachAsset('grass', {
		anchorX: 0.5,
		anchorY: 1
	});
	self.update = function () {
		// Add any specific update logic for the grass here
		// Example: Slightly move the grass to simulate wind effect
		self.x += Math.sin((LK.ticks + 100) / 90) * 0.15; // Swaying effect, increased speed
	};
});
// Grass2 class to represent the second grass image
var Grass2 = Container.expand(function () {
	var self = Container.call(this);
	var grass2Graphics = self.attachAsset('grass2', {
		anchorX: 0.5,
		anchorY: 1
	});
	self.lastX = self.x; // Initialize lastX for tracking changes on X
	self.update = function () {
		// Add any specific update logic for the grass here
		// Example: Slightly move the grass to simulate wind effect
		self.x += Math.sin((LK.ticks + 50) / 100) * 0.125; // Swaying effect, reduced by 50%
		self.lastX = self.x; // Update lastX after movement
	};
});
// Laser class to represent a laser shot from the cat
var Laser = Container.expand(function (startX, startY, targetX, targetY) {
	var self = Container.call(this);
	var laserGraphics = self.attachAsset('laser2', {
		anchorX: 0.5,
		anchorY: 0.5,
		brightness: 2.0 // Increase brightness by 200%
	});
	// Play the laser1 sound when the laser is created
	LK.getSound('laser1').play();
	// Calculate direction and speed
	var dx = targetX - startX;
	var dy = targetY - startY;
	var distance = Math.sqrt(dx * dx + dy * dy);
	var speed = 60; // Speed of the laser increased by 200%
	self.vx = dx / distance * speed;
	self.vy = dy / distance * speed;
	// Set initial position
	self.x = startX;
	self.y = startY;
	// Update function to move the laser
	self.update = function () {
		self.x += self.vx;
		self.y += self.vy;
		// Remove laser if it goes off-screen
		if (self.x < 0 || self.x > 2048 || self.y < 0 || self.y > 2732) {
			self.destroy();
		}
	};
});
// Reticle class to manage reticle behavior
var Reticle = Container.expand(function () {
	var self = Container.call(this);
	var reticleGraphics = self.attachAsset('reticle1', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.update = function () {
		// Add any specific update logic for the reticle here
	};
});
// ScoreDisplay class to manage score display
var ScoreDisplay = Container.expand(function () {
	var self = Container.call(this);
	var scoreGraphics = self.attachAsset('scoreImage', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var scoreText = new Text2('0', {
		size: 175,
		fill: 0x00FF00,
		font: "Courier New, Courier, monospace",
		// Segmented clock style font
		stroke: 0x000000,
		strokeThickness: 5,
		dropShadow: true,
		dropShadowColor: 0x000000,
		dropShadowBlur: 5,
		dropShadowAngle: Math.PI / 6,
		dropShadowDistance: 6
	});
	scoreText.y = -100; // Move score text up by 10px
	scoreText.x = -155; // Move score text right by 10px
	x = 100;
	y = 100;
	self.addChild(scoreText);
	self.updateScore = function (newScore) {
		scoreText.setText(newScore);
	};
});
// ScoreManager class to manage score logic
// ScoreManager class to manage score logic
// Sun class to represent a sun in the top right corner
var Sun = Container.expand(function () {
	var self = Container.call(this);
	var sunGraphics = self.attachAsset('sun', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	startPulsating(self); // Start the pulsating effect
});
// Function to create a pulsating effect
// Tree class to represent a tree with a 9:16 aspect ratio
var Tree = Container.expand(function () {
	var self = Container.call(this);
	var treeGraphics = self.attachAsset('tree', {
		anchorX: 0.5,
		anchorY: 1,
		antialias: true // Apply antialias effect
	});
	self.update = function () {
		// Add any specific update logic for the tree here
	};
});
// UFO class to represent a UFO flying across the screen
var UFO = Container.expand(function () {
	var self = Container.call(this);
	var ufoGraphics = self.attachAsset('ufo', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 3.2; // Decrease speed by 20%
	self.direction = Math.random() < 0.5 ? 1 : -1; // Random direction: 1 for right, -1 for left
	self.lastX = self.x; // Track last X position for future checks
	self.update = function () {
		self.x += self.speed * self.direction;
		self.y = 100 + Math.sin(self.x / 70) * 165; // Increase the wave pattern depth by 10%
		// If the UFO moves off-screen, destroy it and set to null
		if (self.lastX <= 2048 + self.width / 2 && self.x > 2048 + self.width / 2 || self.lastX >= -self.width / 2 && self.x < -self.width / 2) {
			self.destroy();
			ufo = null;
		}
		self.lastX = self.x; // Update lastX after movement
	};
});

/**** 
* Initialize Game
****/ 
/**** 
* Assets
LK.init.shape('branch', {width:50, height:10, color:0x8b4513, shape:'box'})
****/ 
// Initialize clouds array
var game = new LK.Game({
	// No title, no description
	backgroundColor: 0x000000 // Black
});

/**** 
* Game Code
****/ 
// Initialize UFO variable
/**** 
* Assets
LK.init.shape('branch', {width:50, height:10, color:0x8b4513, shape:'box'})
****/ 
// Initialize clouds array
var clouds = [];
var ufo = null;
// Bird2Effects class to handle effects and animations for Bird2
var Bird2Effects = function Bird2Effects(bird) {
	this.bird = bird;
	this.applyEffects = function () {
		// Add any specific effects or animations for Bird2 here
	};
};
// Bird1Effects class to handle effects and animations for Bird1
var Bird1Effects = function Bird1Effects(bird) {
	this.bird = bird;
	this.applyEffects = function () {
		// Add any specific effects or animations for Bird1 here
	};
};
function startPulsating(target) {
	function pulsate() {
		tween(target, {
			scaleX: 1.1,
			scaleY: 1.1
		}, {
			duration: 444,
			easing: tween.easeInOut,
			onFinish: function onFinish() {
				tween(target, {
					scaleX: 1.0,
					scaleY: 1.0
				}, {
					duration: 444,
					easing: tween.easeInOut,
					onFinish: pulsate
				});
			}
		});
	}
	pulsate();
}
// Define layers and layer management
var LAYER_BACKGROUND = 0;
var LAYER_CLOUDS = 1;
var LAYER_BIRDS = 2;
var LAYER_UFO = 3;
var LAYER_GRASS = 4;
var LAYER_CAT = 5;
var LAYER_RETICLE = 6;
var LAYER_LASER = 7;
var LAYER_SCORE = 8;
// Layer management functions
function setLayerIndex(object, layer) {
	game.setChildIndex(object, layer);
}
// Cleanup methods for each layer
function cleanupLayer(layer) {
	var children = game.children.slice();
	for (var i = children.length - 1; i >= 0; i--) {
		var child = children[i];
		if (game.getChildIndex(child) === layer) {
			if (child.destroy) {
				child.destroy();
			} else {
				game.removeChild(child);
			}
		}
	}
}
function cleanupBackground() {
	cleanupLayer(LAYER_BACKGROUND);
}
function cleanupClouds() {
	cleanupLayer(LAYER_CLOUDS);
	clouds = [];
}
function cleanupBirds() {
	cleanupLayer(LAYER_BIRDS);
	birds = [];
}
function cleanupUFO() {
	cleanupLayer(LAYER_UFO);
	ufo = null;
}
function cleanupGrass() {
	cleanupLayer(LAYER_GRASS);
}
function cleanupCat() {
	cleanupLayer(LAYER_CAT);
}
function cleanupReticle() {
	cleanupLayer(LAYER_RETICLE);
}
function cleanupLaser() {
	cleanupLayer(LAYER_LASER);
}
function cleanupScore() {
	cleanupLayer(LAYER_SCORE);
}
// Function to cleanup all layers
function cleanupAllLayers() {
	for (var i = 0; i <= LAYER_SCORE; i++) {
		cleanupLayer(i);
	}
	clouds = [];
	birds = [];
	ufo = null;
}
// Initialize game objects with layers
var background = LK.getAsset('background', {
	anchorX: 0.5,
	anchorY: 0.5
});
background.x = 2048 / 2;
background.y = 2732 / 2 - 200;
game.addChild(background);
setLayerIndex(background, LAYER_BACKGROUND);
// Add a sun to the game in the top left corner
var sun = game.addChild(new Sun());
sun.x = 480;
sun.y = 590;
setLayerIndex(sun, LAYER_CLOUDS);
// Initialize clouds array
var clouds = [];
for (var i = 0; i < 4; i++) {
	var cloud = new Cloud();
	cloud.x = Math.random() * 2048;
	cloud.y = Math.random() * (2732 / 2);
	clouds.push(cloud);
	game.addChild(cloud);
	setLayerIndex(cloud, LAYER_CLOUDS);
}
// Initialize birds array
var birds = [];
// Initialize birds
spawnBird1();
spawnBird2();
// Function to spawn a Bird2 and set its layer
function spawnBird2() {
	var bird = new Bird2();
	bird.x = Math.random() * 2048;
	bird.y = -bird.height;
	bird.speed = 1 + Math.random() * 0.6;
	bird.lastIntersecting = false;
	bird.type = 'Bird2';
	bird.color = 0x746130;
	LK.setTimeout(function () {
		game.addChild(bird);
		setLayerIndex(bird, LAYER_BIRDS);
		birds.push(bird);
	}, 2000);
}
// Function to spawn a bird and set its layer
function spawnBird1() {
	var bird = new Bird1();
	bird.x = Math.random() * 2048;
	bird.y = -bird.height;
	bird.speed = 1 + Math.random() * 0.6;
	bird.lastIntersecting = false;
	bird.type = 'Bird1';
	bird.color = 0x746130;
	LK.setTimeout(function () {
		game.addChild(bird);
		setLayerIndex(bird, LAYER_BIRDS);
		birds.push(bird);
	}, 2000);
}
// Ensure there are always 3 birds on screen
game.update = function () {
	// Update each bird
	birds.forEach(function (bird) {
		bird.update();
		// Check if the bird has moved off-screen
		if (bird.lastY <= 2732 && bird.y > 2732) {
			bird.y = -bird.height; // Respawn the bird at the top
			bird.x = Math.random() * 2048; // Randomize the x position
			bird.speed = 1 + Math.random() * 0.6; // Reset speed for new bird
		}
	});
};
// Add a tree to the game
var tree = game.addChild(new Tree());
tree.x = 2048 / 2 + 500; // Move the tree 500px to the right
tree.y = 2765; // Position the tree on the grass
var treeChildIndex = Math.min(7, game.children.length - 1);
game.setChildIndex(tree, treeChildIndex); // Set tree to be rendered after Bird1
var score = 0;
// Add the grass floor to the game
var grass = new Grass();
grass.x = 1020;
grass.y = 2735;
game.addChild(grass);
setLayerIndex(grass, LAYER_GRASS);
var grass2 = new Grass2();
grass2.x = 1020;
grass2.y = 2735; // Position grass2 at the bottom
game.addChild(grass2);
var grass2ChildIndex = game.getChildIndex(tree) + 1;
game.setChildIndex(grass2, grass2ChildIndex); // Set grass2 to be rendered after the tree
var scoreDisplay = new ScoreDisplay();
scoreDisplay.x = 2048 / 2 + 520;
scoreDisplay.y = 2732 - 185;
game.addChild(scoreDisplay);
setLayerIndex(scoreDisplay, LAYER_SCORE);
// Function to handle bgm1 end event
function onBgm1End() {
	// Set a timer to replay bgm1 after 50-80 seconds
	var bgmTimer = LK.setTimeout(function () {
		LK.playMusic('bgm1', {
			loop: true,
			fade: {
				start: 0,
				end: 1,
				duration: 4000
			},
			onEnd: onBgm1End
		});
	}, Math.random() * 30000 + 50000);
}
;
// Add the cat to the game
var cat = game.addChild(new Cat());
cat.x = 200; // Position the cat to the far left
cat.y = 2732; // Position the cat at the bottom of the screen
var catChildIndex = Math.min(10, game.children.length - 1);
game.setChildIndex(cat, catChildIndex); // Set cat to be rendered after the grass
// Play bgm1 once on load and set a timer to replay it every 20-50 seconds
LK.playMusic('bgm1', {
	loop: false,
	// Play once
	fade: {
		start: 0,
		end: 0.02,
		// Set to the lowest volume
		duration: 4000
	},
	onEnd: function onEnd() {
		// Set a timer to replay bgm1 every 20-50 seconds
		LK.setTimeout(function () {
			LK.playMusic('bgm1', {
				loop: false,
				// Play once
				fade: {
					start: 0,
					end: 0.5,
					// Set to the lowest volume
					duration: 4000
				},
				onEnd: onEnd // Set the onEnd function to replay bgm1
			});
		}, Math.random() * 30000 + 20000); // Random time between 20-50 seconds
	}
});
// Initialize a timer to play the wings1 sound at a random time between 10 and 30 seconds
var wingsTimer = LK.setTimeout(function () {
	LK.getSound('wings1').play();
	wingsTimer = LK.setTimeout(arguments.callee, Math.random() * 20000 + 10000);
}, Math.random() * 20000 + 10000);
// Create an array for all sounds except ufo1, including all birdsong sounds
var sounds = ['cricket1', 'frog1', 'wings1', 'songbird1'];
var currentAmbientSound = null;
// Initialize random timers for each sound to play between 30-50 seconds
sounds.forEach(function (soundId) {
	var sound = LK.getSound(soundId);
	var ambientSoundTimer = LK.setTimeout(function () {
		if (currentAmbientSound) {
			currentAmbientSound.stop(); // Stop the currently playing ambient sound
		}
		sound.play();
		currentAmbientSound = sound; // Set the current ambient sound
		// Set a timeout to reset the current ambient sound after it finishes playing
		LK.setTimeout(function () {
			currentAmbientSound = null;
		}, sound.duration * 1000); // Convert duration from seconds to milliseconds
		// Reset the timer to play the sound again between 30-50 seconds, plus an additional 5 seconds
		ambientSoundTimer = LK.setTimeout(arguments.callee, Math.random() * 20000 + 30000 + 5000);
	}, Math.random() * 20000 + 30000);
});

===================================================================
--- original.js
+++ change.js
@@ -344,14 +344,14 @@
 
 /**** 
 * Game Code
 ****/ 
-// Initialize clouds array
+// Initialize UFO variable
 /**** 
 * Assets
 LK.init.shape('branch', {width:50, height:10, color:0x8b4513, shape:'box'})
 ****/ 
-// Initialize UFO variable
+// Initialize clouds array
 var clouds = [];
 var ufo = null;
 // Bird2Effects class to handle effects and animations for Bird2
 var Bird2Effects = function Bird2Effects(bird) {