/**** 
* 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);
	// Override destroy method to remove from layer tracking
	var originalDestroy = self.destroy;
	self.destroy = function () {
		// Remove from layer tracking before destroying
		if (game.layerManager) {
			game.layerManager.removeFromTracking(self);
		}
		// Call the original destroy method
		originalDestroy.call(self);
	};
	self.update = function () {
		self.movement.update();
	};
	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);
	// Override destroy method to remove from layer tracking
	var originalDestroy = self.destroy;
	self.destroy = function () {
		// Remove from layer tracking before destroying
		if (game.layerManager) {
			game.layerManager.removeFromTracking(self);
		}
		// Call the original destroy method
		originalDestroy.call(self);
	};
	self.update = function () {
		self.movement.update();
	};
	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);
});
// Define cloud types at the beginning
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);
	self.cloudType = cloudType;
	// Override destroy method to remove from layer tracking and update counts
	var originalDestroy = self.destroy;
	self.destroy = function () {
		// Remove from layer tracking before destroying
		if (game.layerManager) {
			game.layerManager.removeFromTracking(self);
		}
		// Update spawn manager counts
		if (spawnManager) {
			spawnManager.objectCounts[self.cloudType === 'cloud1' ? 'cloud1' : 'cloud2']--;
		}
		// Call the original destroy method
		originalDestroy.call(self);
	};
	self.update = function () {
		self.movement.update();
	};
	return self;
});
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);
});
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
	});
	self.type = '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;
	// Override destroy method to remove from layer tracking
	var originalDestroy = self.destroy;
	self.destroy = function () {
		// Remove from layer tracking before destroying
		if (game.layerManager) {
			game.layerManager.removeFromTracking(self);
		}
		// Stop sound when destroyed
		LK.getSound('jet1').stop();
		// Call the original destroy method
		originalDestroy.call(self);
	};
	self.update = function () {
		flipImageVerticallyBasedOnDirection(jetGraphics, self.lastX, self.x);
		self.x += self.speed * self.direction;
		// Play jet1 sound when on screen
		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) {
			if (game.jetSpawnTimer) {
				LK.clearTimeout(game.jetSpawnTimer);
			}
			self.destroy();
			game.jet = null;
			var respawnTime = Math.random() * 10000 + 20000;
			game.jetSpawnTimer = LK.setTimeout(function () {
				if (game.jet === null) {
					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.layerManager.addToLayer(jet, LAYERS.JET1);
					game.jet = jet;
				}
				game.jetSpawnTimer = null;
			}, respawnTime);
		}
		self.lastX = self.x;
	};
});
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
	});
	LK.getSound('laser1').play();
	var dx = targetX - startX;
	var dy = targetY - startY;
	var distance = Math.sqrt(dx * dx + dy * dy);
	var speed = 60;
	self.vx = dx / distance * speed;
	self.vy = dy / distance * speed;
	self.x = startX;
	self.y = startY;
	self.lastIntersecting = false;
	self.active = true;
	var originalDestroy = self.destroy;
	self.destroy = function () {
		if (game.layerManager) {
			game.layerManager.removeFromTracking(self);
		}
		originalDestroy.call(self);
	};
	self.update = function () {
		if (!self.active) {
			return;
		}
		game.children.forEach(function (child) {
			if (!self.lastIntersecting && (child instanceof Bird1 || child instanceof Bird2 || child instanceof UFO1 || child instanceof UFO2) && self.intersects(child)) {
				var soundEffect = child instanceof UFO1 || child instanceof UFO2 ? 'dead3' : 'dead2';
				// Update score and object counts through spawn manager
				if (spawnManager) {
					spawnManager.objectCounts[child.type]--;
					spawnManager.scoreManager.addScore(child.type);
					spawnManager.scheduleRespawn(child.type, child.constructor);
				}
				// Play sound effect and destroy objects
				LK.getSound(soundEffect).play();
				child.destroy();
				self.active = false;
				self.destroy();
				// Update score display
				if (mirror && mirror.updateScore) {
					mirror.updateScore(spawnManager.scoreManager.getScore());
				}
				return;
			}
		});
		self.x += self.vx;
		self.y += self.vy;
		// Update intersection state
		self.lastIntersecting = game.children.some(function (target) {
			return (target instanceof Bird1 || target instanceof Bird2 || target instanceof UFO1 || target instanceof UFO2) && self.intersects(target);
		});
		// Destroy if out of bounds
		if (self.x < 0 || self.x > 2048 || self.y < 0 || self.y > 2732) {
			self.destroy();
		}
	};
	game.layerManager.addToLayer(self, LAYERS.LASER);
});
var Light1 = Container.expand(function () {
	var self = Container.call(this);
	var lightGraphics = self.attachAsset('light1', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.addChild(lightGraphics);
	game.layerManager.addToLayer(self, LAYERS.LIGHT1);
	var originalDestroy = self.destroy;
	self.destroy = function () {
		if (game.layerManager) {
			game.layerManager.removeFromTracking(self);
		}
		originalDestroy.call(self);
	};
	var lightGraphics = self.attachAsset('light1', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 1.0
	});
	self.addChild(lightGraphics);
	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 mirrorGraphics = self.attachAsset('mirror1', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.addChild(mirrorGraphics);
	// Set the layer index for mirror
	game.layerManager.addToLayer(self, LAYERS.MIRROR);
	// Score display functionality
	var scoreText = new Text2('0', {
		size: 175,
		fill: 0x800080,
		font: "Courier New, Courier, monospace",
		stroke: 0x00FF00,
		strokeThickness: 15,
		dropShadow: true,
		dropShadowColor: 0x000000,
		dropShadowBlur: 5,
		dropShadowAngle: Math.PI / 6,
		dropShadowDistance: 6
	});
	scoreText.y = 260 + 50; // Move down 50px
	scoreText.x = -155;
	scoreText.rotation = (-83 - 3) * (Math.PI / 180); // Rotate left by 3 degrees
	self.addChild(scoreText);
	self.updateScore = function (newScore) {
		scoreText.setText(newScore);
	};
	return self;
});
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);
});
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);
});
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);
});
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);
});
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);
});
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);
});
var UFO1 = Container.expand(function () {
	var self = Container.call(this);
	var ufo1Graphics = self.attachAsset('ufo1', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.type = 'ufo1';
	self.soundPlayed = false;
	self.movement = new UFOMovement(self, ufo1Graphics);
	// Override destroy method to remove from layer tracking
	var originalDestroy = self.destroy;
	self.destroy = function () {
		// Remove from layer tracking before destroying
		if (game.layerManager) {
			game.layerManager.removeFromTracking(self);
		}
		// Stop sound when destroyed
		LK.getSound('ufo1').stop();
		// Call the original destroy method
		originalDestroy.call(self);
	};
	self.update = function () {
		if (!self.soundPlayed && self.x > 0 && self.x < 2048) {
			LK.getSound('ufo1').play();
			self.soundPlayed = true;
		}
		if (self.movement) {
			self.movement.update();
		}
	};
	// Set the layer index for ufo1
	game.layerManager.addToLayer(self, LAYERS.UFO1);
});
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);
	// Override destroy method to remove from layer tracking
	var originalDestroy = self.destroy;
	self.destroy = function () {
		// Remove from layer tracking before destroying
		if (game.layerManager) {
			game.layerManager.removeFromTracking(self);
		}
		// Call the original destroy method
		originalDestroy.call(self);
	};
	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
****/ 
// Define cloud types at the beginning
// CloudMovement class to handle cloud movement and fade effects
function _typeof2(o) {
	"@babel/helpers - typeof";
	return _typeof2 = "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;
	}, _typeof2(o);
}
function _createForOfIteratorHelper(r, e) {
	var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
	if (!t) {
		if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) {
			t && (r = t);
			var _n = 0,
				F = function F() {};
			return {
				s: F,
				n: function n() {
					return _n >= r.length ? {
						done: !0
					} : {
						done: !1,
						value: r[_n++]
					};
				},
				e: function e(r) {
					throw r;
				},
				f: F
			};
		}
		throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
	}
	var o,
		a = !0,
		u = !1;
	return {
		s: function s() {
			t = t.call(r);
		},
		n: function n() {
			var r = t.next();
			return a = r.done, r;
		},
		e: function e(r) {
			u = !0, o = r;
		},
		f: function f() {
			try {
				a || null == t["return"] || t["return"]();
			} finally {
				if (u) {
					throw o;
				}
			}
		}
	};
}
function _unsupportedIterableToArray(r, a) {
	if (r) {
		if ("string" == typeof r) {
			return _arrayLikeToArray(r, a);
		}
		var t = {}.toString.call(r).slice(8, -1);
		return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
	}
}
function _arrayLikeToArray(r, a) {
	(null == a || a > r.length) && (a = r.length);
	for (var e = 0, n = Array(a); e < a; e++) {
		n[e] = r[e];
	}
	return n;
}
function _classCallCheck2(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, _toPropertyKey2(o.key), o);
	}
}
function _createClass2(e, r, t) {
	return r && __defineProperties(e.prototype, r), t && __defineProperties(e, t), Object.defineProperty(e, "prototype", {
		writable: !1
	}), e;
}
function _toPropertyKey2(t) {
	var i = _toPrimitive2(t, "string");
	return "symbol" == _typeof2(i) ? i : i + "";
}
function _toPrimitive2(t, r) {
	if ("object" != _typeof2(t) || !t) {
		return t;
	}
	var e = t[Symbol.toPrimitive];
	if (void 0 !== e) {
		var i = e.call(t, r || "default");
		if ("object" != _typeof2(i)) {
			return i;
		}
		throw new TypeError("@@toPrimitive must return a primitive value.");
	}
	return ("string" === r ? String : Number)(t);
}
var CLOUD_TYPES = ['cloud1', 'cloud2'];
var GameObjectMovement = function GameObjectMovement(object, graphics, options) {
	this.object = object;
	this.graphics = graphics;
	this.options = Object.assign({
		speed: 2,
		speedRange: 1.2,
		arcAmplitude: 6.5,
		arcFrequency: 100,
		isVertical: false,
		canFlip: true,
		moveSound: null,
		respawnTime: {
			min: 20000,
			max: 30000
		}
	}, options);
	this.speed = this.options.speed + Math.random() * this.options.speedRange;
	this.direction = Math.random() < 0.5 ? 1 : -1;
	this.lastX = this.object.x;
	this.lastY = this.object.y;
	this.soundPlayed = false;
	this.soundTimer = null;
	this.update = function () {
		var currentX = this.object.x;
		var currentY = this.object.y;
		var screenWidth = 2048;
		var screenHeight = 2732;
		var halfWidth = this.object.width / 2;
		if (this.options.isVertical) {
			this.object.y += this.speed;
			this.object.x += Math.sin(this.object.y / this.options.arcFrequency) * this.options.arcAmplitude;
			if (currentY > screenHeight + this.object.height) {
				this.object.destroy();
				if (spawnManager) {
					spawnManager.scheduleRespawn(this.object.type, this.object.constructor);
				}
				return;
			}
		} else {
			this.object.x += this.speed * this.direction;
			if (currentX <= screenWidth + halfWidth && this.object.x > screenWidth + halfWidth || currentX >= -halfWidth && this.object.x < -halfWidth) {
				this.object.destroy();
				if (spawnManager) {
					spawnManager.scheduleRespawn(this.object.type, this.object.constructor);
				}
				return;
			}
		}
		if (this.options.canFlip) {
			flipImageVerticallyBasedOnDirection(this.graphics, currentX, this.object.x);
		}
		if (this.options.moveSound && !this.soundPlayed && this.object.x > 0 && this.object.x < screenWidth) {
			if (this.soundTimer) {
				LK.clearTimeout(this.soundTimer);
			}
			var sound = LK.getSound(this.options.moveSound);
			sound.volume = 0.1;
			sound.play();
			this.soundPlayed = true;
			this.soundTimer = LK.setTimeout(function () {
				this.soundPlayed = false;
				this.soundTimer = null;
			}.bind(this), Math.random() * (30000 - 20000) + 20000);
		}
		this.lastX = this.object.x;
		this.lastY = this.object.y;
	}.bind(this);
};
var CloudMovement = function CloudMovement(cloud, cloudGraphics) {
	return new GameObjectMovement(cloud, cloudGraphics, {
		speed: 0.25,
		speedRange: 0.55,
		isVertical: false,
		canFlip: false
	});
};
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);
}
/***** 
* Layer Constants
****/ 
var LAYERS = {
	BACKGROUND: 0,
	SUN: 1,
	LIGHT1: 2,
	UFO2: 3,
	CLOUD1: 4,
	JET1: 5,
	CLOUD2: 6,
	UFO1: 7,
	BIRD1: 8,
	GRASS_BACK: 9,
	TREE: 10,
	STACK: 11,
	BIRD2: 12,
	MIRROR: 13,
	GRASS_FRONT: 14,
	CAT: 15,
	LASER: 16,
	RETICLE: 17
};
/***** 
* Layer Management System
****/ 
var LayerManager = /*#__PURE__*/function () {
	function LayerManager(gameInstance) {
		_classCallCheck(this, LayerManager);
		this.game = gameInstance;
		this.layerMap = {};
		// Layer order mapping to ensure correct rendering order
		this.layerOrder = [LAYERS.BACKGROUND, LAYERS.SUN, LAYERS.LIGHT1, LAYERS.UFO2, LAYERS.CLOUD1, LAYERS.JET1, LAYERS.CLOUD2, LAYERS.UFO1, LAYERS.BIRD1, LAYERS.GRASS_BACK, LAYERS.TREE, LAYERS.STACK, LAYERS.BIRD2, LAYERS.MIRROR, LAYERS.GRASS_FRONT, LAYERS.CAT, LAYERS.LASER, LAYERS.RETICLE];
	}
	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;
			}
			// Add the object if it's not already a child
			if (!this.game.children.includes(object)) {
				this.game.addChild(object);
			}
			// Set the child index to match the LAYERS order
			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;
}
// Using existing CLOUD_TYPES definition
var Pulse = function Pulse(graphics, options) {
	this.graphics = graphics;
	this.options = Object.assign({
		minScale: 1.0,
		maxScale: 1.2,
		expandDuration: 1000,
		contractDuration: 1000,
		easing: tween.easeInOut
	}, options);
	this.startPulsating = function () {
		function pulsate() {
			tween(this.graphics, {
				scaleX: this.options.maxScale,
				scaleY: this.options.maxScale
			}, {
				duration: this.options.expandDuration,
				easing: this.options.easing,
				onFinish: function () {
					tween(this.graphics, {
						scaleX: this.options.minScale,
						scaleY: this.options.minScale
					}, {
						duration: this.options.contractDuration,
						easing: this.options.easing,
						onFinish: pulsate.bind(this)
					});
				}.bind(this)
			});
		}
		pulsate.call(this);
	};
};
var SunPulse = function SunPulse(sunGraphics) {
	return new Pulse(sunGraphics, {
		maxScale: 1.1
	});
};
// Light1Pulse class to handle the pulsating effect for Light1
var Light1Pulse = function Light1Pulse(lightGraphics) {
	return new Pulse(lightGraphics, {
		maxScale: 1.6,
		contractDuration: 1500
	});
};
var bird2; // Define bird2 variable in the global scope
function startPulsating(target, options) {
	var pulse = new Pulse(target, options);
	pulse.startPulsating();
	return pulse;
}
// 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) {
	return new GameObjectMovement(bird, birdGraphics, {
		speed: 1,
		speedRange: 1.6,
		arcAmplitude: 6.5,
		arcFrequency: 100,
		isVertical: true,
		canFlip: true,
		moveSound: 'wings1'
	});
};
var Bird2Movement = function Bird2Movement(bird, birdGraphics) {
	return new GameObjectMovement(bird, birdGraphics, {
		speed: 1,
		speedRange: 1.6,
		arcAmplitude: 6.5,
		arcFrequency: 100,
		isVertical: true,
		canFlip: true,
		moveSound: 'wings1'
	});
};
var UFOMovement = function UFOMovement(ufo, ufoGraphics) {
	return new GameObjectMovement(ufo, ufoGraphics, {
		speed: 3.2,
		speedRange: 0.8,
		isVertical: false,
		canFlip: true,
		moveSound: 'ufo1'
	});
};
var Bird2Effects = function Bird2Effects(bird) {
	this.bird = bird;
	this.applyEffects = function () {};
};
var ReticlePulse = function ReticlePulse(reticleGraphics) {
	return new Pulse(reticleGraphics, {
		maxScale: 1.2
	});
};
// 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.scoreValues = {
		bird1: 5,
		// Fix: bird1 should be worth 5 points
		bird2: 1,
		// Fix: bird2 should be worth 1 point
		ufo1: 25,
		ufo2: 25 // Fix: match the value in spawnRules
	};
	self.addScore = function (objectType) {
		var points = self.scoreValues[objectType] || 0;
		if (points > 0) {
			currentScore += points;
			if (currentScore > highScore) {
				highScore = currentScore;
				storage.highScore = highScore;
			}
			// Update score display
			if (scoreDisplay && scoreDisplay.updateScore) {
				scoreDisplay.updateScore(currentScore);
			}
			if (mirror && mirror.updateScore) {
				mirror.updateScore(currentScore);
			}
		}
		return currentScore;
	};
	self.resetScore = function () {
		currentScore = 0;
		if (scoreDisplay && scoreDisplay.updateScore) {
			scoreDisplay.updateScore(currentScore);
		}
		if (mirror && mirror.updateScore) {
			mirror.updateScore(currentScore);
		}
		return currentScore;
	};
	self.getScore = function () {
		return currentScore;
	};
	self.getHighScore = function () {
		return highScore;
	};
};
var birds = [];
game.down = function (x, y, obj) {
	if (obj && obj.event) {
		x = obj.event.x;
		y = obj.event.y;
	}
	if (!game.reticle) {
		game.reticle = game.addChild(new Reticle());
		if (game.children.includes(game.reticle)) {
			game.layerManager.addToLayer(game.reticle, LAYERS.RETICLE);
		}
	}
	game.reticle.x = x;
	game.reticle.y = y;
	if (typeof x === 'undefined' || typeof y === 'undefined') {
		console.error('Invalid coordinates for laser');
		return;
	}
	var laser = new Laser(cat.x - 140, cat.y - 440, x, y);
	game.addChild(laser);
	if (game.children.includes(laser) && game.children.includes(game.reticle)) {
		game.layerManager.addToLayer(laser, LAYERS.LASER);
	}
};
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);
	game.layerManager.addToLayer(ufo, LAYERS.UFO1);
	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 = [];
