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

/**** 
* Classes
****/ 
var Background = Container.expand(function () {
	var self = Container.call(this);
	var backgroundGraphics = self.attachAsset('background', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.addChild(backgroundGraphics);
	game.layerManager.addToLayer(self, LAYERS.BACKGROUND);
});
var Bird1 = Container.expand(function () {
	var self = Container.call(this);
	var birdGraphics = self.attachAsset('bird1', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.movement = new Bird1Movement(self, birdGraphics);
	game.layerManager.addToLayer(self, LAYERS.BIRD1);
});
var Bird2 = Container.expand(function () {
	var self = Container.call(this);
	var birdGraphics = self.attachAsset('bird2', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.movement = new Bird2Movement(self, birdGraphics);
	game.layerManager.addToLayer(self, LAYERS.BIRD2);
});
var Cat = Container.expand(function () {
	var self = Container.call(this);
	var catGraphics = self.attachAsset('cat', {
		anchorX: 0.5,
		anchorY: 1
	});
	self.update = function () {};
	game.layerManager.addToLayer(self, LAYERS.CAT);
});
var Cloud = Container.expand(function () {
	var self = Container.call(this);
	var cloudType = CLOUD_TYPES[Math.floor(Math.random() * CLOUD_TYPES.length)];
	var cloudGraphics = self.attachAsset(cloudType, {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0.8
	});
	var layerIndex = cloudType === 'cloud1' ? LAYERS.CLOUD1 : LAYERS.CLOUD2;
	game.layerManager.addToLayer(self, layerIndex);
	self.movement = new CloudMovement(self, cloudGraphics);
	if (typeof self.movement.update !== 'function') {
		self.movement.update = function () {
			// Default update logic if not defined
		};
	}
	self.update = function () {
		self.movement.update();
	};
	return self;
});
// 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 () {
		self.x += Math.sin((LK.ticks + 100) / 90) * 0.15; // Swaying effect, increased speed
	};
	self.addChild(grassGraphics); // Add grass graphics to the container
	// Set the layer index for grass-back
	game.layerManager.addToLayer(self, LAYERS.GRASS_BACK);
});
// 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 () {
		self.x += Math.sin((LK.ticks + 50) / 100) * 0.125; // Swaying effect, reduced by 50%
		self.lastX = self.x; // Update lastX after movement
	};
	// Set the layer index for grass-front
	game.layerManager.addToLayer(self, LAYERS.GRASS_FRONT);
});
var Jet1 = Container.expand(function () {
	var self = Container.call(this);
	var jetGraphics = self.attachAsset('jet1', {
		anchorX: 0.5,
		anchorY: 0.5,
		flipX: 1
	});
	game.layerManager.addToLayer(self, LAYERS.JET1);
	self.speed = 10;
	self.direction = Math.random() < 0.5 ? 1 : -1;
	self.lastX = self.x;
	self.soundPlayed = false;
	self.x = Math.random() < 0.5 ? 2048 + self.width / 2 : -self.width / 2;
	self.update = function () {
		flipImageVerticallyBasedOnDirection(jetGraphics, self.lastX, self.x);
		self.x += self.speed * self.direction;
		if (!self.soundPlayed && self.x > 0 && self.x < 2048) {
			LK.getSound('jet1').play();
			self.soundPlayed = true;
		}
		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;
			var respawnTime = Math.random() * 10000 + 10000;
			game.jetSpawnTimer = LK.setTimeout(function () {
				var jet = new Jet1();
				jet.x = Math.random() < 0.5 ? 2048 + jet.width / 2 : -jet.width / 2;
				jet.y = Math.random() * (2732 / 2);
				game.addChild(jet);
				game.jet = jet;
				game.jetSpawnTimer = null;
			}, respawnTime);
		}
		self.lastX = self.x;
	};
});
// 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;
	self.update = function () {
		game.children.forEach(function (child) {
			if ((child instanceof Bird1 || child instanceof Bird2) && self.intersects(child)) {
				child.destroy();
				self.destroy();
			}
		});
		self.x += self.vx;
		self.y += self.vy;
		if (self.x < 0 || self.x > 2048 || self.y < 0 || self.y > 2732) {
			self.destroy();
		}
	};
	// Set the layer index for laser
	game.layerManager.addToLayer(self, LAYERS.LASER);
});
// 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: 1.0
	});
	self.x = 450;
	self.y = 450;
	self.update = function () {
		self.x += Math.sin(LK.ticks / 90) * 0.1;
	};
	self.pulse = new Light1Pulse(lightGraphics);
	self.pulse.startPulsating();
	game.layerManager.addToLayer(self, LAYERS.LIGHT1);
});
var Mirror = Container.expand(function () {
	var self = Container.call(this);
	var scoreGraphics = self.attachAsset('mirror1', {
		anchorX: 0.5,
		anchorY: 0.5,
		rotation: Math.PI / 60
	});
	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 = 160; // Move score text down by 110px
	scoreText.x = -155; // Move score text left by 10px
	scoreText.rotation = -85 * (Math.PI / 180);
	x = 100;
	y = 100;
	self.addChild(scoreText);
	self.updateScore = function (newScore) {
		scoreText.setText(newScore);
	};
});
// Mirror1 class to represent the mirror image
var Mirror1 = Container.expand(function () {
	var self = Container.call(this);
	var mirror1Graphics = self.attachAsset('mirror1', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.addChild(mirror1Graphics);
	// Set the layer index for mirror
	game.layerManager.addToLayer(self, LAYERS.MIRROR);
});
var Reticle = Container.expand(function () {
	var self = Container.call(this);
	var reticleGraphics = self.attachAsset('reticle1', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.update = function () {
		if (!self.pulse) {
			self.pulse = new ReticlePulse(reticleGraphics);
			self.pulse.startPulsating();
		}
	};
	game.layerManager.addToLayer(self, LAYERS.RETICLE);
});
// Reticle1 class to represent the reticle image
var Reticle1 = Container.expand(function () {
	var self = Container.call(this);
	var reticle1Graphics = self.attachAsset('reticle1', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.addChild(reticle1Graphics);
	// Set the layer index for reticle
	game.layerManager.addToLayer(self, LAYERS.RETICLE);
});
// 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
	};
	// Set the layer index for stack
	game.layerManager.addToLayer(self, LAYERS.STACK);
});
// 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();
	// Set the layer index for sun
	game.layerManager.addToLayer(self, LAYERS.SUN);
});
// 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('tree1', {
		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
	};
	// Set the layer index for tree
	game.layerManager.addToLayer(self, LAYERS.TREE);
});
// Tree2 class to represent the second type of tree
var Tree2 = Container.expand(function () {
	var self = Container.call(this);
	var tree2Graphics = self.attachAsset('tree2', {
		anchorX: 0.5,
		anchorY: 1
	});
	self.addChild(tree2Graphics);
	// Set the layer index for tree2
	game.layerManager.addToLayer(self, LAYERS.TREE);
});
var UFO = Container.expand(function () {
	var self = Container.call(this);
	var ufoGraphics = self.attachAsset('ufo2', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.movement = new UFOMovement(self, ufoGraphics);
	game.layerManager.addToLayer(self, LAYERS.UFO2);
});
// UFO1 class to represent a specific type of UFO
var UFO1 = Container.expand(function () {
	var self = Container.call(this);
	var ufo1Graphics = self.attachAsset('ufo1', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.movement = new UFOMovement(self, ufo1Graphics);
	// Set the layer index for ufo1
	game.layerManager.addToLayer(self, LAYERS.UFO1);
});
// UFO2 class to represent the second type of UFO
var UFO2 = Container.expand(function () {
	var self = Container.call(this);
	var ufo2Graphics = self.attachAsset('ufo2', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.movement = new UFOMovement(self, ufo2Graphics);
	game.layerManager.addToLayer(self, LAYERS.UFO2);
});

/**** 
* Initialize Game
****/ 
// Initialize clouds array
var game = new LK.Game({
	// No title, no description
	backgroundColor: 0x87CEEB // Sky blue
});

/**** 
* Game Code
****/ 
// CloudMovement class to handle cloud movement and fade effects
var CloudMovement = function CloudMovement(cloud, cloudGraphics) {
	this.cloud = cloud;
	this.cloudGraphics = cloudGraphics;
	this.speed = Math.random() * 0.55 + 0.25;
	this.direction = Math.random() < 0.5 ? 1 : -1;
	this.update = function () {
		this.cloud.x += this.speed * this.direction;
		var screenWidth = 2048;
		var halfWidth = this.cloud.width / 2;
		if (this.cloud.x > screenWidth + halfWidth) {
			this.cloud.x = -halfWidth;
		} else if (this.cloud.x < -halfWidth) {
			this.cloud.x = screenWidth + halfWidth;
		}
	}.bind(this);
};
function _typeof(o) {
	"@babel/helpers - typeof";
	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
		return typeof o;
	} : function (o) {
		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
	}, _typeof(o);
}
function _classCallCheck(a, n) {
	if (!(a instanceof n)) {
		throw new TypeError("Cannot call a class as a function");
	}
}
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;
		}
		throw new TypeError("@@toPrimitive must return a primitive value.");
	}
	return ("string" === r ? String : Number)(t);
}
var CloudMovement = function CloudMovement(cloud, cloudGraphics) {
	this.cloud = cloud;
	this.cloudGraphics = cloudGraphics;
	this.cloud.speed = Math.random() * 0.55 + 0.25;
	this.cloud.hasAccelerated = false;
	this.cloud.direction = Math.random() < 0.5 ? 1 : -1;
	this.cloud.lastX = this.cloud.x;
	this.cloud.lastIntersecting = false;
	this.cloud.update = function () {
		var currentX = this.x;
		var screenWidth = 2048;
		var halfWidth = this.width / 2;
		this.x += this.speed * this.direction;
		if (currentX <= screenWidth + halfWidth && this.x > screenWidth + halfWidth) {
			this.x = -halfWidth;
		} else if (currentX >= -halfWidth && this.x < -halfWidth) {
			this.x = screenWidth + halfWidth;
		}
		this.lastX = this.x;
	}.bind(this.cloud);
};
/**** 
* Layer Constants
****/ 
var LAYERS = {
	BACKGROUND: 0,
	GRASS_BACK: 1,
	TREE: 2,
	CLOUD1: 3,
	CLOUD2: 4,
	JET1: 5,
	UFO1: 6,
	UFO2: 7,
	BIRD1: 8,
	BIRD2: 9,
	LASER: 10,
	CAT: 11,
	RETICLE: 12,
	STACK: 13,
	MIRROR: 14,
	GRASS_FRONT: 15,
	SUN: 16,
	LIGHT1: 17
};
/**** 
* Layer Management System
****/ 
var LayerManager = /*#__PURE__*/function () {
	function LayerManager(gameInstance) {
		_classCallCheck(this, LayerManager);
		this.game = gameInstance;
		this.layerMap = {};
	}
	return _createClass(LayerManager, [{
		key: "setLayerIndex",
		value: function setLayerIndex(object, layerId) {
			if (!object || !this.game.children.includes(object)) {
				return;
			}
			// Ensure the layer ID is valid and within bounds
			layerId = Math.max(0, Math.min(layerId, this.game.children.length));
			// Set the child index
			if (layerId < this.game.children.length) {
				this.game.setChildIndex(object, layerId);
			}
			// Update the layer map
			this.layerMap[object.id] = layerId;
		}
	}, {
		key: "getObjectsInLayer",
		value: function getObjectsInLayer(layerId) {
			var objects = [];
			for (var id in this.layerMap) {
				if (this.layerMap[id] === layerId) {
					// Find the object in the game's children
					for (var i = 0; i < this.game.children.length; i++) {
						var child = this.game.children[i];
						if (child.id === id) {
							objects.push(child);
							break;
						}
					}
				}
			}
			return objects;
		}
		/** 
		* Add an object to a specific layer
		* @param {Object} object - The game object to add
		* @param {Number} layerId - The layer ID
		*/ 
	}, {
		key: "addToLayer",
		value: function addToLayer(object, layerId) {
			if (!object || !object.id) {
				return;
			}
			// Ensure the layer ID is valid and within bounds
			layerId = Math.max(0, Math.min(layerId, this.game.children.length));
			// Add the object if it's not already a child
			if (!this.game.children.includes(object)) {
				this.game.addChild(object);
			}
			// Set the child index only if it's within bounds
			if (layerId < this.game.children.length) {
				this.game.setChildIndex(object, layerId);
			}
			// Update the layer map
			this.layerMap[object.id] = layerId;
		}
		/** 
		* Get the layer of an object
		* @param {Object} object - The game object
		* @return {Number} The layer ID or -1 if not found
		*/ 
	}, {
		key: "getObjectLayer",
		value: function getObjectLayer(object) {
			if (!object || !object.id) {
				return -1;
			}
			return this.layerMap[object.id] !== undefined ? this.layerMap[object.id] : -1;
		}
		/** 
		* Remove an object from layer tracking
		* @param {Object} object - The game object to remove
		*/ 
	}, {
		key: "removeFromTracking",
		value: function removeFromTracking(object) {
			if (!object || !object.id) {
				return;
			}
			delete this.layerMap[object.id];
		}
		/** 
		* Bring an object to the front of its layer
		* @param {Object} object - The game object
		*/ 
	}, {
		key: "bringToFrontOfLayer",
		value: function bringToFrontOfLayer(object) {
			if (!object || !object.id) {
				return;
			}
			var layerId = this.getObjectLayer(object);
			if (layerId === -1) {
				return;
			}
			// Find the highest index within this layer
			var highestIndex = layerId;
			for (var id in this.layerMap) {
				if (this.layerMap[id] === layerId) {
					// Find the object in the game's children
					for (var i = 0; i < this.game.children.length; i++) {
						var child = this.game.children[i];
						if (child.id === id && i > highestIndex) {
							highestIndex = i;
						}
					}
				}
			}
			// Set the object to the highest index within its layer
			this.game.setChildIndex(object, highestIndex);
		}
		/** 
		* Send an object to the back of its layer
		* @param {Object} object - The game object
		*/ 
	}, {
		key: "sendToBackOfLayer",
		value: function sendToBackOfLayer(object) {
			if (!object || !object.id) {
				return;
			}
			var layerId = this.getObjectLayer(object);
			if (layerId === -1) {
				return;
			}
			// Find the lowest index within this layer
			var lowestIndex = layerId;
			for (var id in this.layerMap) {
				if (this.layerMap[id] === layerId) {
					// Find the object in the game's children
					for (var i = 0; i < this.game.children.length; i++) {
						var child = this.game.children[i];
						if (child.id === id && i < lowestIndex) {
							lowestIndex = i;
						}
					}
				}
			}
			// Set the object to the lowest index within its layer
			this.game.setChildIndex(object, lowestIndex);
		}
		/** 
		* Helper function to add multiple objects to a layer at once
		* @param {Array} objects - Array of game objects
		* @param {Number} layerId - The layer ID
		*/ 
	}, {
		key: "addMultipleToLayer",
		value: function addMultipleToLayer(objects, layerId) {
			var _this2 = this;
			if (!Array.isArray(objects)) {
				return;
			}
			objects.forEach(function (object) {
				return _this2.addToLayer(object, layerId);
			});
		}
	}]);
}();
game.layerManager = new LayerManager(game);
// Using UFO sound ID as placeholder
function flipImageVerticallyBasedOnDirection(graphics, lastX, currentX) {
	if (graphics) {
		if (lastX < currentX && graphics.scaleX < 0) {
			graphics.scaleX *= -1; // Flip horizontally to face right
		} else if (lastX > currentX && graphics.scaleX > 0) {
			graphics.scaleX *= -1; // Flip horizontally to face left
		}
	}
}
function flipImageBasedOnDirection(graphics, lastX, currentX) {
	if (graphics) {
		if (lastX < currentX) {
			graphics.scaleY = Math.abs(graphics.scaleY); // Face right when moving right by ensuring scaleY is positive
		} else if (lastX > currentX) {
			graphics.scaleY = -Math.abs(graphics.scaleY); // Face left when moving left by ensuring scaleY is negative
		}
	}
}
// SunPulse class to handle the pulsating effect for Sun
function AABBIntersect(obj1, obj2) {
	if (obj1 && obj2) {
		return obj1.x < obj2.x + obj2.width && obj1.x + obj1.width > obj2.x && obj1.y < obj2.y + obj2.height && obj1.y + obj1.height > obj2.y;
	}
	return false;
}
var CLOUD_TYPES = ['cloud1', 'cloud2'];
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)
			});
		}
		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: 1000,
				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)
			});
		}
		pulsate.call(this);
	};
};
var bird2; // Define bird2 variable in the global scope
function startPulsating(target) {
	var duration = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 888;
	function pulsate() {
		tween(target, {
			scaleX: 1.2,
			scaleY: 1.2
		}, {
			duration: duration,
			easing: tween.easeInOut,
			onFinish: function onFinish() {
				tween(target, {
					scaleX: 1.0,
					scaleY: 1.0
				}, {
					duration: duration,
					easing: tween.easeInOut,
					onFinish: pulsate
				});
			}
		});
	}
	pulsate();
}
// UFOMovement class to handle UFO movement
var UFOMovement = function UFOMovement(ufo, ufoGraphics) {
	this.ufo = ufo;
	this.ufoGraphics = ufoGraphics;
	this.ufo.speed = 3.2;
	this.ufo.direction = Math.random() < 0.5 ? 1 : -1;
	this.ufo.lastX = this.ufo.x;
	this.ufo.soundPlayed = false;
	this.ufo.update = function () {
		var currentX = this.x;
		var screenWidth = 2048;
		var halfWidth = this.width / 2;
		var tickCos = Math.cos(LK.ticks / 60);
		var tickSin = Math.sin(LK.ticks / 120);
		this.x += this.speed * tickCos;
		this.y = 100 + tickSin * 250;
		if (this.x > 0 && this.x < screenWidth && !this.soundPlayed) {
			LK.getSound('ufo1').play();
			this.soundPlayed = true;
		}
		if (this.x < 0 || this.x > screenWidth) {
			this.soundPlayed = false;
		}
		if (currentX <= screenWidth + halfWidth && this.x > screenWidth + halfWidth || currentX >= -halfWidth && this.x < -halfWidth) {
			LK.getSound('ufo1').stop();
			this.destroy();
			ufo = null;
		}
		this.lastX = this.x;
	};
};
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
		});
	};
};
// 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() * 3.2 + 2;
	this.bird.lastY = storage.bird1_lastY || this.bird.y;
	this.bird.lastX = storage.bird1_lastX || this.bird.x;
	this.bird.update = function () {
		// Cache all frequently used values
		var currentX = this.x;
		var currentY = this.y;
		var screenWidth = 2048;
		var screenHeight = 2732;
		var tickCos = Math.cos(LK.ticks / 50);
		// Update position with optimized calculations
		this.x += this.speed * tickCos;
		this.y += Math.sin(this.x / 100) * 6.5;
		// Handle screen boundaries with optimized random positioning
		if (currentY > screenHeight + this.height) {
			this.y = -this.height;
			var rand = Math.random();
			this.x = rand < 0.33 ? rand * screenWidth : rand < 0.5 ? 0 : screenWidth;
		}
		// Update rotation with cached movement values
		this.rotation = Math.atan2(this.y - currentY, this.x - currentX) * 0.1;
		// Optimize cloud intersection check
		var isIntersectingCloud = false;
		for (var i = 0; i < clouds.length; i++) {
			if (this.intersects(clouds[i])) {
				isIntersectingCloud = true;
				break;
			}
		}
		// Handle cloud intersection effects
		if (isIntersectingCloud && !this.lastIntersecting) {
			this.speed *= 0.8;
			LK.getSound('wings1').play();
		}
		this.lastIntersecting = isIntersectingCloud;
		// Update position tracking with throttled storage updates
		if (Math.abs(this.lastX - currentX) > 1 || Math.abs(this.lastY - currentY) > 1) {
			this.lastX = currentX;
			this.lastY = currentY;
			storage.bird1_lastX = currentX;
			storage.bird1_lastY = currentY;
		}
		// Handle image flipping
		flipImageVerticallyBasedOnDirection(birdGraphics, currentX, this.x);
	};
};
var Bird2Movement = function Bird2Movement(bird, birdGraphics) {
	this.bird = bird;
	this.birdGraphics = birdGraphics;
	this.bird.speed = Math.random() * 1.6 + 1;
	this.bird.lastY = storage.bird2_lastY || this.bird.y; // Initialize lastY for tracking changes on Y
	this.bird.lastX = storage.bird2_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%
		flipImageVerticallyBasedOnDirection(birdGraphics, this.lastX, this.x); // Use flipImageVerticallyBasedOnDirection to flip on X axis
		// Check if the bird has moved off-screen
		if (this.lastY <= 2732 && this.y > 2732) {
			this.y = Math.random() * 2732; // Random initial y position within the screen height
			this.x = Math.random() < 0.5 ? 0 : 2048; // Start from either the left or right side
		}
		this.lastX = this.x; // Track position for next update
		this.lastY = this.y; // Update lastY after movement
		storage.bird2_lastX = this.lastX; // Store lastX using storage plugin
		storage.bird2_lastY = this.lastY; // Store lastY using storage plugin
	};
};
var Bird2Effects = function Bird2Effects(bird) {
	this.bird = bird;
	this.applyEffects = function () {};
};
var ReticlePulse = function ReticlePulse(reticleGraphics) {
	this.reticleGraphics = reticleGraphics;
	this.startPulsating = function () {
		function pulsate() {
			tween(this.reticleGraphics, {
				scaleX: 1.2,
				scaleY: 1.2
			}, {
				duration: 1000,
				easing: tween.easeInOut,
				onFinish: function () {
					tween(this.reticleGraphics, {
						scaleX: 1.0,
						scaleY: 1.0
					}, {
						duration: 1000,
						easing: tween.easeInOut,
						onFinish: pulsate.bind(this)
					});
				}.bind(this)
			});
		}
		pulsate.call(this);
	};
};
// 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
	};
};
// Add background to the BACKGROUND layer
var background = new Background();
background.x = 2048 / 2;
background.y = 2732 / 2 - 140;
game.addChild(background);
game.layerManager.addToLayer(background, LAYERS.BACKGROUND);
// ScoreManager class to manage score logic
var ScoreManager = function ScoreManager() {
	var self = this;
	var currentScore = 0;
	var highScore = storage.highScore || 0;
	self.addScore = function (points) {
		if (typeof points !== 'number' || points < 0) {
			return currentScore;
		}
		currentScore += Math.floor(points);
		if (currentScore > highScore) {
			highScore = currentScore;
			storage.highScore = highScore;
		}
		return currentScore;
	};
	self.resetScore = function () {
		currentScore = 0;
		return currentScore;
	};
	self.getScore = function () {
		return currentScore;
	};
	self.getHighScore = function () {
		return highScore;
	};
};
var birds = [];
game.down = function (x, y, obj) {
	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
		}
	}
	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
	}
};
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 = new Sun();
sun.x = 480;
sun.y = 680;
game.layerManager.addToLayer(sun, LAYERS.SUN);
var light1 = new Light1();
light1.x = 510;
light1.y = 1500;
game.layerManager.addToLayer(light1, LAYERS.LIGHT1);
light1.visible = true;
// Function to add a UFO to the game
function addUFO() {
	var ufo = new UFO1();
	game.addChild(ufo);
	if (game.children.includes(ufo) && game.children.includes(clouds[0])) {
		game.setChildIndex(ufo, game.getChildIndex(clouds[0]) + 1);
	}
	ufo.x = Math.random() < 0.5 ? 2048 + ufo.width / 2 : -ufo.width / 2;
	ufo.y = Math.random() * (2732 / 2 - ufo.height);
	ufo.customUpdate = function () {
		if (!ufo.soundPlayed && ufo.x > 0 && ufo.x < 2048) {
			LK.getSound('ufo1').play();
			ufo.soundPlayed = true;
		}
		ufo.update();
	};
	return ufo;
}
// Initialize clouds array
var clouds = [];
// Initialize cloud types
var CLOUD_TYPES = ['cloud1', 'cloud2'];
// Add initial clouds
function initializeClouds() {
	// Add cloud1 instances
	for (var i = 0; i < 3; i++) {
		var cloud = new Cloud();
		cloud.x = Math.random() * 2048;
		cloud.y = Math.random() * (2732 / 2); // Position clouds in the upper half of the screen
		game.addChild(cloud);
		game.layerManager.addToLayer(cloud, LAYERS.CLOUD1);
		clouds.push(cloud);
	}
	// Add cloud2 instances
	for (var i = 0; i < 3; i++) {
		var cloud = new Cloud();
		cloud.x = Math.random() * 2048;
		cloud.y = Math.random() * (2732 / 2); // Position clouds in the upper half of the screen
		game.addChild(cloud);
		game.layerManager.addToLayer(cloud, LAYERS.CLOUD2);
		clouds.push(cloud);
	}
}
// Call initializeClouds after game initialization
initializeClouds();
var bird1; // Define bird1 variable in the global scope
var bird; // Define bird variable in the global scope
// Initialize birds
var birds = [];
spawnBird1();
spawnBird2();
// Initialize a timer to add a UFO at a random time between 10 and 20 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 () {
	if (!game.children.some(function (c) {
		return c instanceof UFO1;
	})) {
		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
var originalUpdate = game.update;
game.update = function () {
	// Call the original update function first
	originalUpdate.call(this);
	// Update clouds
	for (var i = 0; i < clouds.length; i++) {
		clouds[i].update();
	}
	// 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
		}
	});
	// Update UFO and check for collisions
	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 && AABBIntersect(child, 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 && AABBIntersect(child, ufo)) {
					score += 25;
					scoreDisplay.updateScore(score);
					child.destroy();
				}
				child.lastIntersecting = birds.some(function (bird) {
					return child.intersects(bird);
				}) || ufo && child.intersects(ufo);
			}
		});
	} else {
		// If there's no UFO, try to spawn one
		ufo = addUFO();
	}
};
// Function to spawn a third kind of bird
function spawnBird1() {
	if (!birds.some(function (b) {
		return b instanceof Bird1;
	})) {
		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
				}
			}
			birds.push(bird1);
		}, 2000);
	}
}
function spawnBird2() {
	if (birds.filter(function (b) {
		return b instanceof Bird2;
	}).length < 3) {
		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
			}
			birds.push(bird);
		}, 2000);
	}
}
// Update the main game update function to include bird updates
var originalUpdate = game.update;
game.update = function () {
	// Call the original update function first
	originalUpdate.call(this);
	// 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
		}
	});
	// Update UFO and check for collisions
	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 && AABBIntersect(child, 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 && AABBIntersect(child, ufo)) {
					score += 25;
					scoreDisplay.updateScore(score);
					child.destroy();
				}
				child.lastIntersecting = birds.some(function (bird) {
					return child.intersects(bird);
				}) || ufo && child.intersects(ufo);
			}
		});
	}
};
// 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 = 1700; // Move 700px to the right
stack1.y = 2250; // 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)) {
	// Make sure we don't set an index that's out of bounds
	var safeIndex = Math.min(5, game.children.length - 1);
	game.setChildIndex(grassBack, safeIndex); // Set grassBack to be rendered safely
}
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 scoreDisplay = new Mirror();
scoreDisplay.x = 2048 / 2 + 400; // Move the score display 400px to the right
scoreDisplay.y = 2732 - 185 - 80 - 390 + 30; // Move the score display up by an additional 80px and down by 30px
game.addChild(scoreDisplay);
var mirror = new Mirror();
mirror.x = 2048 / 2 + 400; // Move the mirror 400px to the right
mirror.y = 2732 - 185 - 80 - 390 + 30; // Move the mirror up by an additional 80px and down by 30px
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
		});
	}, 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
	}
});
// 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;
// Sound volumes configuration
// 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);
});
// Using UFO sound ID as placeholder
var CLOUD_TYPES = ['cloud1', 'cloud2'];
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)
			});
		}
		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: 1000,
				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)
			});
		}
		pulsate.call(this);
	};
};
var bird2; // Define bird2 variable in the global scope
// 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 () {
		var _this5 = this;
		// Cache current position and dimensions
		var currentX = this.x;
		var screenWidth = 2048;
		var halfWidth = this.width / 2;
		// Update position based on pattern
		this.x += this.speed * Math.cos(LK.ticks / 60);
		this.y = 100 + Math.sin(LK.ticks / 120) * 250;
		// Optimize movement pattern
		var distanceFromCenter = Math.abs(this.x - screenWidth / 2);
		if (distanceFromCenter > screenWidth / 3) {
			this.speed *= -0.95; // Smooth direction change
		}
		// Cache intersection checks
		var isIntersectingCloud = clouds.some(function (cloud) {
			return _this5.intersects(cloud);
		});
		if (isIntersectingCloud && !this.lastIntersecting) {
			this.speed *= 1.2;
			LK.getSound('ufo1').play();
		}
		this.lastIntersecting = isIntersectingCloud;
		// Stop playing ufo1 sound after UFO leaves the screen
		if (this.lastX <= screenWidth + halfWidth && this.x > screenWidth + halfWidth || this.lastX >= -halfWidth && this.x < -halfWidth) {
			this.destroy();
			ufo = null;
			LK.getSound('ufo1').stop();
		}
		this.lastX = this.x; // Update lastX after movement
	};
};
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
		});
	};
};
// 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 = 1 + Math.random() * 1.2;
	this.bird.lastY = this.bird.y;
	this.bird.lastX = this.bird.x;
	this.bird.update = function () {
		this.y += this.speed;
		this.x += Math.sin((LK.ticks + 50) / 50) * 0.25;
		this.lastY = this.y;
		this.lastX = this.x;
	}.bind(this.bird);
};
var Bird2Movement = function Bird2Movement(bird, birdGraphics) {
	this.bird = bird;
	this.birdGraphics = birdGraphics;
	this.bird.speed = Math.random() * 1.6 + 1;
	this.bird.lastY = storage.bird2_lastY || this.bird.y; // Initialize lastY for tracking changes on Y
	this.bird.lastX = storage.bird2_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%
		flipImageVerticallyBasedOnDirection(birdGraphics, this.lastX, this.x); // Use flipImageVerticallyBasedOnDirection to flip on X axis
		// Check if the bird has moved off-screen
		if (this.lastY <= 2732 && this.y > 2732) {
			this.y = Math.random() * 2732; // Random initial y position within the screen height
			this.x = Math.random() < 0.5 ? 0 : 2048; // Start from either the left or right side
		}
		this.lastX = this.x; // Track position for next update
		this.lastY = this.y; // Update lastY after movement
		storage.bird2_lastX = this.lastX; // Store lastX using storage plugin
		storage.bird2_lastY = this.lastY; // Store lastY using storage plugin
	};
};
var Bird2Effects = function Bird2Effects(bird) {
	this.bird = bird;
	this.applyEffects = function () {};
};
var ReticlePulse = function ReticlePulse(reticleGraphics) {
	this.reticleGraphics = reticleGraphics;
	this.startPulsating = function () {
		function pulsate() {
			tween(this.reticleGraphics, {
				scaleX: 1.2,
				scaleY: 1.2
			}, {
				duration: 1000,
				easing: tween.easeInOut,
				onFinish: function () {
					tween(this.reticleGraphics, {
						scaleX: 1.0,
						scaleY: 1.0
					}, {
						duration: 1000,
						easing: tween.easeInOut,
						onFinish: pulsate.bind(this)
					});
				}.bind(this)
			});
		}
		pulsate.call(this);
	};
};
// 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
	};
};
// Add background to the BACKGROUND layer
var background = new Background();
background.x = 2048 / 2;
background.y = 2732 / 2 - 140;
game.layerManager.addToLayer(background, LAYERS.BACKGROUND);
// ScoreManager class to manage score logic
var ScoreManager = function ScoreManager() {
	var self = this;
	var currentScore = 0;
	var highScore = storage.highScore || 0;
	self.addScore = function (points) {
		if (typeof points !== 'number' || points < 0) {
			return currentScore;
		}
		currentScore += Math.floor(points);
		if (currentScore > highScore) {
			highScore = currentScore;
			storage.highScore = highScore;
		}
		return currentScore;
	};
	self.resetScore = function () {
		currentScore = 0;
		return currentScore;
	};
	self.getScore = function () {
		return currentScore;
	};
	self.getHighScore = function () {
		return highScore;
	};
};
var birds = [];
game.down = function (x, y, obj) {
	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
		}
	}
	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 = new Sun();
