===================================================================
--- original.js
+++ change.js
@@ -1,1001 +1,1111 @@
 /**** 
 * Plugins
 ****/ 
-var storage = LK.import("@upit/storage.v1");
+var tween = LK.import("@upit/tween.v1");
 
 /**** 
+* Classes
+****/ 
+// Bird class to manage bird behavior
+var Bird = Container.expand(function () {
+	var self = Container.call(this);
+	var birdGraphics = self.attachAsset('bird', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	self.speed = Math.random() * 1.6 + 1;
+	self.lastY = self.y;
+	self.lastX = self.x;
+	self.update = function () {
+		self.y += self.speed;
+		self.x += Math.sin(self.y / 100) * 6.5;
+		if (self.lastY <= 2732 && self.y > 2732) {
+			self.destroy();
+			birds.splice(birds.indexOf(self), 1);
+			return;
+		}
+		self.lastY = self.y;
+		self.lastX = self.x;
+	};
+});
+// 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.movement = new Bird1Movement(self, birdGraphics);
+});
+// 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.movement = new Bird2Movement(self, birdGraphics);
+});
+// Cat class to manage cat behavior
+var Cat = Container.expand(function () {
+	var self = Container.call(this);
+	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.movement = new CloudMovement(self, cloudGraphics);
+});
+// 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
+	};
+});
+// GrassBack class to represent the grass image
+var GrassBack = Container.expand(function () {
+	var self = Container.call(this);
+	var grassGraphics = self.attachAsset('grass-back', {
+		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
+	};
+	self.addChild(grassGraphics); // Add grass graphics to the container
+	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
+	};
+});
+// GrassFront class to represent the second grass image
+var GrassFront = Container.expand(function () {
+	var self = Container.call(this);
+	var grass2Graphics = self.attachAsset('grass-front', {
+		anchorX: 0.5,
+		anchorY: 1
+	});
+	self.lastX = self.x; // Initialize lastX for tracking changes on X
+	self.addChild(grass2Graphics); // Add grass2 graphics to the container
+	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
+	};
+});
+// Jet class to represent a jet flying across the screen
+var Jet = Container.expand(function () {
+	var self = Container.call(this);
+	var jetGraphics = self.attachAsset('jet', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	// Add a label to the jet
+	var jetLabel = new Text2('Jet', {
+		size: 50,
+		fill: 0xFFFFFF
+	});
+	jetLabel.anchor.set(0.5, 0.5); // Center the label on the jet
+	jetLabel.y = -60; // Position the label above the jet
+	self.addChild(jetLabel);
+	// Add a label to the jet
+	var jetLabel = new Text2('Jet', {
+		size: 50,
+		fill: 0xFFFFFF
+	});
+	jetLabel.anchor.set(0.5, 0.5); // Center the label on the jet
+	jetLabel.y = -60; // Position the label above the jet
+	self.addChild(jetLabel);
+	self.speed = 10; // Set the speed of the jet
+	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.x = Math.random() < 0.5 ? 2048 + self.width / 2 : -self.width / 2; // Start from either the far right or left edge of the screen
+	self.update = function () {
+		self.x += self.speed * self.direction;
+		// If the jet moves off-screen, destroy it and set it 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();
+			game.jet = null;
+			game.jetSoundPlayed = false; // Reset the flag when the jet is removed
+			return; // Exit the update function
+		}
+		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();
+		}
+	};
+});
+// Light1 class to represent a light object
+var Light1 = Container.expand(function () {
+	var self = Container.call(this);
+	var lightGraphics = self.attachAsset('light1', {
+		anchorX: 0.5,
+		anchorY: 0.5,
+		alpha: 0.2 // Set transparency to 20%
+	});
+	self.x = 450, self.y = 450;
+	self.update = function () {
+		// Add any specific update logic for the light here
+	};
+	self.pulse = new Light1Pulse(lightGraphics);
+	self.pulse.startPulsating();
+});
+// Mirror class to manage score display
+var Mirror = Container.expand(function () {
+	var self = Container.call(this);
+	var scoreGraphics = self.attachAsset('mirror1', {
+		anchorX: 0.5,
+		anchorY: 0.5,
+		rotation: Math.PI / 14 // Rotate image right 15 degrees
+	});
+	var scoreText = new Text2('0', {
+		size: 175,
+		fill: 0x800080,
+		font: "Courier New, Courier, monospace",
+		// Segmented clock style font
+		stroke: 0x00FF00,
+		strokeThickness: 15,
+		dropShadow: true,
+		dropShadowColor: 0x000000,
+		dropShadowBlur: 5,
+		dropShadowAngle: Math.PI / 6,
+		dropShadowDistance: 6
+	});
+	scoreText.y = 50; // Move score text up by 20px
+	scoreText.x = -145; // Move score text left by 10px
+	scoreText.rotation = Math.PI / 12; // Rotate score text right 15 degrees
+	x = 100;
+	y = 100;
+	self.addChild(scoreText);
+	self.updateScore = function (newScore) {
+		scoreText.setText(newScore);
+	};
+});
+// 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
+	};
+	// Start the pulsating effect for the reticle
+	startPulsating(self);
+});
+// Sparkle class to manage sparkle behavior
+var Sparkle = Container.expand(function () {
+	var self = Container.call(this);
+	var sparkleGraphics = self.attachAsset('sparkle', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	self.update = function () {
+		// Add floating animation logic here
+	};
+	self.handleCollection = function () {
+		// Add collection state management here
+	};
+});
+// Stack1 class to represent the stack1 image
+var Stack1 = Container.expand(function () {
+	var self = Container.call(this);
+	var stackGraphics = self.attachAsset('stack1', {
+		anchorX: 0.5,
+		anchorY: 0.5,
+		rotation: Math.PI / -12
+	});
+	self.update = function () {
+		// Add any specific update logic for stack1 here
+	};
+});
+// 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
+	});
+	self.pulse = new SunPulse(sunGraphics);
+	self.pulse.startPulsating();
+});
+// 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 
+		stroke: 0x000000,
+		// Add a black stroke 
+		strokeThickness: 15 // Set stroke thickness to 15px 
+	});
+	self.update = function () {
+		// Add any specific update logic for the tree here
+	};
+});
+// UFO class to manage UFO behavior
+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;
+	self.lastX = self.x;
+	self.update = function () {
+		self.x += self.speed;
+		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;
+			return;
+		}
+		self.lastX = self.x;
+	};
+});
+
+/**** 
 * Initialize Game
 ****/ 
+// UFOMovement class to handle UFO movement
+/**** 
+* Assets
+LK.init.shape('branch', {width:50, height:10, color:0x8b4513, shape:'box'})
+****/ 
+// Initialize clouds array
 var game = new LK.Game({
-	backgroundColor: 0x000000
+	// No title, no description
+	backgroundColor: 0x000000 // Black
 });
 
 /**** 
 * Game Code
 ****/ 