function initializeClouds() {
	function ensureCloudCount() {
		// Remove off-screen clouds
		clouds = clouds.filter(function (cloud) {
			if (cloud.x < -cloud.width || cloud.x > 2048 + cloud.width) {
				cloud.destroy();
				return false;
			}
			return true;
		});
		// Add new clouds if needed, maintaining 3-5 clouds
		while (clouds.length < 5) {
			var cloud = new Cloud();
			cloud.x = Math.random() * 2048;
			cloud.y = Math.random() * (2732 / 2);
			game.addChild(cloud);
			game.layerManager.addToLayer(cloud, clouds.length < 3 ? LAYERS.CLOUD1 : LAYERS.CLOUD2);
			clouds.push(cloud);
		}
	}
	// Initial cloud setup
	ensureCloudCount();
	// Check cloud count every second
	LK.setInterval(ensureCloudCount, 1000);
}
// 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 and score
// Initialize game objects and managers
var spawnManager = new _SpawnManager();
var scoreManager = new ScoreManager();
// Initialize mirror for score display
var mirror = new Mirror();
mirror.x = 2048 / 2 + 400;
mirror.y = 2732 - 185 - 80 - 390 + 30 + 50;
game.addChild(mirror);
game.mirror = mirror;
game.layerManager.addToLayer(mirror, LAYERS.MIRROR);
// Set up score display
var scoreDisplay = mirror;
scoreDisplay.x = 2048 / 2 + 400;
scoreDisplay.y = 2732 - 185 - 80 - 390 + 30 + 50;
var SoundManager = function SoundManager() {
	this.soundTimers = {};
	this.soundIntervals = {
		ambient: {
			min: 20000,
			max: 30000
		},
		background: {
			min: 20000,
			max: 30000
		},
		ufo: {
			min: 20000,
			max: 30000
		},
		jet: {
			min: 20000,
			max: 30000
		}
	};
	this.playSound = function (soundId, options) {
		options = Object.assign({
			interval: this.soundIntervals.ambient,
			isMusic: false,
			volume: 0.1,
			loop: false,
			autoRestart: true
		}, options);
		var playFunction = function () {
			if (options.isMusic) {
				LK.playMusic(soundId, {
					volume: options.volume
				});
			} else {
				var sound = LK.getSound(soundId);
				sound.volume = options.volume;
				if (options.loop) {
					sound.loop = true;
				}
				sound.play();
			}
			if (options.autoRestart) {
				var nextInterval = Math.random() * (options.interval.max - options.interval.min) + options.interval.min;
				this.soundTimers[soundId] = LK.setTimeout(playFunction.bind(this), nextInterval);
			}
		}.bind(this);
		playFunction();
		return this.soundTimers[soundId];
	};
	this.initialize = function () {
		// Initialize ambient sounds with 20-30 second intervals
		this.playSound('songbird1', {
			volume: 0.1
		});
		this.playSound('cricket1', {
			volume: 0.1
		});
		this.playSound('breeze1', {
			volume: 0.1
		});
		this.playSound('frog1', {
			volume: 0.1
		});
		this.playSound('chitter', {
			volume: 0.1
		});
		// Initialize background music with 20-30 second intervals
		this.playSound('bgm1', {
			isMusic: true,
			volume: 0.1,
			interval: this.soundIntervals.background
		});
	};
	this.stopSound = function (soundId) {
		if (this.soundTimers[soundId]) {
			LK.clearTimeout(this.soundTimers[soundId]);
			delete this.soundTimers[soundId];
		}
		LK.getSound(soundId).stop();
	};
	this.stopAllSounds = function () {
		for (var soundId in this.soundTimers) {
			this.stopSound(soundId);
		}
	};
};
// Initialize game objects and start spawning
spawnManager.initialize();
// Initialize sound system
var soundManager = new SoundManager();
soundManager.initialize();
var _SpawnManager = function SpawnManager() {
	this.spawnTimers = {};
	this.objectCounts = {
		bird1: 0,
		bird2: 0,
		cloud1: 0,
		cloud2: 0,
		ufo1: 0,
		ufo2: 0,
		jet1: 0
	};
	this.spawnRules = {
		bird1: {
			max: 1,
			layer: LAYERS.BIRD1,
			movement: Bird1Movement,
			scoreValue: 5,
			respawnTime: {
				min: 5000,
				max: 10000
			}
		},
		bird2: {
			min: 3,
			max: 3,
			layer: LAYERS.BIRD2,
			movement: Bird2Movement,
			scoreValue: 1,
			respawnTime: {
				min: 5000,
				max: 10000
			}
		},
		cloud1: {
			min: 1,
			max: 3,
			layer: LAYERS.CLOUD1,
			movement: CloudMovement,
			respawnTime: {
				min: 5000,
				max: 10000
			}
		},
		cloud2: {
			min: 1,
			max: 3,
			layer: LAYERS.CLOUD2,
			movement: CloudMovement,
			respawnTime: {
				min: 5000,
				max: 10000
			}
		},
		ufo1: {
			max: 1,
			respawnTime: {
				min: 20000,
				max: 30000
			},
			layer: LAYERS.UFO1,
			movement: UFOMovement,
			sound: 'ufo1',
			scoreValue: 25
		},
		ufo2: {
			max: 1,
			respawnTime: {
				min: 20000,
				max: 30000
			},
			layer: LAYERS.UFO2,
			movement: UFOMovement,
			sound: 'ufo1',
			scoreValue: 25
		},
		jet1: {
			max: 1,
			respawnTime: {
				min: 20000,
				max: 30000
			},
			layer: LAYERS.JET1,
			movement: GameObjectMovement,
			sound: 'jet1'
		}
	};
	this.soundManager = new SoundManager();
	this.scoreManager = new ScoreManager();
	this.exclusiveGroups = [['ufo1', 'ufo2']];
	// Layer order matching LAYERS constant
	this.layerOrder = [LAYERS.BACKGROUND, LAYERS.SUN, LAYERS.LIGHT1, LAYERS.UFO2, LAYERS.CLOUD1, LAYERS.JET1, LAYERS.CLOUD2, LAYERS.UFO1, LAYERS.BIRD1, LAYERS.GRASS_BACK, LAYERS.TREE, LAYERS.STACK, LAYERS.BIRD2, LAYERS.MIRROR, LAYERS.GRASS_FRONT, LAYERS.CAT, LAYERS.LASER, LAYERS.RETICLE];
	this.spawnObject = function (type, Constructor, options) {
		var rule = this.spawnRules[type];
		var count = this.objectCounts[type];
		// Check if we've reached the maximum count for this type
		if (count >= (rule.max || 1)) {
			return;
		}
		// Check if we need to maintain a minimum count
		if (rule.min && count < rule.min) {
			while (count < rule.min) {
				this.createObject(type, Constructor, rule);
				count++;
			}
			return;
		}
		// Check exclusive groups (e.g., only one UFO type at a time)
		for (var i = 0; i < this.exclusiveGroups.length; i++) {
			var group = this.exclusiveGroups[i];
			if (group.includes(type)) {
				var groupTotal = 0;
				for (var j = 0; j < group.length; j++) {
					groupTotal += this.objectCounts[group[j]];
				}
				if (groupTotal > 0) {
					return;
				}
			}
		}
		// Check total cloud count to ensure 3-5 clouds
		if (type === 'cloud1' || type === 'cloud2') {
			var totalClouds = this.objectCounts.cloud1 + this.objectCounts.cloud2;
			if (totalClouds >= 5) {
				return;
			} // Don't spawn more if we already have 5
		}
		this.createObject(type, Constructor, rule);
	};
	this.createObject = function (type, Constructor, rule) {
		var obj = new Constructor();
		obj.type = type;
		// Position the object based on its type
		if (type === 'bird1' || type === 'bird2') {
			obj.x = Math.random() * 2048;
			obj.y = -obj.height;
		} else {
			obj.x = Math.random() < 0.5 ? 2048 + obj.width / 2 : -obj.width / 2;
			obj.y = Math.random() * (2732 / 2);
		}
		game.addChild(obj);
		game.layerManager.addToLayer(obj, rule.layer);
		this.objectCounts[type]++;
		// Initialize movement with appropriate options
		if (rule.movement) {
			// Define common movement parameters by object type
			var movementParams = {
				// Birds share the same movement parameters
				bird: {
					speed: 2,
					speedRange: 1.6,
					arcAmplitude: 6.5,
					arcFrequency: 100,
					isVertical: true,
					canFlip: true,
					moveSound: 'wings1'
				},
				// UFOs share the same movement parameters
				ufo: {
					speed: 3.2,
					speedRange: 0.8,
					arcAmplitude: 4.5,
					arcFrequency: 80,
					isVertical: false,
					canFlip: true,
					moveSound: 'ufo1'
				},
				// Jets have their own movement parameters
				jet: {
					speed: 10,
					speedRange: 0,
					arcAmplitude: 0,
					arcFrequency: 0,
					isVertical: false,
					canFlip: true,
					moveSound: 'jet1'
				},
				// Clouds have their own movement parameters
				cloud: {
					speed: 0.25,
					speedRange: 0.55,
					arcAmplitude: 0,
					arcFrequency: 0,
					isVertical: false,
					canFlip: false
				}
			};
			// Select the appropriate movement parameters based on object type
			var params;
			if (type === 'bird1' || type === 'bird2') {
				params = movementParams.bird;
			} else if (type === 'ufo1' || type === 'ufo2') {
				params = movementParams.ufo;
			} else if (type === 'jet1') {
				params = movementParams.jet;
			} else if (type === 'cloud1' || type === 'cloud2') {
				params = movementParams.cloud;
			} else {
				// Default parameters
				params = movementParams.bird;
			}
			// Create movement options with the selected parameters
			var movementOptions = {
				speed: params.speed,
				speedRange: params.speedRange,
				arcAmplitude: params.arcAmplitude,
				arcFrequency: params.arcFrequency,
				isVertical: params.isVertical,
				canFlip: params.canFlip,
				moveSound: rule.sound,
				respawnTime: rule.respawnTime
			};
			obj.movement = new rule.movement(obj, obj.children[0], movementOptions);
		}
		if (rule.respawnTime) {
			this.scheduleRespawn(type, Constructor);
		}
		return obj;
	};
	this.scheduleRespawn = function (type, Constructor) {
		var rule = this.spawnRules[type];
		// Ensure respawn timers for ufo1, ufo2, and jet1 are set to 20-30 seconds
		var respawnTime;
		if (type === 'ufo1' || type === 'ufo2' || type === 'jet1') {
			respawnTime = Math.random() * 10000 + 20000; // 20-30 seconds
		} else if (rule.respawnTime) {
			respawnTime = Math.random() * (rule.respawnTime.max - rule.respawnTime.min) + rule.respawnTime.min;
		} else {
			respawnTime = Math.random() * 10000 + 5000; // Default 5-15 seconds
		}
		if (this.spawnTimers[type]) {
			LK.clearTimeout(this.spawnTimers[type]);
		}
		this.spawnTimers[type] = LK.setTimeout(function () {
			if (this.objectCounts[type] > 0) {
				this.objectCounts[type]--;
			}
			var shouldSpawn = true;
			// Check exclusive groups (e.g., only one UFO type at a time)
			for (var i = 0; i < this.exclusiveGroups.length; i++) {
				var group = this.exclusiveGroups[i];
				if (group.includes(type)) {
					var groupTotal = 0;
					for (var j = 0; j < group.length; j++) {
						groupTotal += this.objectCounts[group[j]];
					}
					if (groupTotal > 0) {
						shouldSpawn = false;
					}
				}
			}
			if (shouldSpawn) {
				this.spawnObject(type, Constructor);
			}
			this.spawnTimers[type] = null;
		}.bind(this), respawnTime);
		this.initialize = function () {
			// Reset object counts
			for (var type in this.objectCounts) {
				this.objectCounts[type] = 0;
			}
			// Initialize birds - exactly 1 Bird1 and 3 Bird2s
			this.spawnObject('bird1', Bird1);
			for (var i = 0; i < this.spawnRules.bird2.min; i++) {
				this.spawnObject('bird2', Bird2);
			}
			// Initialize clouds - ensure 3-5 total clouds
			var totalCloudsToSpawn = Math.floor(Math.random() * 3) + 3;
			var cloud1ToSpawn = Math.min(totalCloudsToSpawn, this.spawnRules.cloud1.max);
			var cloud2ToSpawn = totalCloudsToSpawn - cloud1ToSpawn;
			for (var i = 0; i < cloud1ToSpawn; i++) {
				this.spawnObject('cloud1', Cloud);
			}
			for (var i = 0; i < cloud2ToSpawn; i++) {
				this.spawnObject('cloud2', Cloud);
			}
			// Initialize UFOs and Jet with proper respawn timers
			var ufoType = Math.random() < 0.5 ? 'ufo1' : 'ufo2';
			var UFOConstructor = ufoType === 'ufo1' ? UFO1 : UFO2;
			this.spawnObject(ufoType, UFOConstructor);
			this.spawnObject('jet1', Jet1);
			// Set up periodic check for object counts and layer ordering
			LK.setInterval(function () {
				// Maintain bird counts
				if (this.objectCounts.bird1 < 1) {
					this.spawnObject('bird1', Bird1);
				}
				while (this.objectCounts.bird2 < 3) {
					this.spawnObject('bird2', Bird2);
				}
				// Maintain cloud counts (3-5 total)
				var totalClouds = this.objectCounts.cloud1 + this.objectCounts.cloud2;
				if (totalClouds < 3) {
					var cloudsNeeded = Math.floor(Math.random() * 3) + 3 - totalClouds;
					for (var i = 0; i < cloudsNeeded; i++) {
						this.spawnObject(Math.random() < 0.5 ? 'cloud1' : 'cloud2', Cloud);
					}
				}
				// Check UFO and Jet spawns
				if (this.objectCounts.ufo1 + this.objectCounts.ufo2 === 0) {
					var ufoType = Math.random() < 0.5 ? 'ufo1' : 'ufo2';
					var UFOConstructor = ufoType === 'ufo1' ? UFO1 : UFO2;
					this.scheduleRespawn(ufoType, UFOConstructor);
				}
				if (this.objectCounts.jet1 === 0) {
					this.scheduleRespawn('jet1', Jet1);
				}
				// Update layer ordering
				this.layerOrder.forEach(function (layerId, index) {
					var objects = game.layerManager.getObjectsInLayer(layerId);
					objects.forEach(function (obj) {
						game.layerManager.setLayerIndex(obj, index);
					});
				}.bind(this));
			}.bind(this), 1000);
			// Initialize UFOs and Jet with respawn timers
			// Randomly choose between UFO1 and UFO2
			if (Math.random() < 0.5) {
				this.spawnObject('ufo1', UFO1);
			} else {
				this.spawnObject('ufo2', UFO2);
			}
			this.spawnObject('jet1', Jet1);
			// Set up periodic check for object counts and layer ordering
			LK.setInterval(function () {
				// Update layer ordering
				this.layerOrder.forEach(function (layerId, index) {
					var objects = game.layerManager.getObjectsInLayer(layerId);
					objects.forEach(function (obj) {
						game.layerManager.setLayerIndex(obj, index);
					});
				}.bind(this));
				// Maintain bird counts
				if (this.objectCounts.bird1 < 1) {
					this.spawnObject('bird1', Bird1);
				}
				while (this.objectCounts.bird2 < 3) {
					this.spawnObject('bird2', Bird2);
				}
				// Maintain cloud counts
				var totalClouds = this.objectCounts.cloud1 + this.objectCounts.cloud2;
				if (totalClouds < 3) {
					var cloudsNeeded = 3 - totalClouds;
					for (var i = 0; i < cloudsNeeded; i++) {
						if (Math.random() < 0.5 && this.objectCounts.cloud1 < this.spawnRules.cloud1.max) {
							this.spawnObject('cloud1', Cloud);
						} else if (this.objectCounts.cloud2 < this.spawnRules.cloud2.max) {
							this.spawnObject('cloud2', Cloud);
						}
					}
				}
				// Ensure one UFO (either UFO1 or UFO2) is on screen
				if (this.objectCounts.ufo1 + this.objectCounts.ufo2 === 0 && !this.spawnTimers.ufo1 && !this.spawnTimers.ufo2) {
					if (Math.random() < 0.5) {
						this.spawnObject('ufo1', UFO1);
					} else {
						this.spawnObject('ufo2', UFO2);
					}
				}
				// Ensure one jet is on screen
				if (this.objectCounts.jet1 === 0 && !this.spawnTimers.jet1) {
					this.spawnObject('jet1', Jet1);
				}
			}.bind(this), 1000);
		}.bind(this);
		// Set up periodic check for object counts
		LK.setInterval(function () {
			// Maintain bird counts - exactly 1 Bird1
			if (this.objectCounts.bird1 < 1) {
				this.spawnObject('bird1', Bird1);
			}
			// Maintain bird counts - exactly 3 Bird2s
			while (this.objectCounts.bird2 < 3) {
				this.spawnObject('bird2', Bird2);
			}
			// Maintain cloud counts - ensure 3-5 total clouds
			var totalClouds = this.objectCounts.cloud1 + this.objectCounts.cloud2;
			if (totalClouds < 3) {
				var cloudsNeeded = 3 - totalClouds;
				for (var i = 0; i < cloudsNeeded; i++) {
					if (Math.random() < 0.5 && this.objectCounts.cloud1 < this.spawnRules.cloud1.max) {
						this.spawnObject('cloud1', Cloud);
					} else {
						this.spawnObject('cloud2', Cloud);
					}
				}
			} else if (totalClouds > 5) {
				// If there are more than 5 clouds, don't spawn any more until some are removed
				// This is handled automatically when clouds move off-screen
			}
			// Ensure one UFO (either UFO1 or UFO2) is on screen
			if (this.objectCounts.ufo1 + this.objectCounts.ufo2 < 1 && !this.spawnTimers.ufo1 && !this.spawnTimers.ufo2) {
				if (Math.random() < 0.5) {
					this.spawnObject('ufo1', UFO1);
				} else {
					this.spawnObject('ufo2', UFO2);
				}
			}
			// Ensure one Jet1 is on screen
			if (this.objectCounts.jet1 < 1 && !this.spawnTimers.jet1) {
				this.spawnObject('jet1', Jet1);
			}
		}.bind(this), 1000);
	};
	var spawnManager = new _SpawnManager();
	// Initialize the spawn manager
	_SpawnManager.prototype.initialize = function () {
		// Initialize sound and score managers
		this.soundManager.initialize();
		// Set up initial spawns - exactly 1 Bird1
		this.spawnObject('bird1', Bird1);
		// Set up initial spawns - exactly 3 Bird2s
		for (var i = 0; i < 3; i++) {
			this.spawnObject('bird2', Bird2);
		}
		// Set up cloud spawning - 3-5 total clouds
		var totalClouds = Math.floor(Math.random() * 3) + 3;
		var cloud1Count = Math.min(Math.ceil(totalClouds / 2), this.spawnRules.cloud1.max);
		var cloud2Count = totalClouds - cloud1Count;
		for (var i = 0; i < cloud1Count; i++) {
			this.spawnObject('cloud1', Cloud);
		}
		for (var i = 0; i < cloud2Count; i++) {
			this.spawnObject('cloud2', Cloud);
		}
		// Schedule initial UFO spawn (either UFO1 or UFO2)
		if (Math.random() < 0.5) {
			this.spawnObject('ufo1', UFO1);
		} else {
			this.spawnObject('ufo2', UFO2);
		}
		// Schedule initial Jet1 spawn
		this.spawnObject('jet1', Jet1);
		// Set up periodic checks for maintaining entity counts
		LK.setInterval(function () {
			// Maintain bird counts
			if (this.objectCounts.bird1 < 1) {
				this.spawnObject('bird1', Bird1);
			}
			while (this.objectCounts.bird2 < 3) {
				this.spawnObject('bird2', Bird2);
			}
			// Maintain cloud counts (3-5 total)
			var totalClouds = this.objectCounts.cloud1 + this.objectCounts.cloud2;
			if (totalClouds < 3) {
				var type = Math.random() < 0.5 ? 'cloud1' : 'cloud2';
				this.spawnObject(type, Cloud);
			}
			// Ensure one UFO (either UFO1 or UFO2) is scheduled
			if (this.objectCounts.ufo1 + this.objectCounts.ufo2 === 0 && !this.spawnTimers.ufo1 && !this.spawnTimers.ufo2) {
				var ufoType = Math.random() < 0.5 ? 'ufo1' : 'ufo2';
				this.scheduleRespawn(ufoType, ufoType === 'ufo1' ? UFO1 : UFO2);
			}
			// Ensure one Jet1 is scheduled
			if (this.objectCounts.jet1 === 0 && !this.spawnTimers.jet1) {
				this.scheduleRespawn('jet1', Jet1);
			}
		}.bind(this), 1000);
	};
	spawnManager.initialize();
	// Main game update function
	game.update = function () {
		// Update all game objects
		game.children.forEach(function (entity) {
			if (entity.update) {
				entity.update();
			}
			// Handle off-screen objects
			if (entity instanceof Bird1 || entity instanceof Bird2) {
				if (entity.y > 2732) {
					entity.y = -entity.height;
					entity.x = Math.random() * 2048;
				}
			}
		});
		// Update score display
		if (game.mirror && game.mirror.updateScore) {
			game.mirror.updateScore(game.score || 0);
		}
		// Ensure correct number of birds with sound effects
		var bird1Count = birds.filter(function (b) {
			return b instanceof Bird1;
		}).length;
		var bird2Count = birds.filter(function (b) {
			return b instanceof Bird2;
		}).length;
		// Maintain exactly 1 Bird1
		if (bird1Count < 1) {
			var newBird1 = new Bird1();
			newBird1.x = Math.random() * 2048;
			newBird1.y = -newBird1.height;
			newBird1.speed = Math.random() * 1.6 + 1;
			newBird1.lastIntersecting = false;
			newBird1.type = 'bird1';
			newBird1.color = 0x746130;
			game.addChild(newBird1);
			game.layerManager.addToLayer(newBird1, LAYERS.BIRD1);
			birds.push(newBird1);
			LK.getSound('bird1').play();
		} else if (bird1Count > 1) {
			var extraBird1s = birds.filter(function (b) {
				return b instanceof Bird1;
			}).slice(1);
			extraBird1s.forEach(function (b) {
				b.destroy();
				birds.splice(birds.indexOf(b), 1);
			});
		}
		// Maintain exactly 3 Bird2s
		if (bird2Count < 3) {
			for (var i = 0; i < 3 - bird2Count; i++) {
				var newBird2 = new Bird2();
				newBird2.x = Math.random() < 0.5 ? 0 : 2048;
				newBird2.y = Math.random() * (2732 / 2);
				newBird2.speed = 1 + Math.random() * 0.6;
				newBird2.lastIntersecting = false;
				newBird2.type = 'bird2';
				newBird2.color = 0xFFFFFF;
				game.addChild(newBird2);
				game.layerManager.addToLayer(newBird2, LAYERS.BIRD2);
				birds.push(newBird2);
				LK.getSound('bird2').play();
			}
		} else if (bird2Count > 3) {
			var extraBird2s = birds.filter(function (b) {
				return b instanceof Bird2;
			}).slice(3);
			extraBird2s.forEach(function (b) {
				b.destroy();
				birds.splice(birds.indexOf(b), 1);
			});
		}
		// Update UFOs, jets, and check for collisions
		game.children.forEach(function (entity) {
			if (entity instanceof UFO1 || entity instanceof UFO2) {
				if (!entity.soundPlayed && entity.x > 0 && entity.x < 2048) {
					LK.getSound('ufo1').play();
					entity.soundPlayed = true;
				}
				entity.update();
			}
		});
		// Update each laser and check collisions
		game.children.forEach(function (child) {
			if (child instanceof Laser) {
				child.update();
				// Check for intersections with birds
				game.children.forEach(function (target) {
					if (!child.lastIntersecting && AABBIntersect(child, target)) {
						var points = 0;
						var soundEffect = '';
						if (target instanceof Bird1) {
							points = 100;
							soundEffect = 'dead1';
							spawnManager.objectCounts.bird1--;
						} else if (target instanceof Bird2) {
							points = 50;
							soundEffect = 'dead2';
							spawnManager.objectCounts.bird2--;
						} else if (target instanceof UFO1 || target instanceof UFO2) {
							points = 250;
							soundEffect = 'dead3';
							spawnManager.objectCounts.ufo--;
						}
						if (points > 0) {
							game.score = (game.score || 0) + points;
							if (game.mirror && game.mirror.updateScore) {
								game.mirror.updateScore(game.score);
							}
							LK.getSound(soundEffect).play();
							target.destroy();
							child.destroy();
						}
					}
				});
				// Update lastIntersecting state
				child.lastIntersecting = game.children.some(function (target) {
					return (target instanceof Bird1 || target instanceof Bird2 || target instanceof UFO1 || target instanceof UFO2) && child.intersects(target);
				});
			}
		});
	};
	// Initialize game objects and start spawning
	spawnManager.initialize();
	function spawnBird2() {
		var bird2Count = birds.filter(function (b) {
			return b instanceof Bird2;
		}).length;
		// Fix: Ensure there are always 3 bird2 on screen
		if (bird2Count < 3) {
			var bird2 = new Bird2();
			bird2.x = Math.random() * 2048;
			bird2.y = -bird2.height;
			bird2.speed = Math.random() * 1.6 + 1;
			bird2.lastIntersecting = false;
			bird2.type = 'bird2';
			bird2.color = 0x746130;
			game.addChild(bird2);
			if (game.children.includes(bird2)) {
				game.layerManager.addToLayer(bird2, LAYERS.BIRD2);
				birds.push(bird2);
			}
		}
		LK.setTimeout(spawnBird2, Math.random() * 10000 + 20000);
	}
	// Update bird positions and states
	function updateBirds() {
		// 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
			}
		});
		// Ensure correct number of birds
		var bird1Count = birds.filter(function (b) {
			return b instanceof Bird1;
		}).length;
		var bird2Count = birds.filter(function (b) {
			return b instanceof Bird2;
		}).length;
		// Maintain exactly 1 Bird1
		if (bird1Count < 1) {
			var newBird1 = new Bird1();
			newBird1.x = Math.random() * 2048;
			newBird1.y = Math.random() * (2732 / 2);
			game.addChild(newBird1);
			game.layerManager.addToLayer(newBird1, LAYERS.BIRD1);
			birds.push(newBird1);
		} else if (bird1Count > 1) {
			var extraBird1s = birds.filter(function (b) {
				return b instanceof Bird1;
			}).slice(1);
			extraBird1s.forEach(function (b) {
				b.destroy();
				birds.splice(birds.indexOf(b), 1);
			});
		}
		// Maintain exactly 3 Bird2s
		if (bird2Count < 3) {
			for (var i = 0; i < 3 - bird2Count; i++) {
				var newBird2 = new Bird2();
				newBird2.x = Math.random() * 2048;
				newBird2.y = Math.random() * (2732 / 2);
				game.addChild(newBird2);
				game.layerManager.addToLayer(newBird2, LAYERS.BIRD2);
				birds.push(newBird2);
			}
		} else if (bird2Count > 3) {
			var extraBird2s = birds.filter(function (b) {
				return b instanceof Bird2;
			}).slice(3);
			extraBird2s.forEach(function (b) {
				b.destroy();
				birds.splice(birds.indexOf(b), 1);
			});
		}
		// Update UFOs, jets, and check for collisions
		game.children.forEach(function (entity) {
			if (entity instanceof UFO1 || entity instanceof UFO2) {
				if (!entity.soundPlayed && entity.x > 0 && entity.x < 2048) {
					LK.getSound('ufo1').play();
					entity.soundPlayed = true;
				}
				entity.update();
			}
		});
		// Update each laser and check collisions
		game.children.forEach(function (child) {
			if (child instanceof Laser) {
				child.update();
				// Check for intersections with birds
				game.children.forEach(function (target) {
					if (!child.lastIntersecting && AABBIntersect(child, target)) {
						var points = 0;
						var soundEffect = '';
						if (target instanceof Bird1) {
							points = 100;
							soundEffect = 'dead1';
							spawnManager.objectCounts.bird1--;
						} else if (target instanceof Bird2) {
							points = 50;
							soundEffect = 'dead2';
							spawnManager.objectCounts.bird2--;
						} else if (target instanceof UFO1 || target instanceof UFO2) {
							points = 250;
							soundEffect = 'dead3';
							spawnManager.objectCounts.ufo--;
						}
						if (points > 0) {
							game.score = (game.score || 0) + points;
							if (game.mirror && game.mirror.updateScore) {
								game.mirror.updateScore(game.score);
							}
							LK.getSound(soundEffect).play();
							target.destroy();
							child.destroy();
						}
					}
				});
				// Update lastIntersecting state
				child.lastIntersecting = game.children.some(function (target) {
					return (target instanceof Bird1 || target instanceof Bird2 || target instanceof UFO1 || target instanceof UFO2) && child.intersects(target);
				});
			}
		});
	}
	;
	// 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
	// Add tree to the proper layer
	if (game.children.includes(tree)) {
		game.layerManager.addToLayer(tree, LAYERS.TREE); // Use layer manager to set tree layer
	}
	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
	// Add stack1 to the proper layer
	if (game.children.includes(stack1)) {
		game.layerManager.addToLayer(stack1, LAYERS.STACK); // Use layer manager to set stack layer
	}
	// 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);
	// Add grassBack to the proper layer
	if (game.children.includes(grassBack)) {
		game.layerManager.addToLayer(grassBack, LAYERS.GRASS_BACK); // Use layer manager to set grass-back layer
	}
	var grassFront = new GrassFront();
	grassFront.x = 1020;
	grassFront.y = 2785; // Position grassFront at the bottom, moved down by 50px
	game.addChild(grassFront);
	// Add grassFront to the proper layer
	if (game.children.includes(grassFront)) {
		game.layerManager.addToLayer(grassFront, LAYERS.GRASS_FRONT); // Use layer manager to set grass-front layer
	}
	var scoreDisplay = new Mirror();
	scoreDisplay.x = 2048 / 2 + 400; // Move the score display 400px to the right
	scoreDisplay.y = 2732 - 185 - 80 - 390 + 30 + 50; // Move the score display up by an additional 80px and down by 30px + 50px
	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);
	// Add mirror to the proper layer
	if (game.children.includes(mirror)) {
		game.layerManager.addToLayer(mirror, LAYERS.MIRROR); // Use layer manager to set mirror layer
	}
	// 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
	// Add cat to the proper layer
	if (game.children.includes(cat)) {
		game.layerManager.addToLayer(cat, LAYERS.CAT); // Use layer manager to set cat layer
	}
	// Play bgm1 once on load and set a timer to replay it every 20-30 seconds
	LK.playMusic('bgm1', {
		loop: false,
		fade: {
			start: 0,
			end: 0.1,
			duration: 4000
		},
		onEnd: function onEnd() {
			LK.setTimeout(function () {
				LK.playMusic('bgm1', {
					loop: false,
					fade: {
						start: 0,
						end: 0.1,
						duration: 4000
					},
					onEnd: onEnd
				});
			}, Math.random() * 10000 + 20000);
		}
	});
	// 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 20-30 seconds
	sounds.forEach(function (soundId) {
		var sound = LK.getSound(soundId);
		var ambientSoundTimer = LK.setTimeout(function () {
			if (currentAmbientSound) {
				currentAmbientSound.stop();
			}
			sound.play();
			currentAmbientSound = sound;
			LK.setTimeout(function () {
				currentAmbientSound = null;
			}, sound.duration * 1000);
			ambientSoundTimer = LK.setTimeout(arguments.callee, Math.random() * 10000 + 20000);
		}, Math.random() * 10000 + 20000);
	});
	// Using UFO sound ID as placeholder
	// Using existing CLOUD_TYPES definition
	var Pulse = function Pulse(graphics, options) {
		this.graphics = graphics;
		this.options = Object.assign({
			minScale: 1.0,
			maxScale: 1.2,
			expandDuration: 1000,
			contractDuration: 1000,
			easing: tween.easeInOut
		}, options);
		this.startPulsating = function () {
			function pulsate() {
				tween(this.graphics, {
					scaleX: this.options.maxScale,
					scaleY: this.options.maxScale
				}, {
					duration: this.options.expandDuration,
					easing: this.options.easing,
					onFinish: function () {
						tween(this.graphics, {
							scaleX: this.options.minScale,
							scaleY: this.options.minScale
						}, {
							duration: this.options.contractDuration,
							easing: this.options.easing,
							onFinish: pulsate.bind(this)
						});
					}.bind(this)
				});
			}
			pulsate.call(this);
		};
	};
	var SunPulse = function SunPulse(sunGraphics) {
		return new Pulse(sunGraphics, {
			maxScale: 1.1
		});
	};
	// Light1Pulse class to handle the pulsating effect for Light1
	var Light1Pulse = function Light1Pulse(lightGraphics) {
		return new Pulse(lightGraphics, {
			maxScale: 1.6,
			contractDuration: 1500
		});
	};
	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 = Math.random() * 1.6 + 1;
		this.bird.lastY = this.bird.y;
		this.bird.lastX = this.bird.x;
		this.bird.update = function () {
			this.y += this.speed;
			this.x += Math.sin(this.y / 100) * 6.5;
			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) {
		return new Pulse(reticleGraphics, {
			maxScale: 1.2
		});
	};
	// Bird1Effects class to handle effects and animations for Bird1
	var Bird1Effects = function Bird1Effects(bird) {
		this.bird = bird;
		this.applyEffects = function () {
			// Add any specific effects or animations for Bird1 here
		};
	};
	function spawnBird2() {
		var bird2Count = entityManager.getAllOfType(Bird2).length;
		if (bird2Count < 3) {
			var bird = new Bird2();
			bird.y = Math.random() * (2732 / 2);
			bird.x = Math.random() < 0.5 ? 0 : 2048;
			bird.speed = 1 + Math.random() * 0.6;
			bird.lastIntersecting = false;
			bird.type = 'bird2';
			bird.color = 0xFFFFFF;
			entityManager.add(bird);
			birds.push(bird);
		}
		LK.setTimeout(spawnBird2, Math.random() * 10000 + 20000);
	}
	// 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);
	// Initialize bird spawning
	spawnBird2();
	// ScoreManager class to manage score logic
	var ScoreManager = function ScoreManager() {
		var self = this;
		var currentScore = 0;
		var highScore = storage.highScore || 0;
		self.scoreValues = {
			bird1: 100,
			bird2: 50,
			ufo1: 250,
			ufo2: 250
		};
		self.addScore = function (objectType) {
			var points = self.scoreValues[objectType] || 0;
			if (points > 0) {
				currentScore += points;
				if (currentScore > highScore) {
					highScore = currentScore;
					storage.highScore = highScore;
				}
				// Update score display
				if (scoreDisplay && scoreDisplay.updateScore) {
					scoreDisplay.updateScore(currentScore);
				}
				if (mirror && mirror.updateScore) {
					mirror.updateScore(currentScore);
				}
			}
			return currentScore;
		};
		self.resetScore = function () {
			currentScore = 0;
			if (scoreDisplay && scoreDisplay.updateScore) {
				scoreDisplay.updateScore(currentScore);
			}
			if (mirror && mirror.updateScore) {
				mirror.updateScore(currentScore);
			}
			return currentScore;
		};
		self.getScore = function () {
			return currentScore;
		};
		self.getHighScore = function () {
			return highScore;
		};
	};
	var birds = [];
	game.down = function (x, y, obj) {
		if (obj && obj.event) {
			x = obj.event.x;
			y = obj.event.y;
		}
		if (!game.reticle) {
			game.reticle = game.addChild(new Reticle());
			if (game.children.includes(game.reticle)) {
				game.layerManager.addToLayer(game.reticle, LAYERS.RETICLE);
			}
		}
		game.reticle.x = x;
		game.reticle.y = y;
		if (typeof x === 'undefined' || typeof y === 'undefined') {
			console.error('Invalid coordinates for laser');
			return;
		}
		var laser = new Laser(cat.x - 140, cat.y - 440, x, y);
		game.addChild(laser);
		if (game.children.includes(laser) && game.children.includes(game.reticle)) {
			game.layerManager.addToLayer(laser, LAYERS.LASER);
		}
	};
	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
	// Using existing CLOUD_TYPES definition
	// initializeClouds already called earlier
	var bird1; // Define bird1 variable in the global scope
	var bird; // Define bird variable in the global scope
	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 : bird instanceof Bird2 ? 1 : 0;
							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);
						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 bird positions and states
	function updateBirds() {
		// 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
			}
		});
		// Ensure correct number of birds
		var bird1Count = birds.filter(function (b) {
			return b instanceof Bird1;
		}).length;
		var bird2Count = birds.filter(function (b) {
			return b instanceof Bird2;
		}).length;
		// Maintain exactly 1 Bird1
		if (bird1Count < 1) {
			var newBird1 = new Bird1();
			newBird1.x = Math.random() * 2048;
			newBird1.y = Math.random() * (2732 / 2);
			game.addChild(newBird1);
			game.layerManager.addToLayer(newBird1, LAYERS.BIRD1);
			birds.push(newBird1);
		} else if (bird1Count > 1) {
			var extraBird1s = birds.filter(function (b) {
				return b instanceof Bird1;
			}).slice(1);
			extraBird1s.forEach(function (b) {
				b.destroy();
				birds.splice(birds.indexOf(b), 1);
			});
		}
		// Maintain exactly 3 Bird2s
		if (bird2Count < 3) {
			for (var i = 0; i < 3 - bird2Count; i++) {
				var newBird2 = new Bird2();
				newBird2.x = Math.random() * 2048;
				newBird2.y = Math.random() * (2732 / 2);
				game.addChild(newBird2);
				game.layerManager.addToLayer(newBird2, LAYERS.BIRD2);
				birds.push(newBird2);
			}
		} else if (bird2Count > 3) {
			var extraBird2s = birds.filter(function (b) {
				return b instanceof Bird2;
			}).slice(3);
			extraBird2s.forEach(function (b) {
				b.destroy();
				birds.splice(birds.indexOf(b), 1);
			});
		}
		// Update UFOs, jets, and check for collisions
		game.children.forEach(function (entity) {
			if (entity instanceof UFO1 || entity instanceof UFO2) {
				if (!entity.soundPlayed && entity.x > 0 && entity.x < 2048) {
					LK.getSound('ufo1').play();
					entity.soundPlayed = true;
				}
				entity.update();
			}
		});
		// Update each laser and check collisions
		game.children.forEach(function (child) {
			if (child instanceof Laser) {
				child.update();
				// Check for intersections with birds
				game.children.forEach(function (target) {
					if (!child.lastIntersecting && AABBIntersect(child, target)) {
						var points = 0;
						var soundEffect = '';
						if (target instanceof Bird1) {
							points = 100;
							soundEffect = 'dead1';
							spawnManager.objectCounts.bird1--;
						} else if (target instanceof Bird2) {
							points = 50;
							soundEffect = 'dead2';
							spawnManager.objectCounts.bird2--;
						} else if (target instanceof UFO1 || target instanceof UFO2) {
							points = 250;
							soundEffect = 'dead3';
							spawnManager.objectCounts.ufo--;
						}
						if (points > 0) {
							game.score = (game.score || 0) + points;
							if (game.mirror && game.mirror.updateScore) {
								game.mirror.updateScore(game.score);
							}
							LK.getSound(soundEffect).play();
							target.destroy();
							child.destroy();
						}
					}
				});
				// Update lastIntersecting state
				child.lastIntersecting = game.children.some(function (target) {
					return (target instanceof Bird1 || target instanceof Bird2 || target instanceof UFO1 || target instanceof UFO2) && child.intersects(target);
				});
			}
		});
	}
	;
	// 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
	// Add tree to the proper layer
	if (game.children.includes(tree)) {
		game.layerManager.addToLayer(tree, LAYERS.TREE); // Use layer manager to set tree layer
	}
	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
	// Add stack1 to the proper layer
	if (game.children.includes(stack1)) {
		game.layerManager.addToLayer(stack1, LAYERS.STACK); // Use layer manager to set stack layer
	}
	// 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);
	// Add grassBack to the proper layer
	if (game.children.includes(grassBack)) {
		game.layerManager.addToLayer(grassBack, LAYERS.GRASS_BACK); // Use layer manager to set grass-back layer
	}
	var grassFront = new GrassFront();
	grassFront.x = 1020;
	grassFront.y = 2785; // Position grassFront at the bottom, moved down by 50px
	game.addChild(grassFront);
	// Add grassFront to the proper layer
	if (game.children.includes(grassFront)) {
		game.layerManager.addToLayer(grassFront, LAYERS.GRASS_FRONT); // Use layer manager to set grass-front layer
	}
	var scoreDisplay = new Mirror();
	scoreDisplay.x = 2048 / 2 + 400; // Move the score display 400px to the right
	scoreDisplay.y = 2732 - 185 - 80 - 390 + 30 + 50; // Move the score display up by an additional 80px and down by 30px + 50px
	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);
	// Add mirror to the proper layer using the layer manager
	// Add mirror to the proper layer
	if (game.children.includes(mirror)) {
		game.layerManager.addToLayer(mirror, LAYERS.MIRROR); // Use layer manager to set mirror layer
	}
	// 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
	// Add cat to the proper layer
	if (game.children.includes(cat)) {
		game.layerManager.addToLayer(cat, LAYERS.CAT); // Use layer manager to set cat layer
	}
	// 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 20-30 seconds
	sounds.forEach(function (soundId) {
		var sound = LK.getSound(soundId);
		var ambientSoundTimer = LK.setTimeout(function () {
			if (currentAmbientSound) {
				currentAmbientSound.stop();
			}
			sound.play();
			currentAmbientSound = sound;
			LK.setTimeout(function () {
				currentAmbientSound = null;
			}, sound.duration * 1000);
			ambientSoundTimer = LK.setTimeout(arguments.callee, Math.random() * 10000 + 20000);
		}, Math.random() * 10000 + 20000);
	});
	var EntityManager = /*#__PURE__*/function () {
		function EntityManager() {
			_classCallCheck2(this, EntityManager);
			this.entities = [];
		}
		return _createClass2(EntityManager, [{
			key: "add",
			value: function add(entity) {
				this.entities.push(entity);
				// Add to the game world (e.g., addChild)
				game.addChild(entity);
			}
		}, {
			key: "remove",
			value: function remove(entity) {
				var index = this.entities.indexOf(entity);
				if (index > -1) {
					this.entities.splice(index, 1);
					// Remove from the game world (e.g., destroy)
					entity.destroy();
				}
			}
		}, {
			key: "update",
			value: function update(deltaTime) {
				var _iterator = _createForOfIteratorHelper(this.entities),
					_step;
				try {
					for (_iterator.s(); !(_step = _iterator.n()).done;) {
						var entity = _step.value;
						entity.update(deltaTime);
					}
				} catch (err) {
					_iterator.e(err);
				} finally {
					_iterator.f();
				}
			}
		}, {
			key: "getAllOfType",
			value: function getAllOfType(type) {
				return this.entities.filter(function (entity) {
					return entity instanceof type;
				});
			}
		}, {
			key: "clear",
			value: function clear() {
				this.entities.forEach(function (entity) {
					return entity.destroy();
				});
				this.entities = [];
			}
		}]);
	}(); // Initialize entity managers
	var birdManager = new BirdManager();
	var ufoManager = new UFOManager();
	var jetManager = new JetManager();
	// Update all entity managers
	birdManager.update(deltaTime);
	ufoManager.update(deltaTime);
	jetManager.update(deltaTime);
	// Initial entity spawning will be handled by the managers
	if (typeof x !== 'undefined' && typeof y !== 'undefined') {
		var laser = new Laser(cat.x - 140, cat.y - 440, x, y); // laser starting point
		entityManager.add(laser);
	} else {
		console.error('Invalid coordinates for laser creation');
	}
	// Ensure timers for ambient sounds and bgm1 are set to repeat every 20-30 seconds
	function initializeAmbientSounds() {
		function playAmbientSounds() {
			LK.getSound('songbird1').play();
			LK.getSound('cricket1').play();
			LK.setTimeout(playAmbientSounds, Math.random() * 10000 + 20000); // 20-30 seconds
		}
		playAmbientSounds();
		// Set initial interval
		LK.setInterval(playAmbientSounds, 25000); // Average of 20-30 seconds
	}
	function initializeBGM() {
		function playBGM() {
			LK.playMusic('bgm1');
		}
		playBGM();
		// Set regular interval for background music
		LK.setInterval(playBGM, 25000); // Average of 20-30 seconds
	}
	// Fix scoring
	var scoreManager = new ScoreManager();
	var score = 0;
	game.down = function (x, y, obj) {
		if (obj && obj.event) {
			x = obj.event.x;
			y = obj.event.y;
		}
		if (!game.reticle) {
			game.reticle = game.addChild(new Reticle());
			if (game.children.includes(game.reticle)) {
				game.layerManager.addToLayer(game.reticle, LAYERS.RETICLE);
			}
		}
		game.reticle.x = x;
		game.reticle.y = y;
		if (typeof x === 'undefined' || typeof y === 'undefined') {
			console.error('Invalid coordinates for laser');
			return;
		}
		var laser = new Laser(cat.x - 140, cat.y - 440, x, y);
		game.addChild(laser);
		if (game.children.includes(laser) && game.children.includes(game.reticle)) {
			game.layerManager.addToLayer(laser, LAYERS.LASER);
		}
	};
	// Adjust layer display order
	// Ensure light1 layer is displayed after background
	if (light1) {
		game.layerManager.addToLayer(light1, LAYERS.LIGHT1);
	}
	// Ensure jet layer is displayed before cloud2 layer
	if (jet) {
		game.layerManager.addToLayer(jet, LAYERS.JET1);
	}
	// Ensure mirror layer is displayed behind grass-front
	if (mirror) {
		game.layerManager.addToLayer(mirror, LAYERS.MIRROR);
	}
	// Ensure jet1 and ufo1 sounds play when on screen
	Jet1.prototype.update = function () {
		// Fix: Use 'this' instead of 'self' since this is a prototype method
		var jetGraphics = this.children[0];
		flipImageVerticallyBasedOnDirection(jetGraphics, this.lastX, this.x);
		this.x += this.speed * this.direction;
		// Play jet sound when on screen
		if (!this.soundPlayed && this.x > 0 && this.x < 2048) {
			LK.getSound('jet1').play();
			this.soundPlayed = true;
		}
		// Stop sound and destroy when off screen
		if (this.lastX <= 2048 + this.width / 2 && this.x > 2048 + this.width / 2 || this.lastX >= -this.width / 2 && this.x < -this.width / 2) {
			LK.getSound('jet1').stop();
			this.destroy();
			game.jet = null;
			// Set respawn timer to 20-30 seconds
			var respawnTime = Math.random() * 10000 + 20000;
			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.layerManager.addToLayer(jet, LAYERS.JET1);
				game.jet = jet;
				game.jetSpawnTimer = null;
			}, respawnTime);
		}
		this.lastX = this.x;
	};
	UFOMovement.prototype.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();
			game.ufo = null;
			scheduleUFOSpawn(Math.random() * 10000 + 20000);
		}
		this.lastX = this.x;
	};
};