sun.x = 480;
sun.y = 680;
game.layerManager.addToLayer(sun, LAYERS.SUN);
var light1 = new Light1();
light1.x = 510;
light1.y = 1500;
game.layerManager.addToLayer(light1, LAYERS.LIGHT1);
light1.visible = true;
// Function to add a UFO to the game
// Initialize clouds array
var clouds = [];
// Initialize cloud types
var CLOUD_TYPES = ['cloud1', 'cloud2'];
// Add initial clouds
// Call initializeClouds after game initialization
initializeClouds();
var bird1; // Define bird1 variable in the global scope
var bird; // Define bird variable in the global scope
// Initialize birds
spawnBird2();
if (!bird1) {
	spawnBird1();
}
// 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 () {
	// Update clouds
	for (var i = 0; i < clouds.length; i++) {
		clouds[i].update();
	}
	// Add a jet to the game if it doesn't exist and no jet spawn timer is active
	if (!game.jet && !game.jetSpawnTimer) {
		var jet = new Jet1();
		jet.x = Math.random() < 0.5 ? 2048 + jet.width / 2 : -jet.width / 2;
		jet.y = Math.random() * (2732 / 2);
		game.addChild(jet);
		game.jet = jet;
		game.layerManager.addToLayer(jet, LAYERS.JET1);
		LK.getSound('jet1').play();
	}
	// Update jet
	if (game.jet) {
		game.jet.update();
	}
	if (ufo) {
		ufo.customUpdate();
		// Cache game children to avoid repeated property access
		var gameChildren = game.children;
		// Update lasers and check collisions
		gameChildren.forEach(function (child) {
			if (child instanceof Laser) {
				child.update();
				// Check for intersections with birds and UFO
				var hasIntersection = birds.some(function (bird) {
					if (!child.lastIntersecting && AABBIntersect(child, bird)) {
						score += bird instanceof Bird1 ? 5 : 1;
						scoreDisplay.updateScore(score);
						LK.getSound('dead1').play();
						bird.destroy();
						birds.splice(birds.indexOf(bird), 1);
						child.destroy();
						return true;
					}
					return child.intersects(bird);
				});
				if (!hasIntersection && ufo && !child.lastIntersecting && AABBIntersect(child, ufo)) {
					score += 25;
					scoreDisplay.updateScore(score);
					child.destroy();
				}
				child.lastIntersecting = hasIntersection || ufo && child.intersects(ufo);
			}
		});
		// Check for intersections between UFO and birds
		var ufoIntersection = birds.some(function (bird) {
			if (!ufo.lastIntersecting && ufo.intersects(bird)) {
				bird.destroy();
				birds.splice(birds.indexOf(bird), 1);
				LK.getSound('dead2').play();
				return true;
			}
			return ufo.intersects(bird);
		});
		ufo.lastIntersecting = ufoIntersection;
		// Check if UFO is out of bounds
		if (ufo.lastX <= 2048 + ufo.width / 2 && ufo.x > 2048 + ufo.width / 2 || ufo.lastX >= -ufo.width / 2 && ufo.x < -ufo.width / 2) {
			ufo.destroy();
			ufo = null;
			ufoTimer = LK.setTimeout(function () {
				ufo = addUFO();
			}, Math.random() * 20000 + 30000);
		}
		ufo.lastX = ufo.x;
	}
};
// Function to spawn a third kind of bird
// Update the main game update function to include bird updates
var originalUpdate = game.update;
game.update = function () {
	// Call the original update function first
	originalUpdate.call(this);
	// 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
		}
	});
	// Update UFO and check for collisions
	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 && AABBIntersect(child, 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 && AABBIntersect(child, ufo)) {
					score += 25;
					scoreDisplay.updateScore(score);
					child.destroy();
				}
				child.lastIntersecting = birds.some(function (bird) {
					return child.intersects(bird);
				}) || ufo && child.intersects(ufo);
			}
		});
	}
};
// 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 = 1700; // Move 700px to the right
stack1.y = 2250; // 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)) {
	// Make sure we don't set an index that's out of bounds
	var safeIndex = Math.min(5, game.children.length - 1);
	game.setChildIndex(grassBack, safeIndex); // Set grassBack to be rendered safely
}
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 scoreDisplay = new Mirror();
scoreDisplay.x = 2048 / 2 + 400; // Move the score display 400px to the right
scoreDisplay.y = 2732 - 185 - 80 - 390 + 30; // Move the score display up by an additional 80px and down by 30px
game.addChild(scoreDisplay);
var mirror = new Mirror();
mirror.x = 2048 / 2 + 400; // Move the mirror 400px to the right
mirror.y = 2732 - 185 - 80 - 390 + 30; // Move the mirror up by an additional 80px and down by 30px
game.addChild(mirror);
// Mirror doesn't need a specific layer as it's positioned using setChildIndex
// 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
;
// 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
	}
});
// 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
@@ -6,142 +6,73 @@
 
 /**** 
 * Classes
 ****/ 