-// Game objects in global scope
-function ownKeys(e, r) {
-	var t = Object.keys(e);
-	if (Object.getOwnPropertySymbols) {
-		var o = Object.getOwnPropertySymbols(e);
-		r && (o = o.filter(function (r) {
-			return Object.getOwnPropertyDescriptor(e, r).enumerable;
-		})), t.push.apply(t, o);
-	}
-	return t;
-}
-// Check if localStorage is accessible
-function isLocalStorageAccessible() {
-	try {
-		storage.test = 'test';
-		delete storage.test;
-		return true;
-	} catch (e) {
-		return false;
-	}
-}
-function _objectSpread(e) {
-	for (var r = 1; r < arguments.length; r++) {
-		var t = null != arguments[r] ? arguments[r] : {};
-		r % 2 ? ownKeys(Object(t), !0).forEach(function (r) {
-			_defineProperty(e, r, t[r]);
-		}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
-			Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
-		});
-	}
-	return e;
-}
-function _defineProperty(e, r, t) {
-	return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
-		value: t,
-		enumerable: !0,
-		configurable: !0,
-		writable: !0
-	}) : e[r] = t, e;
-}
-function _callSuper(t, o, e) {
-	return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e));
-}
-function _possibleConstructorReturn(t, e) {
-	if (e && ("object" == _typeof(e) || "function" == typeof e)) {
-		return e;
-	}
-	if (void 0 !== e) {
-		throw new TypeError("Derived constructors may only return object or undefined");
-	}
-	return _assertThisInitialized(t);
-}
-function _assertThisInitialized(e) {
-	if (void 0 === e) {
-		throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-	}
-	return e;
-}
-function _isNativeReflectConstruct() {
-	try {
-		var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
-	} catch (t) {}
-	return (_isNativeReflectConstruct = function _isNativeReflectConstruct() {
-		return !!t;
-	})();
-}
-function _getPrototypeOf(t) {
-	return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) {
-		return t.__proto__ || Object.getPrototypeOf(t);
-	}, _getPrototypeOf(t);
-}
-function _inherits(t, e) {
-	if ("function" != typeof e && null !== e) {
-		throw new TypeError("Super expression must either be null or a function");
-	}
-	t.prototype = Object.create(e && e.prototype, {
-		constructor: {
-			value: t,
-			writable: !0,
-			configurable: !0
+// BugFixer class to manage final testing and bug fixes
+// SunPulse class to handle the pulsating effect for Sun
+var BugFixer = function BugFixer() {
+	this.fixBugs = function () {
+		// Add bug fixing logic here
+	};
+};
+// PerformanceOptimizer class to manage performance and memory usage
+var PerformanceOptimizer = function PerformanceOptimizer() {
+	this.optimize = function () {
+		// Add optimization logic here
+	};
+};
+// EconomySystem class to manage gameplay mechanics and economy
+var EconomySystem = function EconomySystem() {
+	this.balanceMechanics = function () {
+		// Add balancing logic here
+	};
+};
+// AnimationSystem class to manage animations and visual feedback
+var AnimationSystem = function AnimationSystem() {
+	this.playIdleAnimation = function (character) {
+		// Add idle animation logic here
+	};
+	this.playFlightAnimation = function (bird) {
+		// Add flight animation logic here
+	};
+	this.playBeamEffect = function (ufo) {
+		// Add beam effect logic here
+	};
+};
+// SoundSystem class to manage sound effects and music
+var SoundSystem = function SoundSystem() {
+	this.initializeSoundSystem = function () {
+		// Add sound system initialization logic here
+	};
+};
+// SaveLoadSystem class to manage game state saving and loading
+var SaveLoadSystem = function SaveLoadSystem() {
+	this.saveGameState = function () {
+		// Add save logic here
+	};
+	this.loadGameState = function () {
+		// Add load logic here
+	};
+};
+// PurchaseSystem class to manage purchases and upgrades
+var PurchaseSystem = function PurchaseSystem() {
+	this.handlePurchases = function () {
+		// Add purchase logic here
+	};
+	this.updateUI = function () {
+		// Add UI update logic here
+	};
+};
+// CharmMechanics class to manage charm mechanics
+var CharmMechanics = function CharmMechanics() {
+	this.tryCharmBird = function (cat, birds) {
+		// Add charm logic here
+	};
+	this.getCharmRadius = function () {
+		return 100; // Example radius
+	};
+	this.handleCharmCooldown = function () {
+		// Add cooldown management here
+	};
+};
+// ParticleSystem class to manage particle effects
+var ParticleSystem = function ParticleSystem() {
+	this.createSparkleDust = function (x, y) {
+		// Add sparkle dust generation logic here
+	};
+	this.createBeamEffect = function (x, y) {
+		// Add beam effect logic here
+	};
+};
+// IdleProgression class to manage idle progression mechanics
+var IdleProgression = function IdleProgression() {
+	this.progress = 0;
+	this.update = function () {
+		// Add idle progression logic here
+	};
+};
+var SunPulse = function SunPulse(sunGraphics) {
+	this.sunGraphics = sunGraphics;
+	this.startPulsating = function () {
+		function pulsate() {
+			tween(this.sunGraphics, {
+				scaleX: 1.1,
+				scaleY: 1.1
+			}, {
+				duration: 1000,
+				easing: tween.easeInOut,
+				onFinish: function () {
+					tween(this.sunGraphics, {
+						scaleX: 1.0,
+						scaleY: 1.0
+					}, {
+						duration: 1000,
+						easing: tween.easeInOut,
+						onFinish: pulsate.bind(this)
+					});
+				}.bind(this)
+			});
 		}
-	}), Object.defineProperty(t, "prototype", {
-		writable: !1
-	}), e && _setPrototypeOf(t, e);
-}
-function _setPrototypeOf(t, e) {
-	return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {
-		return t.__proto__ = e, t;
-	}, _setPrototypeOf(t, e);
-}
-function _typeof(o) {
-	"@babel/helpers - typeof";
-	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
-		if (isLocalStorageAccessible()) {
-			return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
-		} else {
-			return typeof o;
+		pulsate.call(this);
+	};
+};
+// Light1Pulse class to handle the pulsating effect for Light1
+var Light1Pulse = function Light1Pulse(lightGraphics) {
+	this.lightGraphics = lightGraphics;
+	this.startPulsating = function () {
+		function pulsate() {
+			tween(this.lightGraphics, {
+				scaleX: 1.6,
+				scaleY: 1.6
+			}, {
+				duration: 1500,
+				easing: tween.easeInOut,
+				onFinish: function () {
+					tween(this.lightGraphics, {
+						scaleX: 1.0,
+						scaleY: 1.0
+					}, {
+						duration: 1500,
+						easing: tween.easeInOut,
+						onFinish: pulsate.bind(this)
+					});
+				}.bind(this)
+			});
 		}
-	} : function (o) {
-		if (isLocalStorageAccessible()) {
-			return typeof o;
-		} else {
-			return typeof o;
-		}
-	}, _typeof(o);
-}
-function _classCallCheck(a, n) {
-	if (!(a instanceof n)) {
-		throw new TypeError("Cannot call a class as a function");
+		pulsate.call(this);
+	};
+};
+var bird2; // Define bird2 variable in the global scope
+// Bird2Effects class to handle effects and animations for Bird2
+// Function to create a pulsating effect
+function startPulsating(target) {
+	var duration = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 888;
+	function pulsate() {
+		tween(target, {
+			scaleX: 1.0,
+			scaleY: 1.0
+		}, {
+			duration: duration,
+			easing: tween.easeInOut,
+			onFinish: function onFinish() {
+				tween(target, {
+					scaleX: 1.0,
+					scaleY: 1.0
+				}, {
+					duration: duration,
+					easing: tween.easeInOut,
+					onFinish: pulsate
+				});
+			}
+		});
 	}
+	pulsate();
 }
-function _defineProperties(e, r) {
-	for (var t = 0; t < r.length; t++) {
-		var o = r[t];
-		o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o);
-	}
-}
-function _createClass(e, r, t) {
-	return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", {
-		writable: !1
-	}), e;
-}
-function _toPropertyKey(t) {
-	var i = _toPrimitive(t, "string");
-	return "symbol" == _typeof(i) ? i : i + "";
-}
-function _toPrimitive(t, r) {
-	if ("object" != _typeof(t) || !t) {
-		return t;
-	}
-	var e = t[Symbol.toPrimitive];
-	if (void 0 !== e) {
-		var i = e.call(t, r || "default");
-		if ("object" != _typeof(i)) {
-			return i;
+// UFOSound class to manage UFO sound effects
+// UFOMovement class to handle UFO movement
+var UFOMovement = function UFOMovement(ufo, ufoGraphics) {
+	this.ufo = ufo;
+	this.ufoGraphics = ufoGraphics;
+	this.ufo.speed = 3.2; // Decrease speed by 20%
+	this.ufo.direction = Math.random() < 0.5 ? 1 : -1; // Random direction: 1 for right, -1 for left
+	this.ufo.lastX = this.ufo.x; // Track last X position for future checks
+	this.ufo.update = function () {
+		this.x += this.speed * this.direction;
+		this.y = 100 + Math.sin(this.x / 100) * 250; // Slow down the wave pattern by 50%
+		// Stop playing ufo1 sound after UFO leaves the screen
+		if (this.lastX <= 2048 + this.width / 2 && this.x > 2048 + this.width / 2 || this.lastX >= -this.width / 2 && this.x < -this.width / 2) {
+			this.destroy(); // Destroy the UFO when it moves off-screen
+			ufo = null;
+			LK.getSound('ufo1').stop();
+			return; // Exit the update function
 		}
-		throw new TypeError("@@toPrimitive must return a primitive value.");
-	}
-	return ("string" === r ? String : Number)(t);
-}
-var cats = [];
-var kittens = [];
-var birds = [];
-var ufos = [];
-var sparkles = [];
-var tree;
-var sparkleDust = 0;
-// Game parameters
-var GAME_CONFIG = {
-	catCost: 10,
-	kittenCost: 50,
-	ufoCost: 200,
-	catCharmPower: 1,
-	kittenCharmPower: 3,
-	catCharmInterval: 5000,
-	kittenCharmInterval: 3000,
-	ufoCollectSpeed: 150,
-	ufoCollectRange: 100,
-	birdSpawnInterval: 3000,
-	maxBirds: 10
+		this.lastX = this.x; // Update lastX after movement
+	};
 };
-var Cat = /*#__PURE__*/function () {
-	function Cat(x, y) {
-		_classCallCheck(this, Cat);
-		this.sprite = LK.getAsset('cat', {
-			anchorX: 0.5,
-			anchorY: 0.5
+var UFOSound = function UFOSound() {
+	this.play = function () {
+		LK.getSound('ufo1').play();
+	};
+};
+// BackgroundMusic class to manage background music
+var BackgroundMusic = function BackgroundMusic() {
+	this.play = function () {
+		LK.playMusic('bgm1', {
+			loop: true,
+			fade: {
+				start: 0,
+				end: 1,
+				duration: 4000
+			},
+			onEnd: onBgm1End
 		});
-		this.sprite.x = x;
-		this.sprite.y = y;
-		this.charmingCooldown = false;
-	}
-	return _createClass(Cat, [{
-		key: "getCharmRadius",
-		value: function getCharmRadius() {
-			return 100;
+	};
+};
+// LaserSound class to manage laser sound effects
+var LaserSound = function LaserSound() {
+	this.play = function () {
+		LK.getSound('laser1').play();
+	};
+};
+var Bird1Movement = function Bird1Movement(bird, birdGraphics) {
+	this.bird = bird;
+	this.birdGraphics = birdGraphics;
+	this.bird.speed = Math.random() * 1.6 + 1;
+	this.bird.lastY = this.bird.y; // Initialize lastY for tracking changes on Y
+	this.bird.lastX = this.bird.x; // Initialize lastX for tracking changes on X
+	this.bird.update = function () {
+		this.y += this.speed;
+		this.x += Math.sin(this.y / 100) * 6.5; // Increase the swooping motion of the bird's movement by 30%
+		// Check if the bird has moved off-screen
+		if (this.lastY <= 2732 && this.y > 2732) {
+			this.destroy(); // Destroy the bird when it moves off-screen
+			birds.splice(birds.indexOf(this.bird), 1); // Remove bird from the array
+			return; // Exit the update function
 		}
-	}, {
-		key: "tryCharmBird",
-		value: function tryCharmBird() {
-			if (this.charmingCooldown) {
-				return;
+		if (this.birdGraphics) {
+			if (this.lastX <= this.x) {
+				this.birdGraphics.texture = LK.getAsset('bird1-right', {}).texture;
+			} else if (this.lastX > this.x) {
+				this.birdGraphics.texture = LK.getAsset('bird1-left', {}).texture;
 			}
-			for (var _i = 0, _birds = birds; _i < _birds.length; _i++) {
-				var bird = _birds[_i];
-				if (bird.charmed) {
-					continue;
-				}
-				var dx = bird.sprite.x - this.sprite.x;
-				var dy = bird.sprite.y - this.sprite.y;
-				var distSq = dx * dx + dy * dy;
-				if (distSq <= this.getCharmRadius() * this.getCharmRadius()) {
-					var sparkleValue = bird.handleCharmed();
-					this.handleCharmCooldown();
-					// Create visual feedback for successful charm
-					var charm = LK.getAsset('sparkle', {
-						anchorX: 0.5,
-						anchorY: 0.5
-					});
-					charm.x = bird.sprite.x;
-					charm.y = bird.sprite.y;
-					charm.alpha = 0.7;
-					// Animate and remove the charm effect
-					setTimeout(function () {
-						charm.alpha = 0;
-						setTimeout(function () {
-							return LK.remove(charm);
-						}, 500);
-					}, 500);
-					return sparkleValue;
-				}
-			}
-			return 0;
+			this.lastX = this.x; // Update lastX after movement
 		}
-	}, {
-		key: "handleCharmCooldown",
-		value: function handleCharmCooldown() {
-			var _this = this;
-			this.charmingCooldown = true;
-			setTimeout(function () {
-				_this.charmingCooldown = false;
-			}, GAME_CONFIG.catCharmInterval);
-		}
-	}, {
-		key: "update",
-		value: function update() {
-			var sparkleValue = this.tryCharmBird();
-			if (sparkleValue > 0) {
-				Game.instance.createSparkle(this.sprite.x, this.sprite.y, sparkleValue);
+		this.lastY = this.y; // Update lastY after movement
+	};
+};
+var Bird2Movement = function Bird2Movement(bird, birdGraphics) {
+	this.bird = bird;
+	this.birdGraphics = birdGraphics;
+	this.bird.speed = Math.random() * 1.6 + 1;
+	this.bird.lastY = this.bird.y; // Initialize lastY for tracking changes on Y
+	this.bird.lastX = this.bird.x; // Initialize lastX for tracking changes on X
+	this.bird.update = function () {
+		this.y += this.speed;
+		this.x += Math.sin(this.y / 100) * 6.5; // Increase the swooping motion of the bird's movement by 30%
+		if (this.birdGraphics) {
+			if (this.lastX <= this.x) {
+				this.birdGraphics.texture = LK.getAsset('bird2-right', {}).texture;
+			} else if (this.lastX > this.x) {
+				this.birdGraphics.texture = LK.getAsset('bird2-left', {}).texture;
 			}
+			this.lastX = this.x; // Update lastX after movement
 		}
-	}]);
-}();
-var Kitten = /*#__PURE__*/function (_Cat) {
-	function Kitten(x, y) {
-		var _this2;
-		_classCallCheck(this, Kitten);
-		_this2 = _callSuper(this, Kitten, [x, y]);
-		_this2.sprite = LK.getAsset('kitten', {
-			anchorX: 0.5,
-			anchorY: 0.5
-		});
-		return _this2;
-	}
-	_inherits(Kitten, _Cat);
-	return _createClass(Kitten);
-}(Cat);
-var Bird = /*#__PURE__*/function () {
-	function Bird() {
-		_classCallCheck(this, Bird);
-		this.sprite = LK.getAsset('bird', {
-			anchorX: 0.5,
-			anchorY: 0.5
-		});
-		this.charmed = false;
-		this.setRandomPosition();
-	}
-	return _createClass(Bird, [{
-		key: "setRandomPosition",
-		value: function setRandomPosition() {
-			// Start from either side of screen
-			this.sprite.x = Math.random() < 0.5 ? -50 : LK.width + 50;
-			this.sprite.y = Math.random() * (LK.height * 0.6);
-			// Target position near tree with more varied positions
-			this.targetX = tree.x + (Math.random() * 400 - 200);
-			this.targetY = tree.y - (Math.random() * 400 + 50);
-			// Set random movement speed
-			this.moveSpeed = 0.01 + Math.random() * 0.02;
-			// Set random wobble for natural movement
-			this.wobbleOffset = Math.random() * Math.PI * 2;
-			this.wobbleSpeed = 1 + Math.random();
+		// Check if the bird has moved off-screen
+		if (this.lastY <= 2732 && this.y > 2732) {
+			this.destroy(); // Destroy the bird when it moves off-screen
+			birds.splice(birds.indexOf(this.bird), 1); // Remove bird from the array
+			return; // Exit the update function
 		}
-	}, {
-		key: "update",
-		value: function update() {
-			if (this.charmed) {
-				// Charmed birds slowly float upward with spiral motion
-				this.sprite.y -= 0.5;
-				this.sprite.x += Math.sin(Date.now() / 500) * 0.5;
-				this.sprite.rotation += 0.02;
-				this.sprite.alpha = Math.max(0.2, this.sprite.alpha - 0.001);
-				// Remove bird when it's nearly invisible
-				if (this.sprite.alpha <= 0.2) {
-					var index = birds.indexOf(this);
-					if (index > -1) {
-						birds.splice(index, 1);
-						LK.remove(this.sprite);
-					}
-				}
-				return;
-			}
-			// Move towards target with wobble
-			var dx = this.targetX - this.sprite.x;
-			var dy = this.targetY - this.sprite.y;
-			var dist = Math.sqrt(dx * dx + dy * dy);
-			if (dist > 1) {
-				// Add wobble to movement
-				var wobble = Math.sin(this.wobbleOffset + Date.now() / 1000) * 5 * this.wobbleSpeed;
-				this.sprite.x += dx * this.moveSpeed;
-				this.sprite.y += dy * this.moveSpeed + wobble * 0.1;
-				// Rotate bird based on movement direction
-				var angle = Math.atan2(dy, dx);
-				this.sprite.rotation = angle + Math.PI / 2;
-				// Check if bird is too far from tree and remove it
-				var distFromTree = Math.sqrt(Math.pow(this.sprite.x - tree.x, 2) + Math.pow(this.sprite.y - tree.y, 2));
-				if (distFromTree > LK.canvas.width) {
-					var index = birds.indexOf(this);
-					if (index > -1) {
-						birds.splice(index, 1);
-						LK.remove(this.sprite);
-					}
-				}
-			}
+		this.lastY = this.y; // Update lastY after movement
+	};
+};
+var CloudMovement = function CloudMovement(cloud, cloudGraphics) {
+	this.cloud = cloud;
+	this.cloudGraphics = cloudGraphics;
+	this.cloud.speed = Math.random() * 0.55 + 0.25; // Adjust speed to range between 0.25 and 0.8
+	this.cloud.hasAccelerated = false; // Track if the cloud has already accelerated
+	this.cloud.direction = Math.random() < 0.5 ? 1 : -1; // Random direction: 1 for right, -1 for left
+	this.cloud.lastX = this.cloud.x; // Track last X position for future checks
+	this.cloud.lastIntersecting = false; // Initialize lastIntersecting for tracking changes on intersections
+	this.cloud.update = function () {
+		this.x += this.speed * this.direction;
+		// If the cloud moves off-screen, reposition it to the opposite side
+		if (this.lastX <= 2048 + this.width / 2 && this.x > 2048 + this.width / 2 || this.lastX >= -this.width / 2 && this.x < -this.width / 2) {
+			this.destroy(); // Destroy the cloud when it moves off-screen
+			clouds.splice(clouds.indexOf(this.cloud), 1); // Remove cloud from the array
+			return; // Exit the update function
 		}
-	}, {
-		key: "handleCharmed",
-		value: function handleCharmed() {
-			var _this3 = this;
-			if (this.charmed) {
-				return 0;
-			}
-			this.charmed = true;
-			// Visual feedback for charmed state
-			this.sprite.tint = 0xFFAAFF;
-			this.sprite.alpha = 0.8;
-			// Remove bird after floating away
-			setTimeout(function () {
-				var index = birds.indexOf(_this3);
-				if (index > -1) {
-					birds.splice(index, 1);
+		// Check for overlap with other clouds
+		for (var i = 0; i < clouds.length; i++) {
+			if (clouds[i] !== this && this.intersects(clouds[i])) {
+				if (!this.hasAccelerated) {
+					this.speed *= 1.5; // Increase speed by 50%
+					this.hasAccelerated = true; // Mark as accelerated
 				}
-			}, 3000);
-			return GAME_CONFIG.catCharmPower;
-		}
-	}]);
-}();
-var UFO = /*#__PURE__*/function () {
-	function UFO(x, y) {
-		_classCallCheck(this, UFO);
-		this.sprite = LK.getAsset('ufo', {
-			anchorX: 0.5,
-			anchorY: 0.5
-		});
-		this.sprite.x = x;
-		this.sprite.y = y;
-		this.targetSparkle = null;
-	}
-	return _createClass(UFO, [{
-		key: "findNearestSparkle",
-		value: function findNearestSparkle() {
-			var nearest = null;
-			var minDist = Infinity;
-			for (var _i2 = 0, _sparkles = sparkles; _i2 < _sparkles.length; _i2++) {
-				var sparkle = _sparkles[_i2];
-				if (sparkle.targetedByUFO) {
-					continue;
-				}
-				var dx = sparkle.sprite.x - this.sprite.x;
-				var dy = sparkle.sprite.y - this.sprite.y;
-				var distSq = dx * dx + dy * dy;
-				if (distSq < minDist) {
-					minDist = distSq;
-					nearest = sparkle;
-				}
+				break;
+			} else if (this.hasAccelerated && !this.intersects(clouds[i])) {
+				this.speed /= 1.5; // Reset speed to original
+				this.hasAccelerated = false; // Reset acceleration state
 			}
-			return nearest;
 		}
-	}, {
-		key: "moveToSparkle",
-		value: function moveToSparkle() {
-			if (!this.targetSparkle) {
-				return;
+		// Check if the cloud intersects with the sun
+		if (!this.lastIntersecting && this.intersects(sun)) {
+			this.speed *= 2; // Double the speed when touching the sun
+			if (this.cloudGraphics) {
+				tween(this.cloudGraphics, {
+					alpha: 0.5
+				}, {
+					duration: 3000,
+					easing: tween.linear
+				});
 			}
-			var dx = this.targetSparkle.sprite.x - this.sprite.x;
-			var dy = this.targetSparkle.sprite.y - this.sprite.y;
-			var dist = Math.sqrt(dx * dx + dy * dy);
-			if (dist > GAME_CONFIG.ufoCollectRange) {
-				this.sprite.x += dx / dist * GAME_CONFIG.ufoCollectSpeed * 0.016;
-				this.sprite.y += dy / dist * GAME_CONFIG.ufoCollectSpeed * 0.016;
-				// Rotate UFO based on movement direction
-				this.sprite.rotation = Math.atan2(dy, dx) + Math.PI / 2;
-				// Add collection beam effect when close
-				if (dist < GAME_CONFIG.ufoCollectRange * 2) {
-					var beam = LK.getAsset('beam', {
-						anchorX: 0.5
-					});
-					beam.x = this.sprite.x;
-					beam.y = this.sprite.y;
-					beam.alpha = 0.3;
-					beam.rotation = this.sprite.rotation;
-					setTimeout(function () {
-						LK.remove(beam);
-					}, 100);
-				}
-			} else {
-				this.collectSparkle();
+		} else if (this.lastIntersecting && !this.intersects(sun)) {
+			this.speed /= 2; // Reset speed to original when not touching the sun
+			if (this.cloudGraphics) {
+				tween(this.cloudGraphics, {
+					alpha: 1.0
+				}, {
+					duration: 3000,
+					easing: tween.linear
+				});
 			}
 		}
-	}, {
-		key: "collectSparkle",
-		value: function collectSparkle() {
-			if (!this.targetSparkle) {
-				return;
-			}
-			sparkleDust += this.targetSparkle.value;
-			var index = sparkles.indexOf(this.targetSparkle);
-			if (index > -1) {
-				sparkles.splice(index, 1);
-			}
-			this.targetSparkle = null;
+		this.lastIntersecting = this.intersects(sun);
+		this.lastX = this.x; // Update lastX after movement
+	};
+};
+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
+	};
+};
+var background = LK.getAsset('background', {
+	anchorX: 0.5,
+	anchorY: 0.5
+});
+background.x = 2048 / 2;
+background.y = 2732 / 2 - 100;
+game.addChild(background);
+// ScoreManager class to manage score logic
+var ScoreManager = function ScoreManager() {
+	var self = this;
+	self.score = 0;
+	self.addScore = function (points) {
+		self.score += points;
+		return self.score;
+	};
+	self.resetScore = function () {
+		self.score = 0;
+	};
+	self.getScore = function () {
+		return self.score;
+	};
+};
+var ScoreManager = function ScoreManager() {
+	var self = this;
+	self.score = 0;
+	self.addScore = function (points) {
+		self.score += points;
+		return self.score;
+	};
+	self.resetScore = function () {
+		self.score = 0;
+	};
+	self.getScore = function () {
+		return self.score;
+	};
+};
+var birds = [];
+game.down = function (x, y, obj) {
+	// Check if tap is on the tree
+	if (tree.containsPoint({
+		x: x,
+		y: y
+	})) {
+		// Trigger sparkle burst effect
+		createSparkleBurst(x, y);
+	}
+	if (!game.reticle) {
+		game.reticle = game.addChild(new Reticle());
+		if (game.children.includes(game.reticle)) {
+			game.setChildIndex(game.reticle, 7); // Set reticle to be rendered after the tree
 		}
-	}, {
-		key: "update",
-		value: function update() {
-			if (!this.targetSparkle) {
-				this.targetSparkle = this.findNearestSparkle();
-				if (this.targetSparkle) {
-					this.targetSparkle.targetedByUFO = this;
-				}
-			}
-			this.moveToSparkle();
-		}
-	}]);
-}();
-var Sparkle = /*#__PURE__*/function () {
-	function Sparkle(x, y, value) {
-		_classCallCheck(this, Sparkle);
-		this.sprite = LK.getAsset('sparkle', {
-			anchorX: 0.5,
-			anchorY: 0.5
-		});
-		this.sprite.x = x;
-		this.sprite.y = y;
-		this.value = value;
-		this.targetedByUFO = null;
-		this.floatOffset = Math.random() * Math.PI * 2;
-		this.floatSpeed = 1 + Math.random();
-		this.collected = false;
 	}
-	return _createClass(Sparkle, [{
-		key: "update",
-		value: function update() {
-			if (this.collected) {
-				// Fade out collected sparkles
-				this.sprite.alpha = Math.max(0, this.sprite.alpha - 0.05);
-				if (this.sprite.alpha <= 0) {
-					var index = sparkles.indexOf(this);
-					if (index > -1) {
-						sparkles.splice(index, 1);
-						LK.remove(this.sprite);
-					}
-				}
-				return;
-			}
-			// Floating animation
-			this.sprite.y += Math.sin(this.floatOffset + Date.now() / 1000) * 0.5 * this.floatSpeed;
-			// Gentle sparkle rotation
-			this.sprite.rotation += 0.01 * this.floatSpeed;
-			// Pulsing effect
-			this.sprite.alpha = 0.7 + Math.sin(Date.now() / 500) * 0.3;
+	game.reticle.x = x;
+	game.reticle.y = y;
+	var laser = new Laser(cat.x - 140, cat.y - 440, x, y); // laser starting point
+	game.addChild(laser);
+	if (game.children.includes(laser) && game.children.includes(game.reticle)) {
+		game.setChildIndex(laser, game.getChildIndex(game.reticle) + 1); // Ensure laser is rendered after the reticle
+	}
+};
+var VOLUME_BGM1 = 0.02;
+var VOLUME_BREEZE1 = 0.02;
+var VOLUME_CRICKET1 = 0.02;
+var VOLUME_FROG1 = 0.02;
+var VOLUME_SONGBIRD1 = 0.02;
+var VOLUME_UFO1 = 0.02;
+var VOLUME_WINGS1 = 0.02;
+game.move = function (x, y, obj) {
+	if (!game.reticle) {
+		game.reticle = game.addChild(new Reticle());
+	}
+	if (obj.event) {
+		var x = obj.event.x;
+		var y = obj.event.y;
+	}
+	game.reticle.x = x;
+	game.reticle.y = y;
+};
+// Add a sun to the game in the top left corner
+var sun = game.addChild(new Sun());
+sun.x = 480;
+sun.y = 680;
+// Ensure sun is added to the game before setting its index
+if (game.children.includes(sun)) {
+	game.setChildIndex(sun, 1); // Set sun to be rendered after the background
+}
+var light1 = game.addChild(new Light1());
+light1.x = 530; // Move light1 right by 50px
+light1.y = 1500; // Move light1 down by 210px
+// Ensure light1 is added to the game before setting its index
+if (game.children.includes(light1)) {
+	game.setChildIndex(light1, 2); // Set light1 to be rendered after the sun
+}
+// Function to add a UFO to the game
+function addUFO() {
+	var ufo = new UFO();
+	game.addChild(ufo);
+	// Ensure UFO is added to the game before setting its index
+	if (game.children.includes(ufo) && game.children.includes(clouds[0])) {
+		game.setChildIndex(ufo, game.getChildIndex(clouds[0]) + 1); // Set UFO to be rendered after the first cloud
+	}
+	ufo.x = Math.random() < 0.5 ? 2048 + ufo.width / 2 : -ufo.width / 2; // Start from either the far right or left edge of the screen
+	ufo.y = Math.random() * (2732 / 2 - ufo.height); // Random initial y position within the top half of the screen
+	ufo.customUpdate = function () {
+		ufo.update();
+	};
+	// Removed ufo sound playing at startup
+	return ufo;
+}
+// Initialize clouds array
+var clouds = [];
+for (var i = 0; i < 4; i++) {
+	// Add 3 clouds for variety
+	var cloud = new Cloud();
+	cloud.x = Math.random() * 2048;
+	cloud.y = Math.random() * (2732 / 2); // Position clouds in the upper half of the screen
+	clouds.push(cloud);
+	game.addChild(cloud);
+	// Ensure cloud is added to the game before setting its index
+	if (game.children.includes(cloud)) {
+		game.setChildIndex(cloud, 2); // Set clouds to be rendered after the sun
+	}
+}
+var bird1; // Define bird1 variable in the global scope
+// Initialize birds
+spawnBird1();
+spawnBird2();
+spawnBird2();
+// Initialize a timer to add a UFO at a random time between 20 and 30 seconds
+var ufo; // Define the ufo variable in the global scope
+var laser; // Define the laser variable in the global scope
+var ufoTimer = LK.setTimeout(function () {
+	addUFO();
+	// Reset the timer for the UFO to reappear between 10-20 seconds
+	ufoTimer = LK.setTimeout(arguments.callee, Math.random() * 10000 + 10000);
+}, Math.random() * 10000 + 10000); // Initial interval for UFO appearances between 10 to 20 seconds
+game.update = function () {
+	for (var i = 0; i < clouds.length; i++) {
+		clouds[i].update();
+	}
+	// Add a jet to the game
+	if (!game.jet) {
+		var jet = new Jet();
+		jet.x = Math.random() < 0.5 ? 2048 + jet.width / 2 : -jet.width / 2; // Start from either the far right or left edge of the screen
+		jet.y = Math.random() * (2732 - jet.height); // Random initial y position within the screen height
+		game.addChild(jet);
+		if (game.children.includes(jet)) {
+			game.setChildIndex(jet, game.children.length - 1); // Bring the jet to the front by setting its index to the highest value
 		}
-	}, {
-		key: "handleCollection",
-		value: function handleCollection() {
-			if (this.collected) {
-				return false;
-			}
-			this.collected = true;
-			return true;
+		game.jet = jet;
+		if (!game.jetSoundPlayed) {
+			LK.getSound('jetSound').play(); // Play jet sound when it appears
+			game.jetSoundPlayed = true; // Ensure it only plays once
 		}
-	}]);
-}();
-var Game = /*#__PURE__*/function () {
-	function Game() {
-		_classCallCheck(this, Game);
 	}
-	return _createClass(Game, [{
-		key: "initialize",
-		value: function initialize() {
-			Game.instance = this;
-			LK.backgroundColor = 0x87CEFA; // Set background color through LK
-			// Ensure LK is initialized before accessing canvas
-			if (!LK || !LK.canvas) {
-				console.error('LK engine not properly initialized');
-				return;
-			}
-			// Ensure all shapes are initialized
-			if (!LK.getAsset('beam', {}) || !LK.getAsset('bird', {}) || !LK.getAsset('cat', {}) || !LK.getAsset('kitten', {}) || !LK.getAsset('sparkle', {}) || !LK.getAsset('tree', {}) || !LK.getAsset('ufo', {})) {
-				console.error('One or more shapes are not properly initialized');
-				return;
-			}
-			// Reset all game arrays
-			cats = [];
-			kittens = [];
-			birds = [];
-			ufos = [];
-			sparkles = [];
-			// Add a background image to the game
-			var background = new Background(LK.canvas.width / 2, LK.canvas.height / 2);
-			game.addChild(background);
-			this.setupTree();
-			this.setupInitialState();
-			this.setupEventListeners();
-			this.startBirdSpawner();
-		}
-	}, {
-		key: "startBirdSpawner",
-		value: function startBirdSpawner() {
-			setInterval(function () {
-				if (birds.length < GAME_CONFIG.maxBirds) {
-					birds.push(new Bird());
+	// Update jet
+	if (game.jet) {
+		game.jet.update();
+		if (game.jet.lastX <= 2048 + game.jet.width / 2 && game.jet.x > 2048 + game.jet.width / 2 || game.jet.lastX >= -game.jet.width / 2 && game.jet.x < -game.jet.width / 2) {
+			game.jet.destroy();
+			game.jet = null;
+			game.jetSoundPlayed = false; // Reset the flag when the jet is removed
+			// Set a timer to respawn the jet between 10-20 seconds
+			LK.setTimeout(function () {
+				var jet = new Jet();
+				jet.x = Math.random() < 0.5 ? 2048 + jet.width / 2 : -jet.width / 2; // Start from either the far right or left edge of the screen
+				jet.y = Math.random() * (2732 - jet.height); // Random initial y position within the screen height
+				game.addChild(jet);
+				game.jet = jet;
+				if (!game.jetSoundPlayed) {
+					LK.getSound('jetSound').play(); // Play jet sound when it appears
+					game.jetSoundPlayed = true; // Ensure it only plays once
 				}
-			}, GAME_CONFIG.birdSpawnInterval);
+			}, Math.random() * 10000 + 10000); // Random time between 10-20 seconds
 		}
-	}, {
-		key: "createSparkle",
-		value: function createSparkle(x, y, value) {
-			var sparkle = new Sparkle(x, y, value);
-			sparkles.push(sparkle);
-		}
-	}, {
-		key: "setupTree",
-		value: function setupTree() {
-			var _this4 = this;
-			if (!LK || !LK.canvas) {
-				return;
-			}
-			tree = LK.getAsset('tree', {
-				anchorX: 0.5,
-				anchorY: 1
-			});
-			tree.x = LK.canvas.width / 2;
-			tree.y = LK.canvas.height - 10;
-			// Make tree interactive for sparkle generation
-			tree.interactive = true;
-			// Add a reticle to indicate interactive areas
-			var reticle = new Reticle1(tree.x, tree.y - 50);
-			game.addChild(reticle);
-			tree.on('pointerdown', function (obj) {
-				var pos = scope.toLocal(obj.global);
-				_this4.createSparkle(pos.x, pos.y, 1);
-			});
-		}
-	}, {
-		key: "setupInitialState",
-		value: function setupInitialState() {
-			sparkleDust = 50;
-			this.addCat();
-			this.addUFO();
-		}
-	}, {
-		key: "setupEventListeners",
-		value: function setupEventListeners() {
-			var _this5 = this;
-			// Create UI buttons using LK
-			var buttonStyle = {
-				backgroundColor: 0xFF5733,
-				// Change button background color for better visibility
-				textColor: 0xFFFFFF // Keep text color white for contrast
-			};
-			var buttonYStart = 50;
-			var buttonYSpacing = 50;
-			var catButton = LK.CreateButton(_objectSpread(_objectSpread({
-				text: "Buy Cat (".concat(GAME_CONFIG.catCost, ")"),
-				x: 10,
-				y: buttonYStart,
-				width: 120,
-				height: 30
-			}, buttonStyle), {}, {
-				pointerup: function pointerup() {
-					return _this5.addCat();
-				},
-				scope: this
-			}));
-			var kittenButton = LK.CreateButton(_objectSpread(_objectSpread({
-				text: "Buy Kitten (".concat(GAME_CONFIG.kittenCost, ")"),
-				x: 10,
-				y: buttonYStart + buttonYSpacing,
-				width: 120,
-				height: 30
-			}, buttonStyle), {}, {
-				pointerup: function pointerup() {
-					return _this5.addKitten();
-				},
-				scope: this
-			}));
-			var ufoButton = LK.CreateButton(_objectSpread(_objectSpread({
-				text: "Buy UFO (".concat(GAME_CONFIG.ufoCost, ")"),
-				x: 10,
-				y: buttonYStart + buttonYSpacing * 2,
-				width: 120,
-				height: 30
-			}, buttonStyle), {}, {
-				pointerup: function pointerup() {
-					return _this5.addUFO();
-				},
-				scope: this
-			}));
-			// Create sparkle dust counter
-			// Add a score image next to the sparkle dust counter
-			var scoreImage = new ScoreImage(150, 25);
-			game.addChild(scoreImage);
-			this.sparkleDustText = LK.CreateText({
-				text: "Sparkle Dust: ".concat(sparkleDust),
-				x: 10,
-				y: 10,
-				style: {
-					fill: 0xFFFFFF,
-					fontSize: 16
-				}
-			});
-		}
-	}, {
-		key: "update",
-		value: function update() {
-			cats.forEach(function (cat) {
-				return cat.update();
-			});
-			kittens.forEach(function (kitten) {
-				return kitten.update();
-			});
-			birds.forEach(function (bird) {
-				return bird.update();
-			});
-			ufos.forEach(function (ufo) {
-				return ufo.update();
-			});
-			sparkles.forEach(function (sparkle) {
-				return sparkle.update();
-			});
-			this.updateUI();
-		}
-	}, {
-		key: "addCat",
-		value: function addCat() {
-			if (sparkleDust >= GAME_CONFIG.catCost) {
-				var cat = new Cat(tree.x + Math.random() * 100 - 50, tree.y - Math.random() * 100);
-				cats.push(cat);
-				sparkleDust -= GAME_CONFIG.catCost;
-				this.updateUI();
-			}
-		}
-	}, {
-		key: "addKitten",
-		value: function addKitten() {
-			if (sparkleDust >= GAME_CONFIG.kittenCost) {
-				var kitten = new Kitten(tree.x + Math.random() * 100 - 50, tree.y - Math.random() * 100);
-				kittens.push(kitten);
-				sparkleDust -= GAME_CONFIG.kittenCost;
-				this.updateUI();
-			}
-		}
-	}, {
-		key: "addUFO",
-		value: function addUFO() {
-			if (sparkleDust >= GAME_CONFIG.ufoCost) {
-				var ufo = new UFO(tree.x + Math.random() * 200 - 100, tree.y - Math.random() * 200);
-				ufos.push(ufo);
-				sparkleDust -= GAME_CONFIG.ufoCost;
-				this.updateUI();
-			}
-		}
-	}, {
-		key: "updateUI",
-		value: function updateUI() {
-			if (this.sparkleDustText) {
-				this.sparkleDustText.text = "Sparkle Dust: ".concat(Math.floor(sparkleDust));
-			}
-		}
-	}]);
-	//addition methods
-}();
-_defineProperty(Game, "instance", null);
-var Beam = /*#__PURE__*/function () {
-	function Beam(x, y) {
-		_classCallCheck(this, Beam);
-		this.sprite = LK.getAsset('beam', {
-			anchorX: 0.5,
-			anchorY: 0.5
-		});
-		this.sprite.x = x;
-		this.sprite.y = y;
 	}
-	return _createClass(Beam);
-}();
-var Tree = /*#__PURE__*/function () {
-	function Tree(x, y) {
-		_classCallCheck(this, Tree);
-		this.sprite = LK.getAsset('tree', {
-			anchorX: 0.5,
-			anchorY: 1
-		});
-		this.sprite.x = x;
-		this.sprite.y = y;
-	}
-	return _createClass(Tree);
-}();
-var Sparkle = /*#__PURE__*/function () {
-	function Sparkle(x, y, value) {
-		_classCallCheck(this, Sparkle);
-		this.sprite = LK.getAsset('sparkle', {
-			anchorX: 0.5,
-			anchorY: 0.5
-		});
-		this.sprite.x = x;
-		this.sprite.y = y;
-		this.value = value;
-		this.targetedByUFO = null;
-		this.floatOffset = Math.random() * Math.PI * 2;
-		this.floatSpeed = 1 + Math.random();
-		this.collected = false;
-	}
-	return _createClass(Sparkle, [{
-		key: "update",
-		value: function update() {
-			if (this.collected) {
-				this.sprite.alpha = Math.max(0, this.sprite.alpha - 0.05);
-				if (this.sprite.alpha <= 0) {
-					var index = sparkles.indexOf(this);
-					if (index > -1) {
-						sparkles.splice(index, 1);
-						LK.remove(this.sprite);
+	if (ufo) {
+		ufo.customUpdate();
+		// Update each laser
+		game.children.forEach(function (child) {
+			if (child instanceof Laser) {
+				child.update();
+				// Check for intersections with birds and UFO
+				birds.forEach(function (bird) {
+					if (!child.lastIntersecting && child.intersects(bird)) {
+						if (bird instanceof Bird1) {
+							score += 5;
+						} else if (bird instanceof Bird2 || bird instanceof Bird3) {
+							score += 1;
+						}
+						scoreDisplay.updateScore(score); // Update the score display
+						bird.destroy(); // Remove the bird when hit by a laser
+						birds.splice(birds.indexOf(bird), 1); // Remove bird from the array
+						child.destroy();
 					}
+					child.lastIntersecting = birds.some(function (bird) {
+						return child.intersects(bird);
+					});
+				});
+				if (ufo && !child.lastIntersecting && child.intersects(ufo)) {
+					score += 25;
+					score.updateScore(score);
+					child.destroy();
 				}
-				return;
+				child.lastIntersecting = birds.some(function (bird) {
+					return child.intersects(bird);
+				}) || ufo && child.intersects(ufo);
 			}
-			this.sprite.y += Math.sin(this.floatOffset + Date.now() / 1000) * 0.5 * this.floatSpeed;
-			this.sprite.rotation += 0.01 * this.floatSpeed;
-			this.sprite.alpha = 0.7 + Math.sin(Date.now() / 500) * 0.3;
-		}
-	}, {
-		key: "handleCollection",
-		value: function handleCollection() {
-			if (this.collected) {
-				return false;
+		});
+		// Check for intersections between UFO and birds
+		birds.forEach(function (bird) {
+			if (!ufo.lastIntersecting && ufo.intersects(bird)) {
+				bird.destroy(); // Remove the bird when touched by the UFO
+				birds.splice(birds.indexOf(bird), 1); // Remove bird from the array
+				LK.getSound('electro').play(); // Play the 'electro' sound
 			}
-			this.collected = true;
-			return true;
-		}
-	}]);
-}();
-var Bird = /*#__PURE__*/function () {
-	function Bird() {
-		_classCallCheck(this, Bird);
-		this.sprite = LK.getAsset('bird', {
-			anchorX: 0.5,
-			anchorY: 0.5
+			ufo.lastIntersecting = birds.some(function (bird) {
+				return ufo.intersects(bird);
+			});
 		});
-		this.charmed = false;
-		this.setRandomPosition();
+		if (ufo.lastX <= 2048 + ufo.width / 2 && ufo.x > 2048 + ufo.width / 2 || ufo.lastX >= -ufo.width / 2 && ufo.x < -ufo.width / 2) {
+			// Destroy the UFO and set it to null
+			ufo.destroy();
+			ufo = null;
+			// Start a timer for the UFO to reappear between 30-50 seconds
+			ufoTimer = LK.setTimeout(function () {
+				ufo = addUFO();
+			}, Math.random() * 20000 + 30000);
+		} else {}
+		ufo.lastX = ufo.x; // Update lastX for the UFO
 	}
-	return _createClass(Bird, [{
-		key: "setRandomPosition",
-		value: function setRandomPosition() {
-			this.sprite.x = Math.random() < 0.5 ? -50 : LK.width + 50;
-			this.sprite.y = Math.random() * (LK.height * 0.6);
-			this.targetX = tree.x + (Math.random() * 400 - 200);
-			this.targetY = tree.y - (Math.random() * 400 + 50);
-			this.moveSpeed = 0.01 + Math.random() * 0.02;
-			this.wobbleOffset = Math.random() * Math.PI * 2;
-			this.wobbleSpeed = 1 + Math.random();
-		}
-	}, {
-		key: "update",
-		value: function update() {
-			if (this.charmed) {
-				this.sprite.y -= 0.5;
-				this.sprite.x += Math.sin(Date.now() / 500) * 0.5;
-				this.sprite.rotation += 0.02;
-				this.sprite.alpha = Math.max(0.2, this.sprite.alpha - 0.001);
-				if (this.sprite.alpha <= 0.2) {
-					var index = birds.indexOf(this);
-					if (index > -1) {
-						birds.splice(index, 1);
-						LK.remove(this.sprite);
-					}
-				}
-				return;
+	// Removed auto-targeting update function
+};
+// Function to spawn a third kind of bird
+function spawnBird1() {
+	var bird1 = new Bird1();
+	bird1.x = Math.random() * 2048;
+	bird1.y = -bird1.height;
+	bird1.speed = 1 + Math.random() * 0.6;
+	bird1.lastIntersecting = false;
+	bird1.type = 'bird1'; // Specific property for Bird1
+	bird1.color = 0x746130; // Specific color for Bird1
+	LK.setTimeout(function () {
+		game.addChild(bird1);
+		// Ensure bird1 is added to the game before setting its index
+		if (game.children.includes(bird1)) {
+			if (game.children.includes(bird1) && game.children.includes(tree)) {
+				game.setChildIndex(bird1, game.getChildIndex(tree)); // Set Bird1 to be rendered before tree
 			}
-			var dx = this.targetX - this.sprite.x;
-			var dy = this.targetY - this.sprite.y;
-			var dist = Math.sqrt(dx * dx + dy * dy);
-			if (dist > 1) {
-				var wobble = Math.sin(this.wobbleOffset + Date.now() / 1000) * 5 * this.wobbleSpeed;
-				this.sprite.x += dx * this.moveSpeed;
-				this.sprite.y += dy * this.moveSpeed + wobble * 0.1;
-				var angle = Math.atan2(dy, dx);
-				this.sprite.rotation = angle + Math.PI / 2;
-				var distFromTree = Math.sqrt(Math.pow(this.sprite.x - tree.x, 2) + Math.pow(this.sprite.y - tree.y, 2));
-				if (distFromTree > LK.canvas.width) {
-					var index = birds.indexOf(this);
-					if (index > -1) {
-						birds.splice(index, 1);
-						LK.remove(this.sprite);
-					}
-				}
-			}
 		}
-	}, {
-		key: "handleCharmed",
-		value: function handleCharmed() {
-			var _this3 = this;
-			if (this.charmed) {
-				return 0;
-			}
-			this.charmed = true;
-			this.sprite.tint = 0xFFAAFF;
-			this.sprite.alpha = 0.8;
-			setTimeout(function () {
-				var index = birds.indexOf(_this3);
-				if (index > -1) {
-					birds.splice(index, 1);
-				}
-			}, 3000);
-			return GAME_CONFIG.catCharmPower;
+		birds.push(bird1);
+	}, 2000);
+}
+function spawnBird2() {
+	var bird = new Bird2();
+	bird.y = Math.random() * (2732 / 2); // Random initial y position in the top half
+	bird.x = Math.random() < 0.5 ? 0 : 2048; // Start from either the left or right side
+	bird.speed = 1 + Math.random() * 0.6;
+	bird.lastIntersecting = false;
+	bird.type = 'bird2'; // Specific property for Bird2
+	bird.color = 0xFFFFFF; // Specific color for Bird2
+	LK.setTimeout(function () {
+		game.addChild(bird);
+		// Ensure bird is added to the game before setting its index
+		if (game.children.includes(bird)) {
+			game.setChildIndex(bird, game.getChildIndex(stack1) + 1); // Set Bird2 to be rendered after stack1
 		}
-	}]);
-}();
-var Background = /*#__PURE__*/function () {
-	function Background(x, y) {
-		_classCallCheck(this, Background);
-		this.sprite = LK.getAsset('background', {
-			anchorX: 0.5,
-			anchorY: 0.5
+		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 + 600; // Move the tree 500px to the right
+tree.y = 2500; // Position the tree on the grass
+// Ensure tree is added to the game before setting its index
+if (game.children.includes(tree) && game.children.includes(bird1)) {
+	game.setChildIndex(tree, game.getChildIndex(bird1) + 1); // Set tree to be rendered after bird1
+}
+var score = 0;
+// Add stack1 image to the game
+var stack1 = game.addChild(new Stack1());
+stack1.x = 1650; // Move 500px to the right
+stack1.y = 2300; // Move down by 800px
+// Ensure stack1 is added to the game before setting its index
+if (game.children.includes(stack1) && game.children.includes(tree)) {
+	game.setChildIndex(stack1, game.getChildIndex(tree) + 1); // Set stack1 to be rendered after tree
+}
+// Add the grass floor to the game
+var grassBack = new GrassBack();
+grassBack.x = 1020;
+grassBack.y = 2735; // Position grassBack at the bottom
+game.addChild(grassBack);
+// Ensure grassBack is added to the game before setting its index
+if (game.children.includes(grassBack)) {
+	game.setChildIndex(grassBack, 5); // Set grassBack to be rendered after Bird3
+}
+var grassFront = new GrassFront();
+grassFront.x = 1020;
+grassFront.y = 2785; // Position grassFront at the bottom, moved down by 50px
+game.addChild(grassFront);
+// Ensure grassFront is added to the game before setting its index
+if (game.children.includes(grassFront) && game.children.includes(bird2)) {
+	game.setChildIndex(grassFront, game.getChildIndex(bird2) + 1); // Set grassFront to be rendered after bird2
+}
+var mirror = new Mirror();
+mirror.x = 2048 / 2 + 400; // Move the score display 400px to the right
+mirror.y = 2732 - 185 - 80 - 390; // Move the score display up by an additional 80px
+game.addChild(mirror);
+// Ensure mirror is added to the game before setting its index
+if (game.children.includes(mirror) && game.children.includes(stack1)) {
+	game.setChildIndex(mirror, game.getChildIndex(stack1) + 1); // Set mirror to be rendered after stack1
+}
+// Ensure laser is added to the game before setting mirror's index
+if (game.children.includes(laser) && game.children.includes(mirror)) {
+	game.setChildIndex(mirror, game.getChildIndex(laser) + 1); // Set mirror to be rendered after the laser
+}
+// 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
 		});
-		this.sprite.x = x;
-		this.sprite.y = y;
+	}, Math.random() * 30000 + 50000);
+}
+;
+// Add the cat to the game
+var cat = game.addChild(new Cat());
+cat.x = 230; // Move the cat 20px to the left
+cat.y = 2732; // Position the cat at the bottom of the screen
+// Ensure cat is added to the game before setting its index
+if (game.children.includes(cat)) {
+	game.setChildIndex(cat, game.children.length - 1); // Bring the cat to the front by setting its index to the highest value
+}
+// 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
 	}
-	return _createClass(Background);
-}();
-var ScoreImage = /*#__PURE__*/function () {
-	function ScoreImage(x, y) {
-		_classCallCheck(this, ScoreImage);
-		this.sprite = LK.getAsset('scoreImage', {
-			anchorX: 0.5,
-			anchorY: 0.5
-		});
-		this.sprite.x = x;
-		this.sprite.y = y;
-	}
-	return _createClass(ScoreImage);
-}();
-var Tree2 = /*#__PURE__*/function () {
-	function Tree2(x, y) {
-		_classCallCheck(this, Tree2);
-		this.sprite = LK.getAsset('tree2', {
-			anchorX: 0.5,
-			anchorY: 1
-		});
-		this.sprite.x = x;
-		this.sprite.y = y;
-	}
-	return _createClass(Tree2);
-}();
-var UFO2 = /*#__PURE__*/function () {
-	function UFO2(x, y) {
-		_classCallCheck(this, UFO2);
-		this.sprite = LK.getAsset('ufo2', {
-			anchorX: 0.5,
-			anchorY: 0.5
-		});
-		this.sprite.x = x;
-		this.sprite.y = y;
-	}
-	return _createClass(UFO2);
-}();
-var Mirror1 = /*#__PURE__*/function () {
-	function Mirror1(x, y) {
-		_classCallCheck(this, Mirror1);
-		this.sprite = LK.getAsset('mirror1', {
-			anchorX: 0.5,
-			anchorY: 0.5
-		});
-		this.sprite.x = x;
-		this.sprite.y = y;
-	}
-	return _createClass(Mirror1);
-}();
-var Reticle1 = /*#__PURE__*/function () {
-	function Reticle1(x, y) {
-		_classCallCheck(this, Reticle1);
-		this.sprite = LK.getAsset('reticle1', {
-			anchorX: 0.5,
-			anchorY: 0.5
-		});
-		this.sprite.x = x;
-		this.sprite.y = y;
-	}
-	return _createClass(Reticle1);
-}();
-var Stack1 = /*#__PURE__*/function () {
-	function Stack1(x, y) {
-		_classCallCheck(this, Stack1);
-		this.sprite = LK.getAsset('stack1', {
-			anchorX: 0.5,
-			anchorY: 0.5
-		});
-		this.sprite.x = x;
-		this.sprite.y = y;
-	}
-	return _createClass(Stack1);
-}();
-var Background = /*#__PURE__*/function () {
-	function Background(x, y) {
-		_classCallCheck(this, Background);
-		this.sprite = LK.getAsset('background', {
-			anchorX: 0.5,
-			anchorY: 0.5
-		});
-		this.sprite.x = x;
-		this.sprite.y = y;
-	}
-	return _createClass(Background);
-}();
-var ScoreImage = /*#__PURE__*/function () {
-	function ScoreImage(x, y) {
-		_classCallCheck(this, ScoreImage);
-		this.sprite = LK.getAsset('scoreImage', {
-			anchorX: 0.5,
-			anchorY: 0.5
-		});
-		this.sprite.x = x;
-		this.sprite.y = y;
-	}
-	return _createClass(ScoreImage);
-}();
-var Tree2 = /*#__PURE__*/function () {
-	function Tree2(x, y) {
-		_classCallCheck(this, Tree2);
-		this.sprite = LK.getAsset('tree2', {
-			anchorX: 0.5,
-			anchorY: 1
-		});
-		this.sprite.x = x;
-		this.sprite.y = y;
-	}
-	return _createClass(Tree2);
-}();
-var UFO2 = /*#__PURE__*/function () {
-	function UFO2(x, y) {
-		_classCallCheck(this, UFO2);
-		this.sprite = LK.getAsset('ufo2', {
-			anchorX: 0.5,
-			anchorY: 0.5
-		});
-		this.sprite.x = x;
-		this.sprite.y = y;
-	}
-	return _createClass(UFO2);
-}();
-var Mirror1 = /*#__PURE__*/function () {
-	function Mirror1(x, y) {
-		_classCallCheck(this, Mirror1);
-		this.sprite = LK.getAsset('mirror1', {
-			anchorX: 0.5,
-			anchorY: 0.5
-		});
-		this.sprite.x = x;
-		this.sprite.y = y;
-	}
-	return _createClass(Mirror1);
-}();
-var Reticle1 = /*#__PURE__*/function () {
-	function Reticle1(x, y) {
-		_classCallCheck(this, Reticle1);
-		this.sprite = LK.getAsset('reticle1', {
-			anchorX: 0.5,
-			anchorY: 0.5
-		});
-		this.sprite.x = x;
-		this.sprite.y = y;
-	}
-	return _createClass(Reticle1);
-}();
-var Stack1 = /*#__PURE__*/function () {
-	function Stack1(x, y) {
-		_classCallCheck(this, Stack1);
-		this.sprite = LK.getAsset('stack1', {
-			anchorX: 0.5,
-			anchorY: 0.5
-		});
-		this.sprite.x = x;
-		this.sprite.y = y;
-	}
-	return _createClass(Stack1);
-}();
\ No newline at end of file
+});
+// 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);
+});
\ No newline at end of file