===================================================================
--- original.js
+++ change.js
@@ -135,9 +135,9 @@
 		anchorX: 0.5,
 		anchorY: 0.5,
 		flipX: 1
 	});
-	game.layerManager.addToLayer(self, LAYERS.JET1);
+	self.type = 'jet1';
 	self.speed = 10;
 	self.direction = Math.random() < 0.5 ? 1 : -1;
 	self.lastX = self.x;
 	self.soundPlayed = false;
@@ -148,29 +148,37 @@
 		// Remove from layer tracking before destroying
 		if (game.layerManager) {
 			game.layerManager.removeFromTracking(self);
 		}
+		// Stop sound when destroyed
+		LK.getSound('jet1').stop();
 		// Call the original destroy method
 		originalDestroy.call(self);
 	};
 	self.update = function () {
 		flipImageVerticallyBasedOnDirection(jetGraphics, self.lastX, self.x);
 		self.x += self.speed * self.direction;
+		// Play jet1 sound when on screen
 		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) {
+			if (game.jetSpawnTimer) {
+				LK.clearTimeout(game.jetSpawnTimer);
+			}
 			self.destroy();
 			game.jet = null;
 			var respawnTime = Math.random() * 10000 + 20000;
 			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.layerManager.addToLayer(jet, LAYERS.JET1);
-				game.jet = jet;
+				if (game.jet === null) {
+					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.layerManager.addToLayer(jet, LAYERS.JET1);
+					game.jet = jet;
+				}
 				game.jetSpawnTimer = null;
 			}, respawnTime);
 		}
 		self.lastX = self.x;