-// Background class to represent the background image
 var Background = Container.expand(function () {
 	var self = Container.call(this);
 	var backgroundGraphics = self.attachAsset('background', {
 		anchorX: 0.5,
 		anchorY: 0.5
 	});
 	self.addChild(backgroundGraphics);
-	// Set the layer index for background
 	game.layerManager.addToLayer(self, LAYERS.BACKGROUND);
 });
-// 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', {
 		anchorX: 0.5,
 		anchorY: 0.5
 	});
 	self.movement = new Bird1Movement(self, birdGraphics);
-	// Set the layer index for bird1
 	game.layerManager.addToLayer(self, LAYERS.BIRD1);
 });
-// Bird2 class to represent the second kind of bird
 var Bird2 = Container.expand(function () {
 	var self = Container.call(this);
 	var birdGraphics = self.attachAsset('bird2', {
 		anchorX: 0.5,
 		anchorY: 0.5
 	});
 	self.movement = new Bird2Movement(self, birdGraphics);
-	// Set the layer index for bird2
 	game.layerManager.addToLayer(self, LAYERS.BIRD2);
 });
-// 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
-	};
-	// Set the layer index for cat
+	self.update = function () {};
 	game.layerManager.addToLayer(self, LAYERS.CAT);
 });
-// Cloud class to represent cloud behavior
 var Cloud = Container.expand(function () {
 	var self = Container.call(this);
 	var cloudType = CLOUD_TYPES[Math.floor(Math.random() * CLOUD_TYPES.length)];
 	var cloudGraphics = self.attachAsset(cloudType, {
 		anchorX: 0.5,
 		anchorY: 0.5,
-		alpha: 0.8 // Set default opacity to 80%
+		alpha: 0.8
 	});
-	// Set the layer index based on cloud type
 	var layerIndex = cloudType === 'cloud1' ? LAYERS.CLOUD1 : LAYERS.CLOUD2;
 	game.layerManager.addToLayer(self, layerIndex);
 	self.movement = new CloudMovement(self, cloudGraphics);
-	// Add update method to the cloud instance
+	if (typeof self.movement.update !== 'function') {
+		self.movement.update = function () {
+			// Default update logic if not defined
+		};
+	}
 	self.update = function () {
-		// The cloud's update method is already defined in CloudMovement
-		// No need to call it here as it would create an infinite recursion
+		self.movement.update();
 	};
 	return self;
 });
-// CloudMovement class to handle cloud movement and fade effects
-var CloudMovement = Container.expand(function () {
-	var self = Container.call(this);
-	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 () {
-		// Cache current position for movement calculations
-		var currentX = self.x;
-		var screenWidth = 2048;
-		var halfWidth = self.width / 2;
-		// Update position based on speed and direction
-		self.x += self.speed * self.direction;
-		// Handle screen wrapping
-		if (currentX <= screenWidth + halfWidth && self.x > screenWidth + halfWidth) {
-			self.x = -halfWidth;
-		} else if (currentX >= -halfWidth && self.x < -halfWidth) {
-			self.x = screenWidth + halfWidth;
-		}
-		// Handle cloud interactions
-		var isIntersecting = clouds.some(function (cloud) {
-			return cloud !== self && self.intersects(cloud);
-		});
-		if (isIntersecting && !self.hasAccelerated) {
-			self.speed *= 1.5;
-			self.hasAccelerated = true;
-		} else if (!isIntersecting && self.hasAccelerated) {
-			self.speed /= 1.5;
-			self.hasAccelerated = false;
-		}
-		// Handle sun interaction
-		var isTouchingSun = self.intersects(sun);
-		if (!self.lastIntersecting && isTouchingSun) {
-			self.speed *= 2;
-			tween(self.cloudGraphics, {
-				alpha: 0.5
-			}, {
-				duration: 3000,
-				easing: tween.linear
-			});
-		} else if (self.lastIntersecting && !isTouchingSun) {
-			self.speed /= 2;
-			tween(self.cloudGraphics, {
-				alpha: 1.0
-			}, {
-				duration: 3000,
-				easing: tween.linear
-			});
-		}
-		self.lastIntersecting = isTouchingSun;
-		// Update last position
-		self.lastX = self.x;
-	};
-	return self;
-});
 // 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
 	// Set the layer index for grass-back