@@ -192,61 +200,39 @@
 	self.vy = dy / distance * speed;
 	self.x = startX;
 	self.y = startY;
 	self.lastIntersecting = false;
+	self.active = true;
 	var originalDestroy = self.destroy;
 	self.destroy = function () {
 		if (game.layerManager) {
 			game.layerManager.removeFromTracking(self);
 		}
 		originalDestroy.call(self);
 	};
 	self.update = function () {
+		if (!self.active) {
+			return;
+		}
 		game.children.forEach(function (child) {
 			if (!self.lastIntersecting && (child instanceof Bird1 || child instanceof Bird2 || child instanceof UFO1 || child instanceof UFO2) && self.intersects(child)) {
-				var points = 0;
-				var soundEffect = '';
-				if (child instanceof Bird1) {
-					points = 100;
-					soundEffect = 'dead2';
-					if (spawnManager) {
-						spawnManager.objectCounts.bird1--;
-					}
-				} else if (child instanceof Bird2) {
-					points = 50;
-					soundEffect = 'dead2';
-					if (spawnManager) {
-						spawnManager.objectCounts.bird2--;
-					}
-				} else if (child instanceof UFO1) {
-					points = 250;
-					soundEffect = 'dead3';
-					if (spawnManager) {
-						spawnManager.objectCounts.ufo1--;
-					}
-				} else if (child instanceof UFO2) {
-					points = 250;
-					soundEffect = 'dead3';
-					if (spawnManager) {
-						spawnManager.objectCounts.ufo2--;
-					}
+				var soundEffect = child instanceof UFO1 || child instanceof UFO2 ? 'dead3' : 'dead2';
+				// Update score and object counts through spawn manager
+				if (spawnManager) {
+					spawnManager.objectCounts[child.type]--;
+					spawnManager.scoreManager.addScore(child.type);
+					spawnManager.scheduleRespawn(child.type, child.constructor);
 				}
-				if (points > 0) {
-					// Update the global score
-					game.score = (game.score || 0) + points;
-					// Update score display
-					if (scoreDisplay && scoreDisplay.updateScore) {
-						scoreDisplay.updateScore(game.score);
-					}
-					if (mirror && mirror.updateScore) {
-						mirror.updateScore(game.score);
-					}
-					// Play sound effect and destroy objects
-					LK.getSound(soundEffect).play();
-					child.destroy();
-					self.destroy();
-					return;
+				// Play sound effect and destroy objects
+				LK.getSound(soundEffect).play();
+				child.destroy();
+				self.active = false;
+				self.destroy();
+				// Update score display
+				if (mirror && mirror.updateScore) {
+					mirror.updateScore(spawnManager.scoreManager.getScore());
 				}
+				return;
 			}
 		});
 		self.x += self.vx;
 		self.y += self.vy;
@@ -264,11 +250,25 @@
 var Light1 = Container.expand(function () {
 	var self = Container.call(this);
 	var lightGraphics = self.attachAsset('light1', {
 		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	self.addChild(lightGraphics);
+	game.layerManager.addToLayer(self, LAYERS.LIGHT1);
+	var originalDestroy = self.destroy;
+	self.destroy = function () {
+		if (game.layerManager) {
+			game.layerManager.removeFromTracking(self);
+		}
+		originalDestroy.call(self);
+	};
+	var lightGraphics = self.attachAsset('light1', {
+		anchorX: 0.5,
 		anchorY: 0.5,
 		alpha: 1.0
 	});
+	self.addChild(lightGraphics);
 	self.x = 450;
 	self.y = 450;
 	self.update = function () {
 		self.x += Math.sin(LK.ticks / 90) * 0.1;
@@ -397,19 +397,32 @@
 	var ufo1Graphics = self.attachAsset('ufo1', {
 		anchorX: 0.5,
 		anchorY: 0.5
 	});
+	self.type = 'ufo1';
+	self.soundPlayed = false;
 	self.movement = new UFOMovement(self, ufo1Graphics);
 	// Override destroy method to remove from layer tracking
 	var originalDestroy = self.destroy;
 	self.destroy = function () {
 		// Remove from layer tracking before destroying
 		if (game.layerManager) {
 			game.layerManager.removeFromTracking(self);
 		}
+		// Stop sound when destroyed
+		LK.getSound('ufo1').stop();
 		// Call the original destroy method
 		originalDestroy.call(self);
 	};
+	self.update = function () {
+		if (!self.soundPlayed && self.x > 0 && self.x < 2048) {
+			LK.getSound('ufo1').play();
+			self.soundPlayed = true;
+		}
+		if (self.movement) {
+			self.movement.update();
+		}
+	};
 	// Set the layer index for ufo1
 	game.layerManager.addToLayer(self, LAYERS.UFO1);
 });
 var UFO2 = Container.expand(function () {
@@ -443,43 +456,10 @@
 
 /**** 
 * Game Code
 ****/ 
-// CloudMovement class to handle cloud movement and fade effects
 // Define cloud types at the beginning
-var EntityManager = function EntityManager() {
-	this.entities = [];
-	this.add = function (entity) {
-		this.entities.push(entity);
-		game.addChild(entity);
-	};
-	this.remove = function (entity) {
-		var index = this.entities.indexOf(entity);
-		if (index > -1) {
-			this.entities.splice(index, 1);
-			entity.destroy();
-		}
-	};
-	this.update = function () {
-		this.entities.forEach(function (entity) {
-			if (entity.update) {
-				entity.update();
-			}
-		});
-	};
-	this.getAllOfType = function (type) {
-		return this.entities.filter(function (entity) {
-			return entity instanceof type;
-		});
-	};
-	this.clear = function () {
-		this.entities.forEach(function (entity) {
-			entity.destroy();
-		});
-		this.entities = [];
-	};
-};
-var entityManager = new EntityManager();
+// CloudMovement class to handle cloud movement and fade effects
 function _typeof2(o) {
 	"@babel/helpers - typeof";
 	return _typeof2 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
 		return typeof o;
@@ -591,10 +571,10 @@
 var GameObjectMovement = function GameObjectMovement(object, graphics, options) {
 	this.object = object;
 	this.graphics = graphics;
 	this.options = Object.assign({
-		speed: 1,
-		speedRange: 0.6,
+		speed: 2,
+		speedRange: 1.2,
 		arcAmplitude: 6.5,
 		arcFrequency: 100,
 		isVertical: false,
 		canFlip: true,
@@ -608,8 +588,9 @@
 	this.direction = Math.random() < 0.5 ? 1 : -1;
 	this.lastX = this.object.x;
 	this.lastY = this.object.y;
 	this.soundPlayed = false;
+	this.soundTimer = null;
 	this.update = function () {
 		var currentX = this.object.x;
 		var currentY = this.object.y;
 		var screenWidth = 2048;
@@ -618,25 +599,39 @@
 		if (this.options.isVertical) {
 			this.object.y += this.speed;
 			this.object.x += Math.sin(this.object.y / this.options.arcFrequency) * this.options.arcAmplitude;
 			if (currentY > screenHeight + this.object.height) {
-				this.object.y = -this.object.height;
-				this.object.x = Math.random() * screenWidth;
+				this.object.destroy();
+				if (spawnManager) {
+					spawnManager.scheduleRespawn(this.object.type, this.object.constructor);
+				}
+				return;
 			}
 		} else {
 			this.object.x += this.speed * this.direction;
-			if (this.object.x > screenWidth + halfWidth) {
-				this.object.x = -halfWidth;
-			} else if (this.object.x < -halfWidth) {
-				this.object.x = screenWidth + halfWidth;
+			if (currentX <= screenWidth + halfWidth && this.object.x > screenWidth + halfWidth || currentX >= -halfWidth && this.object.x < -halfWidth) {
+				this.object.destroy();
+				if (spawnManager) {
+					spawnManager.scheduleRespawn(this.object.type, this.object.constructor);
+				}
+				return;
 			}
 		}
 		if (this.options.canFlip) {
 			flipImageVerticallyBasedOnDirection(this.graphics, currentX, this.object.x);
 		}
 		if (this.options.moveSound && !this.soundPlayed && this.object.x > 0 && this.object.x < screenWidth) {
-			LK.getSound(this.options.moveSound).play();
+			if (this.soundTimer) {
+				LK.clearTimeout(this.soundTimer);
+			}
+			var sound = LK.getSound(this.options.moveSound);
+			sound.volume = 0.1;
+			sound.play();
 			this.soundPlayed = true;
+			this.soundTimer = LK.setTimeout(function () {
+				this.soundPlayed = false;
+				this.soundTimer = null;
+			}.bind(this), Math.random() * (30000 - 20000) + 20000);
 		}
 		this.lastX = this.object.x;
 		this.lastY = this.object.y;
 	}.bind(this);
@@ -1072,21 +1067,42 @@
 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;
+	self.scoreValues = {
+		bird1: 5,
+		// Fix: bird1 should be worth 5 points
+		bird2: 1,
+		// Fix: bird2 should be worth 1 point
+		ufo1: 25,
+		ufo2: 25 // Fix: match the value in spawnRules
+	};
+	self.addScore = function (objectType) {
+		var points = self.scoreValues[objectType] || 0;
+		if (points > 0) {
+			currentScore += points;
+			if (currentScore > highScore) {
+				highScore = currentScore;
+				storage.highScore = highScore;
+			}
+			// Update score display
+			if (scoreDisplay && scoreDisplay.updateScore) {
+				scoreDisplay.updateScore(currentScore);
+			}
+			if (mirror && mirror.updateScore) {
+				mirror.updateScore(currentScore);
+			}
 		}
-		currentScore += Math.floor(points);
-		if (currentScore > highScore) {
-			highScore = currentScore;
-			storage.highScore = highScore;
-		}
 		return currentScore;
 	};
 	self.resetScore = function () {
 		currentScore = 0;
+		if (scoreDisplay && scoreDisplay.updateScore) {
+			scoreDisplay.updateScore(currentScore);
+		}
+		if (mirror && mirror.updateScore) {
+			mirror.updateScore(currentScore);
+		}
 		return currentScore;
 	};
 	self.getScore = function () {
 		return currentScore;
@@ -1187,15 +1203,19 @@
 initializeClouds();
 var bird1; // Define bird1 variable in the global scope
 var bird; // Define bird variable in the global scope
 // Initialize birds and score
-var birds = [];
-var score = 0;
+// Initialize game objects and managers
+var spawnManager = new _SpawnManager();
+var scoreManager = new ScoreManager();
+// Initialize mirror for score display
 var mirror = new Mirror();
 mirror.x = 2048 / 2 + 400;
 mirror.y = 2732 - 185 - 80 - 390 + 30 + 50;
 game.addChild(mirror);
 game.mirror = mirror;
+game.layerManager.addToLayer(mirror, LAYERS.MIRROR);
+// Set up score display
 var scoreDisplay = mirror;
 scoreDisplay.x = 2048 / 2 + 400;
 scoreDisplay.y = 2732 - 185 - 80 - 390 + 30 + 50;
 var SoundManager = function SoundManager() {
@@ -1207,15 +1227,25 @@
 		},
 		background: {
 			min: 20000,
 			max: 30000
+		},
+		ufo: {
+			min: 20000,
+			max: 30000
+		},
+		jet: {
+			min: 20000,
+			max: 30000
 		}
 	};
 	this.playSound = function (soundId, options) {
 		options = Object.assign({
 			interval: this.soundIntervals.ambient,
 			isMusic: false,
-			volume: 0.1
+			volume: 0.1,
+			loop: false,
+			autoRestart: true
 		}, options);
 		var playFunction = function () {
 			if (options.isMusic) {
 				LK.playMusic(soundId, {
@@ -1223,12 +1253,17 @@
 				});
 			} else {
 				var sound = LK.getSound(soundId);
 				sound.volume = options.volume;
+				if (options.loop) {
+					sound.loop = true;
+				}
 				sound.play();
 			}
-			var nextInterval = Math.random() * (options.interval.max - options.interval.min) + options.interval.min;
-			this.soundTimers[soundId] = LK.setTimeout(playFunction.bind(this), nextInterval);
+			if (options.autoRestart) {
+				var nextInterval = Math.random() * (options.interval.max - options.interval.min) + options.interval.min;
+				this.soundTimers[soundId] = LK.setTimeout(playFunction.bind(this), nextInterval);
+			}
 		}.bind(this);
 		playFunction();
 		return this.soundTimers[soundId];
 	};
@@ -1268,37 +1303,13 @@
 			this.stopSound(soundId);
 		}
 	};
 };
-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 = Math.random() * 1.6 + 1;
-		bird1.lastIntersecting = false;
-		bird1.type = 'bird1';
-		bird1.color = 0x746130;
-		game.addChild(bird1);
-		if (game.children.includes(bird1)) {
-			game.layerManager.addToLayer(bird1, LAYERS.BIRD1);
-			birds.push(bird1);
-		}
-	}
-	LK.setTimeout(spawnBird1, Math.random() * 10000 + 20000);
-}
+// Initialize game objects and start spawning
+spawnManager.initialize();
+// Initialize sound system
 var soundManager = new SoundManager();
 soundManager.initialize();
-// Start the game
-initializeBGM();
-initializeAmbientSounds();
-// Ensure game objects are initialized before spawning birds
-LK.setTimeout(function () {
-	spawnBird1();
-	spawnBird2();
-});
 var _SpawnManager = function SpawnManager() {
 	this.spawnTimers = {};
 	this.objectCounts = {
 		bird1: 0,
@@ -1311,57 +1322,101 @@
 	};
 	this.spawnRules = {
 		bird1: {
 			max: 1,
-			layer: LAYERS.BIRD1
+			layer: LAYERS.BIRD1,
+			movement: Bird1Movement,
+			scoreValue: 5,
+			respawnTime: {
+				min: 5000,
+				max: 10000
+			}
 		},
 		bird2: {
 			min: 3,
 			max: 3,
-			layer: LAYERS.BIRD2
+			layer: LAYERS.BIRD2,
+			movement: Bird2Movement,
+			scoreValue: 1,
+			respawnTime: {
+				min: 5000,
+				max: 10000
+			}
 		},
 		cloud1: {
-			min: 2,
+			min: 1,
 			max: 3,
-			layer: LAYERS.CLOUD1
+			layer: LAYERS.CLOUD1,
+			movement: CloudMovement,
+			respawnTime: {
+				min: 5000,
+				max: 10000
+			}
 		},
 		cloud2: {
 			min: 1,
-			max: 2,
-			layer: LAYERS.CLOUD2
+			max: 3,
+			layer: LAYERS.CLOUD2,
+			movement: CloudMovement,
+			respawnTime: {
+				min: 5000,
+				max: 10000
+			}
 		},
 		ufo1: {
 			max: 1,
 			respawnTime: {
 				min: 20000,
 				max: 30000
 			},
-			layer: LAYERS.UFO1
+			layer: LAYERS.UFO1,
+			movement: UFOMovement,
+			sound: 'ufo1',
+			scoreValue: 25
 		},
 		ufo2: {
 			max: 1,
 			respawnTime: {
 				min: 20000,
 				max: 30000
 			},
-			layer: LAYERS.UFO2
+			layer: LAYERS.UFO2,
+			movement: UFOMovement,
+			sound: 'ufo1',
+			scoreValue: 25
 		},
 		jet1: {
 			max: 1,
 			respawnTime: {
 				min: 20000,
 				max: 30000
 			},
-			layer: LAYERS.JET1
+			layer: LAYERS.JET1,
+			movement: GameObjectMovement,
+			sound: 'jet1'
 		}
 	};
+	this.soundManager = new SoundManager();
+	this.scoreManager = new ScoreManager();
 	this.exclusiveGroups = [['ufo1', 'ufo2']];
+	// Layer order matching LAYERS constant
+	this.layerOrder = [LAYERS.BACKGROUND, LAYERS.SUN, LAYERS.LIGHT1, LAYERS.UFO2, LAYERS.CLOUD1, LAYERS.JET1, LAYERS.CLOUD2, LAYERS.UFO1, LAYERS.BIRD1, LAYERS.GRASS_BACK, LAYERS.TREE, LAYERS.STACK, LAYERS.BIRD2, LAYERS.MIRROR, LAYERS.GRASS_FRONT, LAYERS.CAT, LAYERS.LASER, LAYERS.RETICLE];
 	this.spawnObject = function (type, Constructor, options) {
 		var rule = this.spawnRules[type];
 		var count = this.objectCounts[type];
+		// Check if we've reached the maximum count for this type
 		if (count >= (rule.max || 1)) {
 			return;
 		}
+		// Check if we need to maintain a minimum count
+		if (rule.min && count < rule.min) {
+			while (count < rule.min) {
+				this.createObject(type, Constructor, rule);
+				count++;
+			}
+			return;
+		}
+		// Check exclusive groups (e.g., only one UFO type at a time)
 		for (var i = 0; i < this.exclusiveGroups.length; i++) {
 			var group = this.exclusiveGroups[i];
 			if (group.includes(type)) {
 				var groupTotal = 0;
@@ -1372,9 +1427,21 @@
 					return;
 				}
 			}
 		}
+		// Check total cloud count to ensure 3-5 clouds
+		if (type === 'cloud1' || type === 'cloud2') {
+			var totalClouds = this.objectCounts.cloud1 + this.objectCounts.cloud2;
+			if (totalClouds >= 5) {
+				return;
+			} // Don't spawn more if we already have 5
+		}
+		this.createObject(type, Constructor, rule);
+	};
+	this.createObject = function (type, Constructor, rule) {
 		var obj = new Constructor();
+		obj.type = type;
+		// Position the object based on its type
 		if (type === 'bird1' || type === 'bird2') {
 			obj.x = Math.random() * 2048;
 			obj.y = -obj.height;
 		} else {
@@ -1383,69 +1450,230 @@
 		}
 		game.addChild(obj);
 		game.layerManager.addToLayer(obj, rule.layer);
 		this.objectCounts[type]++;
-		if (type === 'ufo1' || type === 'ufo2') {
-			LK.getSound('ufo1').play();
-			obj.soundPlayed = true;
-		} else if (type === 'jet1') {
-			LK.getSound('jet1').play();
-			obj.soundPlayed = true;
+		// Initialize movement with appropriate options
+		if (rule.movement) {
+			// Define common movement parameters by object type
+			var movementParams = {
+				// Birds share the same movement parameters
+				bird: {
+					speed: 2,
+					speedRange: 1.6,
+					arcAmplitude: 6.5,
+					arcFrequency: 100,
+					isVertical: true,
+					canFlip: true,
+					moveSound: 'wings1'
+				},
+				// UFOs share the same movement parameters
+				ufo: {
+					speed: 3.2,
+					speedRange: 0.8,
+					arcAmplitude: 4.5,
+					arcFrequency: 80,
+					isVertical: false,
+					canFlip: true,
+					moveSound: 'ufo1'
+				},
+				// Jets have their own movement parameters
+				jet: {
+					speed: 10,
+					speedRange: 0,
+					arcAmplitude: 0,
+					arcFrequency: 0,
+					isVertical: false,
+					canFlip: true,
+					moveSound: 'jet1'
+				},
+				// Clouds have their own movement parameters
+				cloud: {
+					speed: 0.25,
+					speedRange: 0.55,
+					arcAmplitude: 0,
+					arcFrequency: 0,
+					isVertical: false,
+					canFlip: false
+				}
+			};
+			// Select the appropriate movement parameters based on object type
+			var params;
+			if (type === 'bird1' || type === 'bird2') {
+				params = movementParams.bird;
+			} else if (type === 'ufo1' || type === 'ufo2') {
+				params = movementParams.ufo;
+			} else if (type === 'jet1') {
+				params = movementParams.jet;
+			} else if (type === 'cloud1' || type === 'cloud2') {
+				params = movementParams.cloud;
+			} else {
+				// Default parameters
+				params = movementParams.bird;
+			}
+			// Create movement options with the selected parameters
+			var movementOptions = {
+				speed: params.speed,
+				speedRange: params.speedRange,
+				arcAmplitude: params.arcAmplitude,
+				arcFrequency: params.arcFrequency,
+				isVertical: params.isVertical,
+				canFlip: params.canFlip,
+				moveSound: rule.sound,
+				respawnTime: rule.respawnTime
+			};
+			obj.movement = new rule.movement(obj, obj.children[0], movementOptions);
 		}
 		if (rule.respawnTime) {
 			this.scheduleRespawn(type, Constructor);
 		}
 		return obj;
 	};
 	this.scheduleRespawn = function (type, Constructor) {
 		var rule = this.spawnRules[type];
-		var respawnTime = Math.random() * (rule.respawnTime.max - rule.respawnTime.min) + rule.respawnTime.min;
+		// Ensure respawn timers for ufo1, ufo2, and jet1 are set to 20-30 seconds
+		var respawnTime;
+		if (type === 'ufo1' || type === 'ufo2' || type === 'jet1') {
+			respawnTime = Math.random() * 10000 + 20000; // 20-30 seconds
+		} else if (rule.respawnTime) {
+			respawnTime = Math.random() * (rule.respawnTime.max - rule.respawnTime.min) + rule.respawnTime.min;
+		} else {
+			respawnTime = Math.random() * 10000 + 5000; // Default 5-15 seconds
+		}
 		if (this.spawnTimers[type]) {
 			LK.clearTimeout(this.spawnTimers[type]);
 		}
 		this.spawnTimers[type] = LK.setTimeout(function () {
 			if (this.objectCounts[type] > 0) {
 				this.objectCounts[type]--;
 			}
 			var shouldSpawn = true;
+			// Check exclusive groups (e.g., only one UFO type at a time)
 			for (var i = 0; i < this.exclusiveGroups.length; i++) {
 				var group = this.exclusiveGroups[i];
 				if (group.includes(type)) {
 					var groupTotal = 0;
 					for (var j = 0; j < group.length; j++) {
 						groupTotal += this.objectCounts[group[j]];
 					}
+					if (groupTotal > 0) {
+						shouldSpawn = false;
+					}
 				}
 			}
 			if (shouldSpawn) {
 				this.spawnObject(type, Constructor);
 			}
+			this.spawnTimers[type] = null;
 		}.bind(this), respawnTime);
-	};
-	this.initialize = function () {
-		// Initialize birds - exactly 1 Bird1 and 3 Bird2s
-		this.spawnObject('bird1', Bird1);
-		for (var i = 0; i < this.spawnRules.bird2.min; i++) {
-			this.spawnObject('bird2', Bird2);
-		}
-		// Initialize clouds - ensure 3-5 total clouds
-		var totalCloudsToSpawn = Math.floor(Math.random() * 3) + 3; // Random between 3-5
-		var cloud1ToSpawn = Math.min(totalCloudsToSpawn, this.spawnRules.cloud1.max);
-		var cloud2ToSpawn = totalCloudsToSpawn - cloud1ToSpawn;
-		for (var i = 0; i < cloud1ToSpawn; i++) {
-			this.spawnObject('cloud1', Cloud);
-		}
-		for (var i = 0; i < cloud2ToSpawn; i++) {
-			this.spawnObject('cloud2', Cloud);
-		}
-		// Initialize UFOs and Jet with respawn timers
-		// Randomly choose between UFO1 and UFO2
-		if (Math.random() < 0.5) {
-			this.spawnObject('ufo1', UFO1);
-		} else {
-			this.spawnObject('ufo2', UFO2);
-		}
-		this.spawnObject('jet1', Jet1);
+		this.initialize = function () {
+			// Reset object counts
+			for (var type in this.objectCounts) {
+				this.objectCounts[type] = 0;
+			}
+			// Initialize birds - exactly 1 Bird1 and 3 Bird2s
+			this.spawnObject('bird1', Bird1);
+			for (var i = 0; i < this.spawnRules.bird2.min; i++) {
+				this.spawnObject('bird2', Bird2);
+			}
+			// Initialize clouds - ensure 3-5 total clouds
+			var totalCloudsToSpawn = Math.floor(Math.random() * 3) + 3;
+			var cloud1ToSpawn = Math.min(totalCloudsToSpawn, this.spawnRules.cloud1.max);
+			var cloud2ToSpawn = totalCloudsToSpawn - cloud1ToSpawn;
+			for (var i = 0; i < cloud1ToSpawn; i++) {
+				this.spawnObject('cloud1', Cloud);
+			}
+			for (var i = 0; i < cloud2ToSpawn; i++) {
+				this.spawnObject('cloud2', Cloud);
+			}
+			// Initialize UFOs and Jet with proper respawn timers
+			var ufoType = Math.random() < 0.5 ? 'ufo1' : 'ufo2';
+			var UFOConstructor = ufoType === 'ufo1' ? UFO1 : UFO2;
+			this.spawnObject(ufoType, UFOConstructor);
+			this.spawnObject('jet1', Jet1);
+			// Set up periodic check for object counts and layer ordering
+			LK.setInterval(function () {
+				// Maintain bird counts
+				if (this.objectCounts.bird1 < 1) {
+					this.spawnObject('bird1', Bird1);
+				}
+				while (this.objectCounts.bird2 < 3) {
+					this.spawnObject('bird2', Bird2);
+				}
+				// Maintain cloud counts (3-5 total)
+				var totalClouds = this.objectCounts.cloud1 + this.objectCounts.cloud2;
+				if (totalClouds < 3) {
+					var cloudsNeeded = Math.floor(Math.random() * 3) + 3 - totalClouds;
+					for (var i = 0; i < cloudsNeeded; i++) {
+						this.spawnObject(Math.random() < 0.5 ? 'cloud1' : 'cloud2', Cloud);
+					}
+				}
+				// Check UFO and Jet spawns
+				if (this.objectCounts.ufo1 + this.objectCounts.ufo2 === 0) {
+					var ufoType = Math.random() < 0.5 ? 'ufo1' : 'ufo2';
+					var UFOConstructor = ufoType === 'ufo1' ? UFO1 : UFO2;
+					this.scheduleRespawn(ufoType, UFOConstructor);
+				}
+				if (this.objectCounts.jet1 === 0) {
+					this.scheduleRespawn('jet1', Jet1);
+				}
+				// Update layer ordering
+				this.layerOrder.forEach(function (layerId, index) {
+					var objects = game.layerManager.getObjectsInLayer(layerId);
+					objects.forEach(function (obj) {
+						game.layerManager.setLayerIndex(obj, index);
+					});
+				}.bind(this));
+			}.bind(this), 1000);
+			// Initialize UFOs and Jet with respawn timers
+			// Randomly choose between UFO1 and UFO2
+			if (Math.random() < 0.5) {
+				this.spawnObject('ufo1', UFO1);
+			} else {
+				this.spawnObject('ufo2', UFO2);
+			}
+			this.spawnObject('jet1', Jet1);
+			// Set up periodic check for object counts and layer ordering
+			LK.setInterval(function () {
+				// Update layer ordering
+				this.layerOrder.forEach(function (layerId, index) {
+					var objects = game.layerManager.getObjectsInLayer(layerId);
+					objects.forEach(function (obj) {
+						game.layerManager.setLayerIndex(obj, index);
+					});
+				}.bind(this));
+				// Maintain bird counts
+				if (this.objectCounts.bird1 < 1) {
+					this.spawnObject('bird1', Bird1);
+				}
+				while (this.objectCounts.bird2 < 3) {
+					this.spawnObject('bird2', Bird2);
+				}
+				// Maintain cloud counts
+				var totalClouds = this.objectCounts.cloud1 + this.objectCounts.cloud2;
+				if (totalClouds < 3) {
+					var cloudsNeeded = 3 - totalClouds;
+					for (var i = 0; i < cloudsNeeded; i++) {
+						if (Math.random() < 0.5 && this.objectCounts.cloud1 < this.spawnRules.cloud1.max) {
+							this.spawnObject('cloud1', Cloud);
+						} else if (this.objectCounts.cloud2 < this.spawnRules.cloud2.max) {
+							this.spawnObject('cloud2', Cloud);
+						}
+					}
+				}
+				// Ensure one UFO (either UFO1 or UFO2) is on screen
+				if (this.objectCounts.ufo1 + this.objectCounts.ufo2 === 0 && !this.spawnTimers.ufo1 && !this.spawnTimers.ufo2) {
+					if (Math.random() < 0.5) {
+						this.spawnObject('ufo1', UFO1);
+					} else {
+						this.spawnObject('ufo2', UFO2);
+					}
+				}
+				// Ensure one jet is on screen
+				if (this.objectCounts.jet1 === 0 && !this.spawnTimers.jet1) {
+					this.spawnObject('jet1', Jet1);
+				}
+			}.bind(this), 1000);
+		}.bind(this);
 		// Set up periodic check for object counts
 		LK.setInterval(function () {
 			// Maintain bird counts - exactly 1 Bird1
 			if (this.objectCounts.bird1 < 1) {
@@ -1486,23 +1714,59 @@
 	};
 	var spawnManager = new _SpawnManager();
 	// Initialize the spawn manager
 	_SpawnManager.prototype.initialize = function () {
-		// Set up initial spawns
+		// Initialize sound and score managers
+		this.soundManager.initialize();
+		// Set up initial spawns - exactly 1 Bird1
 		this.spawnObject('bird1', Bird1);
+		// Set up initial spawns - exactly 3 Bird2s
 		for (var i = 0; i < 3; i++) {
 			this.spawnObject('bird2', Bird2);
 		}
-		// Set up cloud spawning
-		for (var i = 0; i < 3; i++) {
+		// Set up cloud spawning - 3-5 total clouds
+		var totalClouds = Math.floor(Math.random() * 3) + 3;
+		var cloud1Count = Math.min(Math.ceil(totalClouds / 2), this.spawnRules.cloud1.max);
+		var cloud2Count = totalClouds - cloud1Count;
+		for (var i = 0; i < cloud1Count; i++) {
 			this.spawnObject('cloud1', Cloud);
 		}
-		for (var i = 0; i < 2; i++) {
+		for (var i = 0; i < cloud2Count; i++) {
 			this.spawnObject('cloud2', Cloud);
 		}
-		// Schedule UFO and jet spawns
-		this.scheduleRespawn('ufo1', UFO1);
-		this.scheduleRespawn('jet1', Jet1);
+		// Schedule initial UFO spawn (either UFO1 or UFO2)
+		if (Math.random() < 0.5) {
+			this.spawnObject('ufo1', UFO1);
+		} else {
+			this.spawnObject('ufo2', UFO2);
+		}
+		// Schedule initial Jet1 spawn
+		this.spawnObject('jet1', Jet1);
+		// Set up periodic checks for maintaining entity counts
+		LK.setInterval(function () {
+			// Maintain bird counts
+			if (this.objectCounts.bird1 < 1) {
+				this.spawnObject('bird1', Bird1);
+			}
+			while (this.objectCounts.bird2 < 3) {
+				this.spawnObject('bird2', Bird2);
+			}
+			// Maintain cloud counts (3-5 total)
+			var totalClouds = this.objectCounts.cloud1 + this.objectCounts.cloud2;
+			if (totalClouds < 3) {
+				var type = Math.random() < 0.5 ? 'cloud1' : 'cloud2';
+				this.spawnObject(type, Cloud);
+			}
+			// Ensure one UFO (either UFO1 or UFO2) is scheduled
+			if (this.objectCounts.ufo1 + this.objectCounts.ufo2 === 0 && !this.spawnTimers.ufo1 && !this.spawnTimers.ufo2) {
+				var ufoType = Math.random() < 0.5 ? 'ufo1' : 'ufo2';
+				this.scheduleRespawn(ufoType, ufoType === 'ufo1' ? UFO1 : UFO2);
+			}
+			// Ensure one Jet1 is scheduled
+			if (this.objectCounts.jet1 === 0 && !this.spawnTimers.jet1) {
+				this.scheduleRespawn('jet1', Jet1);
+			}
+		}.bind(this), 1000);
 	};
 	spawnManager.initialize();
 	// Main game update function
 	game.update = function () {
@@ -1625,39 +1889,28 @@
 				});
 			}
 		});
 	};
-	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 = Math.random() * 1.6 + 1;
-			bird1.lastIntersecting = false;
-			bird1.type = 'bird1';
-			bird1.color = 0x746130;
-			game.addChild(bird1);
-			if (game.children.includes(bird1)) {
-				game.layerManager.addToLayer(bird1, LAYERS.BIRD1);
-				birds.push(bird1);
-			}
-		}
-		LK.setTimeout(spawnBird1, Math.random() * 10000 + 20000);
-	}
+	// Initialize game objects and start spawning
+	spawnManager.initialize();
 	function spawnBird2() {
-		var bird2Count = entityManager.getAllOfType(Bird2).length;
+		var bird2Count = birds.filter(function (b) {
+			return b instanceof Bird2;
+		}).length;
+		// Fix: Ensure there are always 3 bird2 on screen
 		if (bird2Count < 3) {
-			var bird = new Bird2();
-			bird.y = Math.random() * (2732 / 2);
-			bird.x = Math.random() < 0.5 ? 0 : 2048;
-			bird.speed = 1 + Math.random() * 0.6;
-			bird.lastIntersecting = false;
-			bird.type = 'bird2';
-			bird.color = 0xFFFFFF;
-			entityManager.add(bird);
-			birds.push(bird);
+			var bird2 = new Bird2();
+			bird2.x = Math.random() * 2048;
+			bird2.y = -bird2.height;
+			bird2.speed = Math.random() * 1.6 + 1;
+			bird2.lastIntersecting = false;
+			bird2.type = 'bird2';
+			bird2.color = 0x746130;
+			game.addChild(bird2);
+			if (game.children.includes(bird2)) {
+				game.layerManager.addToLayer(bird2, LAYERS.BIRD2);
+				birds.push(bird2);
+			}
 		}
 		LK.setTimeout(spawnBird2, Math.random() * 10000 + 20000);
 	}
 	// Update bird positions and states
@@ -2069,21 +2322,40 @@
 	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;
+		self.scoreValues = {
+			bird1: 100,
+			bird2: 50,
+			ufo1: 250,
+			ufo2: 250
+		};
+		self.addScore = function (objectType) {
+			var points = self.scoreValues[objectType] || 0;
+			if (points > 0) {
+				currentScore += points;
+				if (currentScore > highScore) {
+					highScore = currentScore;
+					storage.highScore = highScore;
+				}
+				// Update score display
+				if (scoreDisplay && scoreDisplay.updateScore) {
+					scoreDisplay.updateScore(currentScore);
+				}
+				if (mirror && mirror.updateScore) {
+					mirror.updateScore(currentScore);
+				}
 			}
-			currentScore += Math.floor(points);
-			if (currentScore > highScore) {
-				highScore = currentScore;
-				storage.highScore = highScore;
-			}
 			return currentScore;
 		};
 		self.resetScore = function () {
 			currentScore = 0;
+			if (scoreDisplay && scoreDisplay.updateScore) {
+				scoreDisplay.updateScore(currentScore);
+			}
+			if (mirror && mirror.updateScore) {
+				mirror.updateScore(currentScore);
+			}
 			return currentScore;
 		};
 		self.getScore = function () {
 			return currentScore;
@@ -2493,140 +2765,131 @@
 				});
 				this.entities = [];
 			}
 		}]);
-	}(); // Instantiate the EntityManager
-	var entityManager = new EntityManager();
-	// Update entities
-	// Update entities using the EntityManager
-	entityManager.update(deltaTime);
-};
-// Add existing entities to the EntityManager
-var bird1 = new Bird1();
-bird1.x = Math.random() * 2048;
-bird1.y = -bird1.height;
-bird1.speed = Math.random() * 1.6 + 1;
-bird1.lastIntersecting = false;
-bird1.type = 'bird1';
-bird1.color = 0x746130;
-entityManager.add(bird1);
-var bird2 = new Bird2();
-bird2.y = Math.random() * (2732 / 2);
-bird2.x = Math.random() < 0.5 ? 0 : 2048;
-bird2.speed = 1 + Math.random() * 0.6;
-bird2.lastIntersecting = false;
-bird2.type = 'bird2';
-bird2.color = 0xFFFFFF;
-entityManager.add(bird2);
-var ufo1 = new UFO1();
-ufo1.x = Math.random() < 0.5 ? 2048 + ufo1.width / 2 : -ufo1.width / 2;
-ufo1.y = Math.random() * (2732 / 2 - ufo1.height);
-entityManager.add(ufo1);
-var ufo2 = new UFO2();
-ufo2.x = Math.random() < 0.5 ? 2048 + ufo2.width / 2 : -ufo2.width / 2;
-ufo2.y = Math.random() * (2732 / 2 - ufo2.height);
-entityManager.add(ufo2);
-var jet = new Jet1();
-jet.x = Math.random() < 0.5 ? 2048 + jet.width / 2 : -jet.width / 2;
-jet.y = Math.random() * (2732 / 2);
-entityManager.add(jet);
-if (typeof x !== 'undefined' && typeof y !== 'undefined') {
-	var laser = new Laser(cat.x - 140, cat.y - 440, x, y); // laser starting point
-	entityManager.add(laser);
-} else {
-	console.error('Invalid coordinates for laser creation');
-}
-// Ensure timers for ambient sounds and bgm1 are set to repeat every 20-30 seconds
-function initializeAmbientSounds() {
-	function playAmbientSounds() {
-		LK.getSound('songbird1').play();
-		LK.getSound('cricket1').play();
-		LK.setTimeout(playAmbientSounds, Math.random() * 10000 + 20000); // 20-30 seconds
+	}(); // Initialize entity managers
+	var birdManager = new BirdManager();
+	var ufoManager = new UFOManager();
+	var jetManager = new JetManager();
+	// Update all entity managers
+	birdManager.update(deltaTime);
+	ufoManager.update(deltaTime);
+	jetManager.update(deltaTime);
+	// Initial entity spawning will be handled by the managers
+	if (typeof x !== 'undefined' && typeof y !== 'undefined') {
+		var laser = new Laser(cat.x - 140, cat.y - 440, x, y); // laser starting point
+		entityManager.add(laser);
+	} else {
+		console.error('Invalid coordinates for laser creation');
 	}
-	playAmbientSounds();
-	// Set initial interval
-	LK.setInterval(playAmbientSounds, 25000); // Average of 20-30 seconds
-}
-function initializeBGM() {
-	function playBGM() {
-		LK.playMusic('bgm1');
+	// Ensure timers for ambient sounds and bgm1 are set to repeat every 20-30 seconds
+	function initializeAmbientSounds() {
+		function playAmbientSounds() {
+			LK.getSound('songbird1').play();
+			LK.getSound('cricket1').play();
+			LK.setTimeout(playAmbientSounds, Math.random() * 10000 + 20000); // 20-30 seconds
+		}
+		playAmbientSounds();
+		// Set initial interval
+		LK.setInterval(playAmbientSounds, 25000); // Average of 20-30 seconds
 	}
-	playBGM();
-	// Set regular interval for background music
-	LK.setInterval(playBGM, 25000); // Average of 20-30 seconds
-}
-// Fix scoring
-var scoreManager = new ScoreManager();
-var score = 0;
-game.down = function (x, y, obj) {
-	if (obj && obj.event) {
-		x = obj.event.x;
-		y = obj.event.y;
+	function initializeBGM() {
+		function playBGM() {
+			LK.playMusic('bgm1');
+		}
+		playBGM();
+		// Set regular interval for background music
+		LK.setInterval(playBGM, 25000); // Average of 20-30 seconds
 	}
-	if (!game.reticle) {
-		game.reticle = game.addChild(new Reticle());
-		if (game.children.includes(game.reticle)) {
-			game.layerManager.addToLayer(game.reticle, LAYERS.RETICLE);
+	// Fix scoring
+	var scoreManager = new ScoreManager();
+	var score = 0;
+	game.down = function (x, y, obj) {
+		if (obj && obj.event) {
+			x = obj.event.x;
+			y = obj.event.y;
 		}
+		if (!game.reticle) {
+			game.reticle = game.addChild(new Reticle());
+			if (game.children.includes(game.reticle)) {
+				game.layerManager.addToLayer(game.reticle, LAYERS.RETICLE);
+			}
+		}
+		game.reticle.x = x;
+		game.reticle.y = y;
+		if (typeof x === 'undefined' || typeof y === 'undefined') {
+			console.error('Invalid coordinates for laser');
+			return;
+		}
+		var laser = new Laser(cat.x - 140, cat.y - 440, x, y);
+		game.addChild(laser);
+		if (game.children.includes(laser) && game.children.includes(game.reticle)) {
+			game.layerManager.addToLayer(laser, LAYERS.LASER);
+		}
+	};
+	// Adjust layer display order
+	// Ensure light1 layer is displayed after background
+	if (light1) {
+		game.layerManager.addToLayer(light1, LAYERS.LIGHT1);
 	}
-	game.reticle.x = x;
-	game.reticle.y = y;
-	if (typeof x === 'undefined' || typeof y === 'undefined') {
-		console.error('Invalid coordinates for laser');
-		return;
+	// Ensure jet layer is displayed before cloud2 layer
+	if (jet) {
+		game.layerManager.addToLayer(jet, LAYERS.JET1);
 	}
-	var laser = new Laser(cat.x - 140, cat.y - 440, x, y);
-	game.addChild(laser);
-	if (game.children.includes(laser) && game.children.includes(game.reticle)) {
-		game.layerManager.addToLayer(laser, LAYERS.LASER);
+	// Ensure mirror layer is displayed behind grass-front
+	if (mirror) {
+		game.layerManager.addToLayer(mirror, LAYERS.MIRROR);
 	}
-};
-// Adjust layer display order
-game.layerManager.addToLayer(light1, LAYERS.LIGHT1);
-game.layerManager.addToLayer(jet, LAYERS.JET1);
-game.layerManager.addToLayer(mirror, LAYERS.MIRROR);
-// Ensure jet1 and ufo1 sounds play when on screen
-Jet1.prototype.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 + 20000;
-		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.layerManager.addToLayer(jet, LAYERS.JET1);
-			game.jet = jet;
-			game.jetSpawnTimer = null;
-		}, respawnTime);
-	}
-	self.lastX = self.x;
-};
-UFOMovement.prototype.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;
+	// Ensure jet1 and ufo1 sounds play when on screen
+	Jet1.prototype.update = function () {
+		// Fix: Use 'this' instead of 'self' since this is a prototype method
+		var jetGraphics = this.children[0];
+		flipImageVerticallyBasedOnDirection(jetGraphics, this.lastX, this.x);
+		this.x += this.speed * this.direction;
+		// Play jet sound when on screen
+		if (!this.soundPlayed && this.x > 0 && this.x < 2048) {
+			LK.getSound('jet1').play();
+			this.soundPlayed = true;
+		}
+		// Stop sound and destroy when off screen
+		if (this.lastX <= 2048 + this.width / 2 && this.x > 2048 + this.width / 2 || this.lastX >= -this.width / 2 && this.x < -this.width / 2) {
+			LK.getSound('jet1').stop();
+			this.destroy();
+			game.jet = null;
+			// Set respawn timer to 20-30 seconds
+			var respawnTime = Math.random() * 10000 + 20000;
+			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.layerManager.addToLayer(jet, LAYERS.JET1);
+				game.jet = jet;
+				game.jetSpawnTimer = null;
+			}, respawnTime);
+		}
+		this.lastX = this.x;
+	};
+	UFOMovement.prototype.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();
+			game.ufo = null;
+			scheduleUFOSpawn(Math.random() * 10000 + 20000);
+		}
+		this.lastX = this.x;
+	};
 };
\ No newline at end of file