@@ -156,66 +87,48 @@
 	});
 	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
 	};
 	// Set the layer index for grass-front
 	game.layerManager.addToLayer(self, LAYERS.GRASS_FRONT);
 });
-// Jet1 class to represent a jet flying across the screen
 var Jet1 = Container.expand(function () {
 	var self = Container.call(this);
 	var jetGraphics = self.attachAsset('jet1', {
 		anchorX: 0.5,
 		anchorY: 0.5,
-		flipX: 1 // Apply the same directional image flipping logic as bird1 and bird2
+		flipX: 1
 	});
-	// Set the layer index for jet
 	game.layerManager.addToLayer(self, LAYERS.JET1);
-	// 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.speed = 10;
+	self.direction = Math.random() < 0.5 ? 1 : -1;
+	self.lastX = self.x;
+	self.soundPlayed = false;
+	self.x = Math.random() < 0.5 ? 2048 + self.width / 2 : -self.width / 2;
 	self.update = function () {
-		flipImageVerticallyBasedOnDirection(jetGraphics, self.lastX, self.x); // Use flipImageVerticallyBasedOnDirection to flip on X axis
+		flipImageVerticallyBasedOnDirection(jetGraphics, self.lastX, self.x);
 		self.x += self.speed * self.direction;
-		// If the jet moves off-screen, destroy it and set it to null
-		if (!game.jetSoundPlayed) {
-			LK.getSound('jet1').play(); // Play jet1 sound when the jet is on screen
-			game.jetSoundPlayed = true; // Ensure it only plays once
+		if (!self.soundPlayed && self.x > 0 && self.x < 2048) {
+			LK.getSound('jet1').play();
+			self.soundPlayed = true;
 		}
 		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
-			// Set a timer to respawn the jet between 10-20 seconds
-			var respawnTime = Math.random() * 10000 + 10000; // Random time between 10-20 seconds
+			var respawnTime = Math.random() * 10000 + 10000;
 			game.jetSpawnTimer = LK.setTimeout(function () {
 				var jet = new Jet1();
-				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 / 2); // Random initial y position in the top half of the screen
+				jet.x = Math.random() < 0.5 ? 2048 + jet.width / 2 : -jet.width / 2;
+				jet.y = Math.random() * (2732 / 2);
 				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.jetSpawnTimer = null; // Clear the timer reference
+				game.jetSpawnTimer = null;
 			}, respawnTime);
 		}
-		self.lastX = self.x; // Update lastX after movement
+		self.lastX = self.x;
 	};
 });
 // Laser class to represent a laser shot from the cat
 var Laser = Container.expand(function (startX, startY, targetX, targetY) {
@@ -236,25 +149,17 @@
 	self.vy = dy / distance * speed;
 	// Set initial position
 	self.x = startX;
 	self.y = startY;
-	// Update function to move the laser
 	self.update = function () {
 		game.children.forEach(function (child) {
-			if (AABBIntersect(child, bird)) {
-				// Debug visualization: Draw a rectangle around the intersecting objects
-				var debugGraphics = new Graphics();
-				debugGraphics.lineStyle(2, 0xFF0000, 1);
-				debugGraphics.drawRect(bird.x, bird.y, bird.width, bird.height);
-				game.addChild(debugGraphics);
-				LK.setTimeout(function () {
-					game.removeChild(debugGraphics);
-				}, 100); // Remove debug visualization after 100ms
+			if ((child instanceof Bird1 || child instanceof Bird2) && self.intersects(child)) {
+				child.destroy();
+				self.destroy();
 			}
-		}); // Close the loop for iterating over game children
+		});
 		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();
 		}
 	};
@@ -266,26 +171,25 @@
 	var self = Container.call(this);
 	var lightGraphics = self.attachAsset('light1', {
 		anchorX: 0.5,
 		anchorY: 0.5,
-		alpha: 0.2 // Set transparency to 20%
+		alpha: 1.0
 	});
-	self.x = 450, self.y = 450;
+	self.x = 450;
+	self.y = 450;
 	self.update = function () {
-		// Add any specific update logic for the light here
+		self.x += Math.sin(LK.ticks / 90) * 0.1;
 	};
 	self.pulse = new Light1Pulse(lightGraphics);
 	self.pulse.startPulsating();
-	// Set the layer index for light
 	game.layerManager.addToLayer(self, LAYERS.LIGHT1);
 });
-// 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 / 36 // Rotate image left 5 degrees
+		rotation: Math.PI / 60
 	});
 	var scoreText = new Text2('0', {
 		size: 175,
 		fill: 0x800080,
@@ -300,9 +204,9 @@
 		dropShadowDistance: 6
 	});
 	scoreText.y = 160; // Move score text down by 110px
 	scoreText.x = -155; // Move score text left by 10px
-	scoreText.rotation = -65 * (Math.PI / 180); // Rotate score text left by 65 degrees
+	scoreText.rotation = -85 * (Math.PI / 180);
 	x = 100;
 	y = 100;
 	self.addChild(scoreText);
 	self.updateScore = function (newScore) {
@@ -319,20 +223,21 @@
 	self.addChild(mirror1Graphics);
 	// Set the layer index for mirror
 	game.layerManager.addToLayer(self, LAYERS.MIRROR);
 });
-// 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
+		if (!self.pulse) {
+			self.pulse = new ReticlePulse(reticleGraphics);
+			self.pulse.startPulsating();
+		}
 	};
-	// Start the pulsating effect for the reticle
-	startPulsating(self);
+	game.layerManager.addToLayer(self, LAYERS.RETICLE);
 });
 // Reticle1 class to represent the reticle image
 var Reticle1 = Container.expand(function () {
 	var self = Container.call(this);
@@ -357,9 +262,8 @@
 	};
 	// Set the layer index for stack
 	game.layerManager.addToLayer(self, LAYERS.STACK);
 });
-// 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', {
@@ -370,9 +274,8 @@
 	self.pulse.startPulsating();
 	// Set the layer index for sun
 	game.layerManager.addToLayer(self, LAYERS.SUN);
 });
-// 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('tree1', {
@@ -402,15 +305,14 @@
 	game.layerManager.addToLayer(self, LAYERS.TREE);
 });
 var UFO = Container.expand(function () {
 	var self = Container.call(this);
-	var ufoGraphics = self.attachAsset('ufo1', {
+	var ufoGraphics = self.attachAsset('ufo2', {
 		anchorX: 0.5,
 		anchorY: 0.5
 	});
 	self.movement = new UFOMovement(self, ufoGraphics);
-	// Set the layer index for UFO
-	game.layerManager.addToLayer(self, LAYERS.UFO1);
+	game.layerManager.addToLayer(self, LAYERS.UFO2);
 });
 // UFO1 class to represent a specific type of UFO
 var UFO1 = Container.expand(function () {
 	var self = Container.call(this);
@@ -429,23 +331,14 @@
 		anchorX: 0.5,
 		anchorY: 0.5
 	});
 	self.movement = new UFOMovement(self, ufo2Graphics);
-	// Set the layer index for ufo2
-	game.layerManager.addToLayer(self, LAYERS.UFO1);
+	game.layerManager.addToLayer(self, LAYERS.UFO2);
 });
 
 /**** 
 * Initialize Game
 ****/ 
-// UFOMovement class to handle UFO movement
-/**** 
-* Assets
-LK.init.shape('branch', {width:50, height:10, color:0x8b4513, shape:'box'})
-****/ 
-/**** 
-* Layer Constants
-****/ 
 // Initialize clouds array
 var game = new LK.Game({
 	// No title, no description
 	backgroundColor: 0x87CEEB // Sky blue
@@ -453,10 +346,25 @@
 
 /**** 
 * Game Code
 ****/ 
-// Initialize the game's layer manager
 // CloudMovement class to handle cloud movement and fade effects
+var CloudMovement = function CloudMovement(cloud, cloudGraphics) {
+	this.cloud = cloud;
+	this.cloudGraphics = cloudGraphics;
+	this.speed = Math.random() * 0.55 + 0.25;
+	this.direction = Math.random() < 0.5 ? 1 : -1;
+	this.update = function () {
+		this.cloud.x += this.speed * this.direction;
+		var screenWidth = 2048;
+		var halfWidth = this.cloud.width / 2;
+		if (this.cloud.x > screenWidth + halfWidth) {
+			this.cloud.x = -halfWidth;
+		} else if (this.cloud.x < -halfWidth) {
+			this.cloud.x = screenWidth + halfWidth;
+		}
+	}.bind(this);
+};
 function _typeof(o) {
 	"@babel/helpers - typeof";
 	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
 		return typeof o;
@@ -500,55 +408,48 @@
 }
 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
-	// Bind update method to the cloud instance
+	this.cloud.speed = Math.random() * 0.55 + 0.25;
+	this.cloud.hasAccelerated = false;
+	this.cloud.direction = Math.random() < 0.5 ? 1 : -1;
+	this.cloud.lastX = this.cloud.x;
+	this.cloud.lastIntersecting = false;
 	this.cloud.update = function () {
-		// Cache current position for movement calculations
 		var currentX = this.x;
 		var screenWidth = 2048;
 		var halfWidth = this.width / 2;
-		// Update position based on speed and direction
 		this.x += this.speed * this.direction;
-		// Handle screen wrapping
 		if (currentX <= screenWidth + halfWidth && this.x > screenWidth + halfWidth) {
 			this.x = -halfWidth;
 		} else if (currentX >= -halfWidth && this.x < -halfWidth) {
 			this.x = screenWidth + halfWidth;
 		}
-		this.lastX = this.x; // Update lastX after movement
-	}.bind(this.cloud); // Bind the update function to the cloud instance
+		this.lastX = this.x;
+	}.bind(this.cloud);
 };
-// UFOMovement class to handle UFO movement
 /**** 
-* Assets
-LK.init.shape('branch', {width:50, height:10, color:0x8b4513, shape:'box'})
-****/ 
-/**** 
 * Layer Constants
 ****/ 
 var LAYERS = {
 	BACKGROUND: 0,
-	LIGHT1: 1,
-	SUN: 2,
-	JET1: 3,
-	CLOUD1: 4,
-	UFO1: 5,
-	CLOUD2: 6,
-	GRASS_BACK: 7,
+	GRASS_BACK: 1,
+	TREE: 2,
+	CLOUD1: 3,
+	CLOUD2: 4,
+	JET1: 5,
+	UFO1: 6,
+	UFO2: 7,
 	BIRD1: 8,
-	TREE: 9,
-	STACK: 10,
-	BIRD2: 11,
-	GRASS_FRONT: 12,
-	CAT: 13,
-	LASER: 14,
-	RETICLE: 15
+	BIRD2: 9,
+	LASER: 10,
+	CAT: 11,
+	RETICLE: 12,
+	STACK: 13,
+	MIRROR: 14,
+	GRASS_FRONT: 15,
+	SUN: 16,
+	LIGHT1: 17
 };
 /**** 
 * Layer Management System
 ****/ 
@@ -797,16 +698,14 @@
 		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
+			scaleX: 1.2,
+			scaleY: 1.2
 		}, {
 			duration: duration,
 			easing: tween.easeInOut,
 			onFinish: function onFinish() {
@@ -822,46 +721,37 @@
 		});
 	}
 	pulsate();
 }
-// 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.speed = 3.2;
+	this.ufo.direction = Math.random() < 0.5 ? 1 : -1;
+	this.ufo.lastX = this.ufo.x;
+	this.ufo.soundPlayed = false;
 	this.ufo.update = function () {
-		var _this3 = this;
-		// Cache current position and dimensions
 		var currentX = this.x;
 		var screenWidth = 2048;
 		var halfWidth = this.width / 2;
-		// Update position based on pattern
-		this.x += this.speed * Math.cos(LK.ticks / 60);
-		this.y = 100 + Math.sin(LK.ticks / 120) * 250;
-		// Optimize movement pattern
-		var distanceFromCenter = Math.abs(this.x - screenWidth / 2);
-		if (distanceFromCenter > screenWidth / 3) {
-			this.speed *= -0.95; // Smooth direction change
-		}
-		// Cache intersection checks
-		var isIntersectingCloud = clouds.some(function (cloud) {
-			return _this3.intersects(cloud);
-		});
-		if (isIntersectingCloud && !this.lastIntersecting) {
-			this.speed *= 1.2;
+		var tickCos = Math.cos(LK.ticks / 60);
+		var tickSin = Math.sin(LK.ticks / 120);
+		this.x += this.speed * tickCos;
+		this.y = 100 + tickSin * 250;
+		if (this.x > 0 && this.x < screenWidth && !this.soundPlayed) {
 			LK.getSound('ufo1').play();
+			this.soundPlayed = true;
 		}
-		this.lastIntersecting = isIntersectingCloud;
-		// Stop playing ufo1 sound after UFO leaves the screen
-		if (this.lastX <= screenWidth + halfWidth && this.x > screenWidth + halfWidth || this.lastX >= -halfWidth && this.x < -halfWidth) {
+		if (this.x < 0 || this.x > screenWidth) {
+			this.soundPlayed = false;
+		}
+		if (currentX <= screenWidth + halfWidth && this.x > screenWidth + halfWidth || currentX >= -halfWidth && this.x < -halfWidth) {
+			LK.getSound('ufo1').stop();
 			this.destroy();
 			ufo = null;
-			LK.getSound('ufo1').stop();
 		}
-		this.lastX = this.x; // Update lastX after movement
+		this.lastX = this.x;
 	};
 };
 var UFOSound = function UFOSound() {
 	this.play = function () {
@@ -890,42 +780,50 @@
 };
 var Bird1Movement = function Bird1Movement(bird, birdGraphics) {
 	this.bird = bird;
 	this.birdGraphics = birdGraphics;
-	this.bird.speed = Math.random() * 1.6 + 1;
+	this.bird.speed = Math.random() * 3.2 + 2;
 	this.bird.lastY = storage.bird1_lastY || this.bird.y;
 	this.bird.lastX = storage.bird1_lastX || this.bird.x;
 	this.bird.update = function () {
-		var _this4 = this;
-		// Cache current position and screen dimensions
+		// Cache all frequently used values
 		var currentX = this.x;
 		var currentY = this.y;
 		var screenWidth = 2048;
 		var screenHeight = 2732;
-		// Update position based on speed and pattern
-		this.x += this.speed * Math.cos(LK.ticks / 50);
-		this.y += this.speed * 0.5;
-		// Handle screen boundaries
+		var tickCos = Math.cos(LK.ticks / 50);
+		// Update position with optimized calculations
+		this.x += this.speed * tickCos;
+		this.y += Math.sin(this.x / 100) * 6.5;
+		// Handle screen boundaries with optimized random positioning
 		if (currentY > screenHeight + this.height) {
 			this.y = -this.height;
-			this.x = Math.random() < 0.33 ? Math.random() * screenWidth : Math.random() < 0.5 ? 0 : screenWidth;
+			var rand = Math.random();
+			this.x = rand < 0.33 ? rand * screenWidth : rand < 0.5 ? 0 : screenWidth;
 		}
-		// Update rotation based on movement
+		// Update rotation with cached movement values
 		this.rotation = Math.atan2(this.y - currentY, this.x - currentX) * 0.1;
-		// Cache intersection checks
-		var isIntersectingCloud = clouds.some(function (cloud) {
-			return _this4.intersects(cloud);
-		});
+		// Optimize cloud intersection check
+		var isIntersectingCloud = false;
+		for (var i = 0; i < clouds.length; i++) {
+			if (this.intersects(clouds[i])) {
+				isIntersectingCloud = true;
+				break;
+			}
+		}
+		// Handle cloud intersection effects
 		if (isIntersectingCloud && !this.lastIntersecting) {
 			this.speed *= 0.8;
 			LK.getSound('wings1').play();
 		}
 		this.lastIntersecting = isIntersectingCloud;
-		// Update position tracking
-		this.lastX = currentX;
-		this.lastY = currentY;
-		storage.bird1_lastX = this.lastX;
-		storage.bird1_lastY = this.lastY;
+		// Update position tracking with throttled storage updates
+		if (Math.abs(this.lastX - currentX) > 1 || Math.abs(this.lastY - currentY) > 1) {
+			this.lastX = currentX;
+			this.lastY = currentY;
+			storage.bird1_lastX = currentX;
+			storage.bird1_lastY = currentY;
+		}
 		// Handle image flipping
 		flipImageVerticallyBasedOnDirection(birdGraphics, currentX, this.x);
 	};
 };
@@ -951,10 +849,33 @@
 	};
 };
 var Bird2Effects = function Bird2Effects(bird) {
 	this.bird = bird;
-	this.applyEffects = function () {
-		// Add any specific effects or animations for Bird2 here
+	this.applyEffects = function () {};
+};
+var ReticlePulse = function ReticlePulse(reticleGraphics) {
+	this.reticleGraphics = reticleGraphics;
+	this.startPulsating = function () {
+		function pulsate() {
+			tween(this.reticleGraphics, {
+				scaleX: 1.2,
+				scaleY: 1.2
+			}, {
+				duration: 1000,
+				easing: tween.easeInOut,
+				onFinish: function () {
+					tween(this.reticleGraphics, {
+						scaleX: 1.0,
+						scaleY: 1.0
+					}, {
+						duration: 1000,
+						easing: tween.easeInOut,
+						onFinish: pulsate.bind(this)
+					});
+				}.bind(this)
+			});
+		}
+		pulsate.call(this);
 	};
 };
 // Bird1Effects class to handle effects and animations for Bird1
 var Bird1Effects = function Bird1Effects(bird) {
@@ -971,19 +892,31 @@
 game.layerManager.addToLayer(background, LAYERS.BACKGROUND);
 // ScoreManager class to manage score logic
 var ScoreManager = function ScoreManager() {
 	var self = this;
-	self.score = 0;
+	var currentScore = 0;
+	var highScore = storage.highScore || 0;
 	self.addScore = function (points) {
-		self.score += points;
-		return self.score;
+		if (typeof points !== 'number' || points < 0) {
+			return currentScore;
+		}
+		currentScore += Math.floor(points);
+		if (currentScore > highScore) {
+			highScore = currentScore;
+			storage.highScore = highScore;
+		}
+		return currentScore;
 	};
 	self.resetScore = function () {
-		self.score = 0;
+		currentScore = 0;
+		return currentScore;
 	};
 	self.getScore = function () {
-		return self.score;
+		return currentScore;
 	};
+	self.getHighScore = function () {
+		return highScore;
+	};
 };
 var birds = [];
 game.down = function (x, y, obj) {
 	if (!game.reticle) {
@@ -999,15 +932,8 @@
 	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());
 	}
@@ -1023,30 +949,29 @@
 sun.x = 480;
 sun.y = 680;
 game.layerManager.addToLayer(sun, LAYERS.SUN);
 var light1 = new Light1();
-light1.x = 510; // Move light1 right by 50px
-light1.y = 1500; // Move light1 down by 210px
+light1.x = 510;
+light1.y = 1500;
 game.layerManager.addToLayer(light1, LAYERS.LIGHT1);
+light1.visible = true;
 // Function to add a UFO to the game
 function addUFO() {
-	if (!game.children.some(function (c) {
-		return c instanceof UFO1;
-	})) {
-		ufo = new UFO1();
-		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();
-		};
-		return ufo;
+	var ufo = new UFO1();
+	game.addChild(ufo);
+	if (game.children.includes(ufo) && game.children.includes(clouds[0])) {
+		game.setChildIndex(ufo, game.getChildIndex(clouds[0]) + 1);
 	}
-	return null;
+	ufo.x = Math.random() < 0.5 ? 2048 + ufo.width / 2 : -ufo.width / 2;
+	ufo.y = Math.random() * (2732 / 2 - ufo.height);
+	ufo.customUpdate = function () {
+		if (!ufo.soundPlayed && ufo.x > 0 && ufo.x < 2048) {
+			LK.getSound('ufo1').play();
+			ufo.soundPlayed = true;
+		}
+		ufo.update();
+	};
+	return ufo;
 }
 // Initialize clouds array
 var clouds = [];
 // Initialize cloud types
@@ -1494,45 +1419,17 @@
 };
 var Bird1Movement = function Bird1Movement(bird, birdGraphics) {
 	this.bird = bird;
 	this.birdGraphics = birdGraphics;
-	this.bird.speed = Math.random() * 1.6 + 1;
-	this.bird.lastY = storage.bird1_lastY || this.bird.y;
-	this.bird.lastX = storage.bird1_lastX || this.bird.x;
+	this.bird.speed = 1 + Math.random() * 1.2;
+	this.bird.lastY = this.bird.y;
+	this.bird.lastX = this.bird.x;
 	this.bird.update = function () {
-		var _this6 = this;
-		// Cache current position and screen dimensions
-		var currentX = this.x;
-		var currentY = this.y;
-		var screenWidth = 2048;
-		var screenHeight = 2732;
-		// Update position based on speed and pattern
-		this.x += this.speed * Math.cos(LK.ticks / 50);
-		this.y += this.speed * 0.5;
-		// Handle screen boundaries
-		if (currentY > screenHeight + this.height) {
-			this.y = -this.height;
-			this.x = Math.random() < 0.33 ? Math.random() * screenWidth : Math.random() < 0.5 ? 0 : screenWidth;
-		}
-		// Update rotation based on movement
-		this.rotation = Math.atan2(this.y - currentY, this.x - currentX) * 0.1;
-		// Cache intersection checks
-		var isIntersectingCloud = clouds.some(function (cloud) {
-			return _this6.intersects(cloud);
-		});
-		if (isIntersectingCloud && !this.lastIntersecting) {
-			this.speed *= 0.8;
-			LK.getSound('wings1').play();
-		}
-		this.lastIntersecting = isIntersectingCloud;
-		// Update position tracking
-		this.lastX = currentX;
-		this.lastY = currentY;
-		storage.bird1_lastX = this.lastX;
-		storage.bird1_lastY = this.lastY;
-		// Handle image flipping
-		flipImageVerticallyBasedOnDirection(birdGraphics, currentX, this.x);
-	};
+		this.y += this.speed;
+		this.x += Math.sin((LK.ticks + 50) / 50) * 0.25;
+		this.lastY = this.y;
+		this.lastX = this.x;
+	}.bind(this.bird);
 };
 var Bird2Movement = function Bird2Movement(bird, birdGraphics) {
 	this.bird = bird;
 	this.birdGraphics = birdGraphics;
@@ -1555,10 +1452,33 @@
 	};
 };
 var Bird2Effects = function Bird2Effects(bird) {
 	this.bird = bird;
-	this.applyEffects = function () {
-		// Add any specific effects or animations for Bird2 here
+	this.applyEffects = function () {};
+};
+var ReticlePulse = function ReticlePulse(reticleGraphics) {
+	this.reticleGraphics = reticleGraphics;
+	this.startPulsating = function () {
+		function pulsate() {
+			tween(this.reticleGraphics, {
+				scaleX: 1.2,
+				scaleY: 1.2
+			}, {
+				duration: 1000,
+				easing: tween.easeInOut,
+				onFinish: function () {
+					tween(this.reticleGraphics, {
+						scaleX: 1.0,
+						scaleY: 1.0
+					}, {
+						duration: 1000,
+						easing: tween.easeInOut,
+						onFinish: pulsate.bind(this)
+					});
+				}.bind(this)
+			});
+		}
+		pulsate.call(this);
 	};
 };
 // Bird1Effects class to handle effects and animations for Bird1
 var Bird1Effects = function Bird1Effects(bird) {
@@ -1574,19 +1494,31 @@
 game.layerManager.addToLayer(background, LAYERS.BACKGROUND);
 // ScoreManager class to manage score logic
 var ScoreManager = function ScoreManager() {
 	var self = this;
-	self.score = 0;
+	var currentScore = 0;
+	var highScore = storage.highScore || 0;
 	self.addScore = function (points) {
-		self.score += points;
-		return self.score;
+		if (typeof points !== 'number' || points < 0) {
+			return currentScore;
+		}
+		currentScore += Math.floor(points);
+		if (currentScore > highScore) {
+			highScore = currentScore;
+			storage.highScore = highScore;
+		}
+		return currentScore;
 	};
 	self.resetScore = function () {
-		self.score = 0;
+		currentScore = 0;
+		return currentScore;
 	};
 	self.getScore = function () {
-		return self.score;
+		return currentScore;
 	};
+	self.getHighScore = function () {
+		return highScore;
+	};
 };
 var birds = [];
 game.down = function (x, y, obj) {
 	if (!game.reticle) {
@@ -1626,11 +1558,12 @@
 sun.x = 480;
 sun.y = 680;
 game.layerManager.addToLayer(sun, LAYERS.SUN);
 var light1 = new Light1();
-light1.x = 510; // Move light1 right by 50px
-light1.y = 1500; // Move light1 down by 210px
+light1.x = 510;
+light1.y = 1500;
 game.layerManager.addToLayer(light1, LAYERS.LIGHT1);
+light1.visible = true;
 // Function to add a UFO to the game
 // Initialize clouds array
 var clouds = [];
 // Initialize cloud types
@@ -1640,15 +1573,12 @@
 initializeClouds();
 var bird1; // Define bird1 variable in the global scope
 var bird; // Define bird variable in the global scope
 // Initialize birds
-if (!birds.some(function (b) {
-	return b instanceof Bird1;
-})) {
+spawnBird2();
+if (!bird1) {
 	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 () {
@@ -1666,16 +1596,11 @@
 		var jet = new Jet1();
 		jet.x = Math.random() < 0.5 ? 2048 + jet.width / 2 : -jet.width / 2;
 		jet.y = Math.random() * (2732 / 2);
 		game.addChild(jet);
-		if (game.children.includes(jet) && game.children.includes(clouds[0])) {
-			game.setChildIndex(jet, game.getChildIndex(clouds[0]) + 1);
-		}
 		game.jet = jet;
-		if (!game.jetSoundPlayed) {
-			LK.getSound('jet1').play();
-			game.jetSoundPlayed = true;
-		}
+		game.layerManager.addToLayer(jet, LAYERS.JET1);
+		LK.getSound('jet1').play();
 	}
 	// Update jet
 	if (game.jet) {
 		game.jet.update();
@@ -1713,9 +1638,9 @@
 		var ufoIntersection = birds.some(function (bird) {
 			if (!ufo.lastIntersecting && ufo.intersects(bird)) {
 				bird.destroy();
 				birds.splice(birds.indexOf(bird), 1);
-				LK.getSound('electro').play();
+				LK.getSound('dead2').play();
 				return true;
 			}
 			return ufo.intersects(bird);
 		});
@@ -1880,10 +1805,8 @@
 }, 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;
-// Display volumes of all sounds in the console
-// Sound volumes configuration
 // 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 () {