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

/**** 
* Classes
****/ 
// Background class to represent the background image
var Background = Container.expand(function () {
	var self = Container.call(this);
	var backgroundGraphics = self.attachAsset('background', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.addChild(backgroundGraphics);
});
// Branch asset
// Bird1 class to represent the first kind of bird
var Bird1 = Container.expand(function () {
	var self = Container.call(this);
	var birdGraphics = self.attachAsset('bird1-right', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.movement = new Bird1Movement(self, birdGraphics);
	self.setChildIndex = function (index) {
		if (game.children.includes(self)) {
			game.setChildIndex(self, index);
		}
	};
});
// Bird2 class to represent the second kind of bird
var Bird2 = Container.expand(function () {
	var self = Container.call(this);
	var birdGraphics = self.attachAsset('bird2-right', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.movement = new Bird2Movement(self, birdGraphics);
	self.setChildIndex = function (index) {
		if (game.children.includes(self)) {
			game.setChildIndex(self, index);
		}
	};
});
// This is a duplicate checkInteractions function that has been consolidated elsewhere
// Layer z-index management is handled by the layerStructure configuration
// Layer structure and initialization is already handled at the beginning of the file
// Consolidated checkInteractions function is inserted below
// Bird2Movement class to handle Bird2 movement
// Bird2Movement class to handle Bird2 movement
var Bird2Movement = Container.expand(function (bird, birdGraphics) {
	var self = Container.call(this);
	BirdMovement.call(this, bird, birdGraphics, 'bird2-right', 'bird2-left');
	var originalUpdate = this.bird.update.bind(this.bird);
	this.bird.update = function () {
		originalUpdate();
		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
		}
	}.bind(this.bird);
});
// Cat class to manage cat behavior
var Cat = Container.expand(function () {
	var self = Container.call(this);
	var catGraphics = self.attachAsset('cat', {
		anchorX: 0.5,
		anchorY: 1
	});
	self.update = function () {
		// Add any specific update logic for the cat here
	};
});
// Cloud class to represent cloud behavior
var Cloud = Container.expand(function () {
	var self = Container.call(this);
	var cloudGraphics = self.attachAsset('cloud', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0.8 // Set default opacity to 80%
	});
	self.movement = new CloudMovement(self, cloudGraphics);
});
// CloudMovement class to handle cloud movement and fade effects
// GrassBack class to represent the grass image
var GrassBack = Container.expand(function () {
	var self = Container.call(this);
	var grassGraphics = self.attachAsset('grass-back', {
		anchorX: 0.5,
		anchorY: 1
	});
	self.update = function () {
		// Add any specific update logic for the grass here
		// Example: Slightly move the grass to simulate wind effect
		self.x += Math.sin((LK.ticks + 100) / 90) * 0.15; // Swaying effect, increased speed
	};
	self.addChild(grassGraphics); // Add grass graphics to the container
});
// GrassFront class to represent the second grass image
var GrassFront = Container.expand(function () {
	var self = Container.call(this);
	var grass2Graphics = self.attachAsset('grass-front', {
		anchorX: 0.5,
		anchorY: 1
	});
	self.lastX = self.x; // Initialize lastX for tracking changes on X
	self.addChild(grass2Graphics); // Add grass2 graphics to the container
	self.update = function () {
		// Add any specific update logic for the grass here
		// Example: Slightly move the grass to simulate wind effect
		self.x += Math.sin((LK.ticks + 50) / 100) * 0.125; // Swaying effect, reduced by 50%
		self.lastX = self.x; // Update lastX after movement
	};
});
// Jet class to represent a jet flying across the screen
var Jet = Container.expand(function () {
	var self = Container.call(this);
	var jetGraphics = self.attachAsset('jet-right', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 3.2; // Decrease speed by 20%
	self.direction = Math.random() < 0.5 ? 1 : -1; // Random direction: 1 for right, -1 for left
	self.lastX = self.x; // Track last X position for future checks
	self.update = function () {
		self.x += self.speed * self.direction;
		jetGraphics.texture = LK.getAsset(self.lastX < self.x ? 'jet-right' : 'jet-left', {}).texture;
		// Remove vertical wave pattern for straight horizontal movement
		// Stop playing jetSound after Jet leaves the screen
		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();
			LK.getSound('jetSound').stop();
		}
		self.lastX = self.x; // Update lastX after movement
	};
	self.onDestroy = function () {
		LK.getSound('jetSound').stop(); // Ensure sound stops when jet is destroyed
	};
	self.setChildIndex = function (index) {
		if (game.children.includes(self)) {
			game.setChildIndex(self, index);
		}
	};
});
var JetLeft = Container.expand(function () {
	var self = Container.call(this);
	var jetGraphics = self.attachAsset('jet-left', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 3.2;
	self.direction = -1; // Always left
	self.lastX = self.x;
	self.update = function () {
		self.x += self.speed * self.direction;
		if (self.lastX >= -self.width / 2 && self.x < -self.width / 2) {
			self.destroy();
			LK.getSound('jetSound').stop();
		}
		self.lastX = self.x;
	};
	self.onDestroy = function () {
		LK.getSound('jetSound').stop();
	};
});
var JetRight = Container.expand(function () {
	var self = Container.call(this);
	var jetGraphics = self.attachAsset('jet-right', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 3.2;
	self.direction = 1; // Always right
	self.lastX = self.x;
	self.update = function () {
		self.x += self.speed * self.direction;
		if (self.lastX <= 2048 + self.width / 2 && self.x > 2048 + self.width / 2) {
			self.destroy();
			LK.getSound('jetSound').stop();
		}
		self.lastX = self.x;
	};
	self.onDestroy = function () {
		LK.getSound('jetSound').stop();
	};
});
// Laser class to represent a laser shot from the cat
var Laser = Container.expand(function (startX, startY, targetX, targetY) {
	var self = Container.call(this);
	var laserGraphics = self.attachAsset('laser2', {
		anchorX: 0.5,
		anchorY: 0.5,
		brightness: 2.0 // Increase brightness by 200%
	});
	// Play the laser1 sound when the laser is created
	LK.getSound('laser1').play();
	// Calculate direction and speed
	var dx = targetX - startX;
	var dy = targetY - startY;
	var distance = Math.sqrt(dx * dx + dy * dy);
	var speed = 60; // Speed of the laser increased by 200%
	self.vx = dx / distance * speed;
	self.vy = dy / distance * speed;
	// Set initial position
	self.x = startX;
	self.y = startY;
	// Update function to move the laser
	self.update = function () {
		self.x += self.vx;
		self.y += self.vy;
		// Remove laser if it goes off-screen
		if (self.x < 0 || self.x > 2048 || self.y < 0 || self.y > 2732) {
			self.destroy();
		}
	};
});
// Light1 class to represent a light object
var Light1 = Container.expand(function () {
	var self = Container.call(this);
	var lightGraphics = self.attachAsset('light1', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0.2 // Set transparency to 20%
	});
	self.x = 450, self.y = 440;
	self.update = function () {
		// Add any specific update logic for the light here
	};
	self.pulse = new Light1Pulse(lightGraphics);
	self.pulse.startPulsating();
});
// Mirror class to manage score display
var Mirror = Container.expand(function () {
	var self = Container.call(this);
	var scoreGraphics = self.attachAsset('mirror1', {
		anchorX: 0.5,
		anchorY: 0.5,
		rotation: Math.PI / 14 // Rotate image right 15 degrees
	});
	var scoreText = new Text2('0', {
		size: 175,
		fill: 0x800080,
		font: "Courier New, Courier, monospace",
		// Segmented clock style font
		stroke: 0x00FF00,
		strokeThickness: 15,
		dropShadow: true,
		dropShadowColor: 0x000000,
		dropShadowBlur: 5,
		dropShadowAngle: Math.PI / 6,
		dropShadowDistance: 6
	});
	scoreText.y = 40; // Move score text up by 20px
	scoreText.x = -145; // Move score text left by 10px
	scoreText.rotation = Math.PI / 12; // Rotate score text right 15 degrees
	self.addChild(scoreText);
	self.updateScore = function (newScore) {
		scoreText.setText(newScore);
	};
});
// Mirror1 class to represent the mirror image
var Mirror1 = Container.expand(function () {
	var self = Container.call(this);
	var mirror1Graphics = self.attachAsset('mirror1', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.addChild(mirror1Graphics);
});
// Reticle class to manage reticle behavior
var Reticle = Container.expand(function () {
	var self = Container.call(this);
	var reticleGraphics = self.attachAsset('reticle1', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.update = function () {
		// Add any specific update logic for the reticle here
	};
	// Start the pulsating effect for the reticle
	startPulsating(self);
});
// Reticle1 class to represent the reticle image
var Reticle1 = Container.expand(function () {
	var self = Container.call(this);
	var reticle1Graphics = self.attachAsset('reticle1', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.addChild(reticle1Graphics);
});
// ScoreImage class to represent the score image
var ScoreImage = Container.expand(function () {
	var self = Container.call(this);
	var scoreImageGraphics = self.attachAsset('scoreImage', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.addChild(scoreImageGraphics);
});
// Stack1 class to represent the stack1 image
var Stack1 = Container.expand(function () {
	var self = Container.call(this);
	var stackGraphics = self.attachAsset('stack1', {
		anchorX: 0.5,
		anchorY: 0.5,
		rotation: Math.PI / -12
	});
	self.update = function () {
		// Add any specific update logic for stack1 here
	};
});
// ScoreManager class to manage score logic
// Sun class to represent a sun in the top right corner
var Sun = Container.expand(function () {
	var self = Container.call(this);
	var sunGraphics = self.attachAsset('sun', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.pulse = new SunPulse(sunGraphics);
	self.pulse.startPulsating();
});
// Function to create a pulsating effect
// Tree class to represent a tree with a 9:16 aspect ratio
var Tree = Container.expand(function () {
	var self = Container.call(this);
	var treeGraphics = self.attachAsset('tree', {
		anchorX: 0.5,
		anchorY: 1,
		antialias: true,
		// Apply antialias effect
		stroke: 0x000000,
		// Add a black stroke
		strokeThickness: 15 // Set stroke thickness to 15px
	});
	self.update = function () {
		// Add any specific update logic for the tree here
	};
});
// Tree2 class to represent the second type of tree
var Tree2 = Container.expand(function () {
	var self = Container.call(this);
	var tree2Graphics = self.attachAsset('tree2', {
		anchorX: 0.5,
		anchorY: 1
	});
	self.addChild(tree2Graphics);
});
// UFO class to represent a UFO
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);
	self.setChildIndex = function (index) {
		if (game.children.includes(self)) {
			game.setChildIndex(self, index);
		}
	};
});
// UFO2 class to represent the second type of UFO
var UFO2 = Container.expand(function () {
	var self = Container.call(this);
	var ufo2Graphics = self.attachAsset('ufo2', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.movement = new UFOMovement(self, ufo2Graphics);
});

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

/**** 
* Game Code
****/ 
var light1; // Define light1 variable in the global scope
var BirdMovement = function BirdMovement(bird, birdGraphics, rightTexture, leftTexture) {
	this.bird = bird;
	this.birdGraphics = birdGraphics;
	this.bird.speed = Math.random() * 1.6 + 1;
	this.bird.lastY = this.bird.y; // Initialize lastY for tracking changes on Y
	this.bird.lastX = this.bird.x; // Initialize lastX for tracking changes on X
	this.bird.update = function () {
		this.y += this.speed;
		this.x += Math.sin(this.y / 100) * 6.5; // Increase the swooping motion of the bird's movement by 30%
		if (this.birdGraphics) {
			if (this.lastX <= this.x) {
				this.birdGraphics.texture = LK.getAsset(rightTexture, {}).texture;
			} else if (this.lastX > this.x) {
				this.birdGraphics.texture = LK.getAsset(leftTexture, {}).texture;
			}
			this.lastX = this.x; // Update lastX after movement
		}
		// 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.lastY = this.y; // Update lastY after movement
	}.bind(this.bird);
};
game.layers = {
	clouds: new Container(),
	jetLeft: new Container(),
	jetRight: new Container(),
	reticle: new Container(),
	laser: new Container(),
	enemies: new Container(),
	grassBack: new Container(),
	background: new Container()
};
// CloudMovement class to handle cloud movement and fade effects
// Initialize global variables
var CloudMovement = function CloudMovement(cloud, cloudGraphics) {
	this.cloud = cloud;
	this.cloudGraphics = cloudGraphics;
	this.speed = Math.random() * 0.55 + 0.25; // Adjust speed to range between 0.25 and 0.8
	this.hasAccelerated = false; // Track if the cloud has already accelerated
	this.direction = Math.random() < 0.5 ? 1 : -1; // Random direction: 1 for right, -1 for left
	this.lastX = this.cloud.x; // Track last X position for future checks
	this.lastIntersecting = false; // Initialize lastIntersecting for tracking changes on intersections
	this.cloud.update = function () {
		this.x += this.speed * this.direction;
		// If the cloud moves off-screen, reposition it to the opposite side
		if (this.lastX <= 2048 + this.width / 2 && this.x > 2048 + this.width / 2) {
			this.x = -this.width / 2;
		} else if (this.lastX >= -this.width / 2 && this.x < -this.width / 2) {
			this.x = 2048 + this.width / 2;
		}
		// Check for overlap with other clouds
		for (var i = 0; i < clouds.length; i++) {
			if (clouds[i] !== this && this.intersects(clouds[i])) {
				if (!this.hasAccelerated) {
					this.speed *= 1.5; // Increase speed by 50%
					this.hasAccelerated = true; // Mark as accelerated
				}
				break;
			} else if (this.hasAccelerated && !this.intersects(clouds[i])) {
				this.speed /= 1.5; // Reset speed to original
				this.hasAccelerated = false; // Reset acceleration state
			}
		}
		// Check if the cloud intersects with the sun
		if (!this.lastIntersecting && this.intersects(sun)) {
			this.speed *= 2; // Double the speed when touching the sun
			if (this.cloudGraphics) {
				tween(this.cloudGraphics, {
					alpha: 0.5
				}, {
					duration: 3000,
					easing: tween.linear
				});
			}
		} else if (this.lastIntersecting && !this.intersects(sun)) {
			this.speed /= 2; // Reset speed to original when not touching the sun
			if (this.cloudGraphics) {
				tween(this.cloudGraphics, {
					alpha: 1.0
				}, {
					duration: 3000,
					easing: tween.linear
				});
			}
		}
		this.lastIntersecting = this.intersects(sun);
		this.lastX = this.x; // Update lastX after movement
	}.bind(this.cloud);
};
var birds = [];
var clouds = [];
var ufo = null;
var score = 0;
var scoreDisplay = null;
// Initialize game layers with a single, organized structure
// Duplicate game.layers initialization removed
// UFO creation function
function addUFO() {
	if (ufo) {
		return;
	}
	var ufo = new UFO();
	game.layers.ufo.addChild(ufo);
	ufo.x = Math.random() < 0.5 ? 2048 + ufo.width / 2 : -ufo.width / 2;
	ufo.y = Math.random() * (2732 / 2 - ufo.height);
	ufo.customUpdate = function () {
		ufo.update();
	};
	return ufo;
}
// Bird spawning functions
// Consolidated bird spawning functions
// Consolidated bird spawning functions are inserted below
// Jet timer function
var jetTimer = LK.setTimeout(function () {
	var jet = new Jet();
	jet.x = Math.random() < 0.5 ? 2048 + jet.width / 2 : -jet.width / 2;
	jet.y = Math.random() * (2732 / 2 - jet.height);
	// Add to appropriate layer based on direction
	if (jet.x < 1024) {
		game.layers.jetLeft.addChild(jet);
	} else {
		game.layers.jetRight.addChild(jet);
	}
	game.jet = jet;
	if (!game.jetSoundPlayed) {
		LK.getSound('jetSound').play();
		game.jetSoundPlayed = true;
	}
	jetTimer = LK.setTimeout(arguments.callee, 5000);
}, Math.random() * 5000 + 5000);
// Cloud initialization
for (var i = 0; i < 4; i++) {
	var cloud = new Cloud();
	cloud.x = Math.random() * 2048;
	cloud.y = Math.random() * (2732 / 2);
	clouds.push(cloud);
	game.layers.clouds.addChild(cloud);
}
// Handle click/tap events
game.down = function (x, y, obj) {
	if (!game.reticle) {
		game.reticle = game.layers.reticle.addChild(new Reticle());
	}
	game.reticle.x = x;
	game.reticle.y = y;
	var laser = new Laser(cat.x - 140, cat.y - 440, x, y);
	game.layers.laser.addChild(laser);
};
// This is a duplicate checkInteractions function that has been consolidated elsewhere
// Object placements are handled in the main initialization section
// This is a duplicate addUFO function that has been consolidated elsewhere
// Consolidated bird spawning functions
// Function to spawn Bird2
function spawnBird2() {
	var bird2 = new Bird2();
	bird2.x = Math.random() * 2048;
	bird2.y = Math.random() * 2732;
	birds.push(bird2);
	game.layers.enemies.addChild(bird2);
}
var jetTimer = LK.setTimeout(function () {
	var jet = new Jet();
	jet.x = Math.random() < 0.5 ? 2048 + jet.width / 2 : -jet.width / 2;
	jet.y = Math.random() * (2732 / 2 - jet.height);
	// Add to appropriate layer based on direction
	if (jet.x < 1024) {
		game.layers.jetLeft.addChild(jet);
	} else {
		game.layers.jetRight.addChild(jet);
	}
	game.jet = jet;
	if (!game.jetSoundPlayed) {
		LK.getSound('jetSound').play();
		game.jetSoundPlayed = true;
	}
	jetTimer = LK.setTimeout(arguments.callee, 5000);
}, Math.random() * 5000 + 5000);
for (var i = 0; i < 4; i++) {
	var cloud = new Cloud();
	cloud.x = Math.random() * 2048;
	cloud.y = Math.random() * (2732 / 2);
	clouds.push(cloud);
	game.layers.clouds.addChild(cloud);
}
game.down = function (x, y, obj) {
	if (!game.reticle) {
		game.reticle = game.layers.reticle.addChild(new Reticle());
	}
	game.reticle.x = x;
	game.reticle.y = y;
	var laser = new Laser(cat.x - 140, cat.y - 440, x, y);
	game.layers.laser.addChild(laser);
};
// This is a duplicate checkInteractions function that has been consolidated elsewhere
// Layer structure and initialization is already handled at the beginning of the file
// Layer z-index management is handled by the layerStructure configuration
// The spawn functions for UFO, Bird1, Bird2, and Jet are already defined earlier in the code
// Layer z-index management is handled by the layerStructure configuration
// The game.down function is already defined earlier in the code
game.addChild(game.layers.enemies);
Bird2Movement.prototype = Object.create(BirdMovement.prototype);
Bird2Movement.prototype.constructor = Bird2Movement;
var Bird2Movement = function Bird2Movement(bird, birdGraphics) {
	// Duplicate grassBack and grassFront placements removed
	this.bird = bird;
	this.birdGraphics = birdGraphics;
	this.bird.speed = Math.random() * 1.6 + 1;
	// Duplicate mirror placement removed
	this.bird.lastY = this.bird.y; // Initialize lastY for tracking changes on Y
	this.bird.lastX = this.bird.x; // Initialize lastX for tracking changes on X
	this.bird.update = function () {
		// Duplicate cat placement removed
		this.y += this.speed;
		this.x += Math.sin(this.y / 100) * 6.5; // Increase the swooping motion of the bird's movement by 30%
		if (this.birdGraphics) {
			if (this.lastX <= this.x) {
				this.birdGraphics.texture = LK.getAsset('bird2-right', {}).texture;
			} else if (this.lastX > this.x) {
				this.birdGraphics.texture = LK.getAsset('bird2-left', {}).texture;
			}
			this.lastX = this.x; // Update lastX after movement
		}
		// 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.lastY = this.y; // Update lastY after movement
	}.bind(this.bird);
};
// CloudMovement class to handle cloud movement and fade effects
var CloudMovement = function CloudMovement(cloud, cloudGraphics) {
	this.cloud = cloud;
	this.cloudGraphics = cloudGraphics;
	this.speed = Math.random() * 0.55 + 0.25; // Adjust speed to range between 0.25 and 0.8
	this.hasAccelerated = false; // Track if the cloud has already accelerated
	this.direction = Math.random() < 0.5 ? 1 : -1; // Random direction: 1 for right, -1 for left
	this.lastX = this.cloud.x; // Track last X position for future checks
	this.lastIntersecting = false; // Initialize lastIntersecting for tracking changes on intersections
	this.cloud.update = function () {
		this.x += this.speed * this.direction;
		// If the cloud moves off-screen, reposition it to the opposite side
		if (this.lastX <= 2048 + this.width / 2 && this.x > 2048 + this.width / 2) {
			this.x = -this.width / 2;
		} else if (this.lastX >= -this.width / 2 && this.x < -this.width / 2) {
			this.x = 2048 + this.width / 2;
		}
		// Check for overlap with other clouds
		for (var i = 0; i < clouds.length; i++) {
			if (clouds[i] !== this && this.intersects(clouds[i])) {
				if (!this.hasAccelerated) {
					this.speed *= 1.5; // Increase speed by 50%
					this.hasAccelerated = true; // Mark as accelerated
				}
				break;
			} else if (this.hasAccelerated && !this.intersects(clouds[i])) {
				this.speed /= 1.5; // Reset speed to original
				this.hasAccelerated = false; // Reset acceleration state
			}
		}
		// Check if the cloud intersects with the sun
		if (!this.lastIntersecting && this.intersects(sun)) {
			this.speed *= 2; // Double the speed when touching the sun
			if (this.cloudGraphics) {
				tween(this.cloudGraphics, {
					alpha: 0.5
				}, {
					duration: 3000,
					easing: tween.linear
				});
			}
		} else if (this.lastIntersecting && !this.intersects(sun)) {
			this.speed /= 2; // Reset speed to original when not touching the sun
			if (this.cloudGraphics) {
				tween(this.cloudGraphics, {
					alpha: 1.0
				}, {
					duration: 3000,
					easing: tween.linear
				});
			}
		}
		this.lastIntersecting = this.intersects(sun);
		this.lastX = this.x; // Update lastX after movement
	}.bind(this.cloud);
};
// UFOMovement class to handle UFO movement
var UFOMovement = function UFOMovement(ufo, ufoGraphics) {
	this.ufo = ufo;
	this.ufoGraphics = ufoGraphics;
	this.ufo.speed = 3.2; // Decrease speed by 20%
	this.ufo.direction = Math.random() < 0.5 ? 1 : -1; // Random direction: 1 for right, -1 for left
	this.ufo.lastX = this.ufo.x; // Track last X position for future checks
	this.ufo.update = function () {
		this.x += this.speed * this.direction;
		this.y = 100 + Math.sin(this.x / 100) * 250; // Slow down the wave pattern by 50%
		// Stop playing ufo1 sound after UFO leaves the screen
		if (this.lastX <= 2048 + this.width / 2 && this.x > 2048 + this.width / 2 || this.lastX >= -this.width / 2 && this.x < -this.width / 2) {
			this.destroy();
			ufo = null;
			LK.getSound('ufo1').stop();
		}
		this.lastX = this.x; // Update lastX after movement
	};
};
// Generic Pulse class that can be used for both Sun and Light1
var Pulse = function Pulse(graphics, scaleMax, duration) {
	this.graphics = graphics;
	this.scaleMax = scaleMax || 1.1;
	this.duration = duration || 1000;
	this.startPulsating = function () {
		function pulsate() {
			tween(this.graphics, {
				scaleX: this.scaleMax,
				scaleY: this.scaleMax
			}, {
				duration: this.duration,
				easing: tween.easeInOut,
				onFinish: function () {
					tween(this.graphics, {
						scaleX: 1.0,
						scaleY: 1.0
					}, {
						duration: this.duration,
						easing: tween.easeInOut,
						onFinish: pulsate.bind(this)
					});
				}.bind(this)
			});
		}
		pulsate.call(this);
	};
};
// Light1Pulse now uses the generic Pulse class
var Light1Pulse = function Light1Pulse(lightGraphics) {
	return new Pulse(lightGraphics, 1.6, 1500);
};
// SunPulse now uses the generic Pulse class
var SunPulse = function SunPulse(sunGraphics) {
	return new Pulse(sunGraphics, 1.1, 1000);
};
var bird2; // Define bird2 variable in the global scope
// Bird2Effects class to handle effects and animations for Bird2
// Consolidated function to create a pulsating effect
function startPulsating(target, duration) {
	duration = duration || 888;
	function pulsate() {
		tween(target, {
			scaleX: 1.1,
			// Use consistent scale value
			scaleY: 1.1
		}, {
			duration: duration,
			easing: tween.easeInOut,
			onFinish: function onFinish() {
				tween(target, {
					scaleX: 1.0,
					scaleY: 1.0
				}, {
					duration: duration,
					easing: tween.easeInOut,
					onFinish: pulsate
				});
			}
		});
	}
	pulsate();
}
// UFOSound class to manage UFO sound effects
// UFOMovement class to handle UFO movement
// UFOMovement class to handle UFO movement
var UFOMovement = function UFOMovement(ufo, ufoGraphics) {
	this.ufo = ufo;
	this.ufoGraphics = ufoGraphics;
	this.ufo.speed = 3.2; // Decrease speed by 20%
	this.ufo.direction = Math.random() < 0.5 ? 1 : -1; // Random direction: 1 for right, -1 for left
	this.ufo.lastX = this.ufo.x; // Track last X position for future checks
	this.ufo.update = function () {
		this.x += this.speed * this.direction;
		this.y = 100 + Math.sin(this.x / 100) * 250; // Slow down the wave pattern by 50%
		// Stop playing ufo1 sound after UFO leaves the screen
		if (this.lastX <= 2048 + this.width / 2 && this.x > 2048 + this.width / 2 || this.lastX >= -this.width / 2 && this.x < -this.width / 2) {
			this.destroy();
			ufo = null;
			LK.getSound('ufo1').stop();
		}
		this.lastX = this.x; // Update lastX after movement
	};
};
var UFOMovement = function UFOMovement(ufo, ufoGraphics) {
	this.ufo = ufo;
	this.ufoGraphics = ufoGraphics;
	this.ufo.speed = 3.2; // Decrease speed by 20%
	this.ufo.direction = Math.random() < 0.5 ? 1 : -1; // Random direction: 1 for right, -1 for left
	this.ufo.lastX = this.ufo.x; // Track last X position for future checks
	this.ufo.update = function () {
		this.x += this.speed * this.direction;
		this.y = 100 + Math.sin(this.x / 100) * 250; // Slow down the wave pattern by 50%
		// Stop playing ufo1 sound after UFO leaves the screen
		if (this.lastX <= 2048 + this.width / 2 && this.x > 2048 + this.width / 2 || this.lastX >= -this.width / 2 && this.x < -this.width / 2) {
			this.destroy();
			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; // Initialize lastY for tracking changes on Y
	this.bird.lastX = this.bird.x; // Initialize lastX for tracking changes on X
	this.bird.update = function () {
		this.y += this.speed;
		this.x += Math.sin(this.y / 100) * 6.5; // Increase the swooping motion of the bird's movement by 30%
		// Check if the bird has moved off-screen
		if (this.lastY <= 2732 && this.y > 2732) {
			this.y = -this.height;
			this.x = Math.random() < 0.33 ? Math.random() * 2048 : Math.random() < 0.5 ? 0 : 2048;
		}
		if (this.birdGraphics) {
			if (this.lastX <= this.x) {
				this.birdGraphics.texture = LK.getAsset('bird1-right', {}).texture;
			} else if (this.lastX > this.x) {
				this.birdGraphics.texture = LK.getAsset('bird1-left', {}).texture;
			}
			this.lastX = this.x; // Update lastX after movement
		}
		this.lastY = this.y; // Update lastY after movement
	}.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 = this.bird.y; // Initialize lastY for tracking changes on Y
	this.bird.lastX = this.bird.x; // Initialize lastX for tracking changes on X
	this.bird.update = function () {
		this.y += this.speed;
		this.x += Math.sin(this.y / 100) * 6.5; // Increase the swooping motion of the bird's movement by 30%
		if (this.birdGraphics) {
			if (this.lastX <= this.x) {
				this.birdGraphics.texture = LK.getAsset('bird2-right', {}).texture;
			} else if (this.lastX > this.x) {
				this.birdGraphics.texture = LK.getAsset('bird2-left', {}).texture;
			}
			this.lastX = this.x; // Update lastX after movement
		}
		// 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.lastY = this.y; // Update lastY after movement
	}.bind(this.bird);
};
// CloudMovement class is already defined earlier in the file
var Bird2Effects = function Bird2Effects(bird) {
	this.bird = bird;
	this.applyEffects = function () {
		// Add any specific effects or animations for Bird2 here
	};
};
// Bird1Effects class to handle effects and animations for Bird1
var Bird1Effects = function Bird1Effects(bird) {
	this.bird = bird;
	this.applyEffects = function () {
		// Add any specific effects or animations for Bird1 here
	};
};
var background = LK.getAsset('background', {
	anchorX: 0.5,
	anchorY: 0.5
});
background.x = 2048 / 2;
background.y = 2732 / 2 - 100;
game.layers.background.addChild(background);
game.addChild(background);
// ScoreManager class to manage score logic
var ScoreManager = function ScoreManager() {
	var self = this;
	self.score = 0;
	self.addScore = function (points) {
		self.score += points;
		return self.score;
	};
	self.resetScore = function () {
		self.score = 0;
	};
	self.getScore = function () {
		return self.score;
	};
};
var birds = [];
game.down = function (x, y, obj) {
	if (!game.reticle) {
		game.reticle = game.layers.reticle.addChild(new Reticle());
	}
	game.reticle.x = x;
	game.reticle.y = y;
	var laser = new Laser(cat.x - 140, cat.y - 440, x, y); // laser starting point
	game.layers.laser.addChild(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.layers.reticle.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
// Duplicate sun placement removed
// Duplicate light1 placement removed // Move light1 down by 210px
// Ensure light1 is added to the game before setting its index
if (game.children.includes(light1)) {
	game.setChildIndex(light1, 2); // Set light1 to be rendered after the sun
}
// Function to add a UFO to the game
// Initialize clouds array
var clouds = [];
for (var i = 0; i < 4; i++) {
	// Add 3 clouds for variety
	var cloud = new Cloud();
	cloud.x = Math.random() * 2048;
	cloud.y = Math.random() * (2732 / 2); // Position clouds in the upper half of the screen
	clouds.push(cloud);
	game.layers.clouds.addChild(cloud);
	// No need to add cloud directly to game since it's already in the clouds layer
}
var bird1; // Define bird1 variable in the global scope
// Function to spawn Bird1
function spawnBird1() {
	var bird1 = new Bird1();
	bird1.x = Math.random() * 2048;
	bird1.y = Math.random() * 2732;
	birds.push(bird1);
	game.layers.enemies.addChild(bird1);
}
spawnBird1();
spawnBird2();
spawnBird2();
// Initialize a timer to add a UFO at a random time between 20 and 30 seconds
var ufo; // Define the ufo variable in the global scope
var laser; // Define the laser variable in the global scope
// Start UFO 3 seconds after game loads
var ufoTimer = LK.setTimeout(function () {
	ufo = addUFO();
}, 3000);
// Function to handle UFO reappearance logic
// Function to handle UFO reappearance logic
function handleUFOReappearance() {
	if (!ufo) {
		// Start a timer for the UFO to reappear 10-20 seconds after it leaves the screen
		ufoTimer = LK.setTimeout(function () {
			ufo = addUFO();
		}, Math.random() * 10000 + 10000);
	}
}
// Initialize a timer to add a Jet at a random time between 5 and 10 seconds
var jet; // Define the jet variable in the global scope
var jetTimer = LK.setTimeout(function () {
	var jet = new Jet();
	jet.x = Math.random() < 0.5 ? 2048 + jet.width / 2 : -jet.width / 2; // Start from either the far right or left edge of the screen
	jet.y = Math.random() * (2732 / 2 - jet.height); // Random initial y position within the top half of the screen
	// Add to appropriate layer based on direction
	if (jet.x < 1024) {
		game.layers.jetLeft.addChild(jet);
	} else {
		game.layers.jetRight.addChild(jet);
	}
	game.jet = jet;
	if (!game.jetSoundPlayed) {
		LK.getSound('jetSound').play(); // Play jet sound when it appears
		game.jetSoundPlayed = true; // Ensure it only plays once
	}
	// Reset the timer for the Jet to reappear every 5 seconds after it leaves the screen
	jetTimer = LK.setTimeout(arguments.callee, 5000);
}, Math.random() * 5000 + 5000); // Initial interval for Jet appearances 5-10 seconds after page load
game.update = function () {
	for (var i = 0; i < clouds.length; i++) {
		clouds[i].update();
	}
	// Ensure at least 3 clouds are visible
	while (clouds.length < 3) {
		var cloud = new Cloud();
		cloud.x = Math.random() * 2048;
		cloud.y = Math.random() * (2732 / 2); // Position clouds in the upper half of the screen
		clouds.push(cloud);
		game.layers.clouds.addChild(cloud);
	}
	// Add a jet to the game
	if (!game.jet) {
		var jet = new Jet();
		jet.x = Math.random() < 0.5 ? 2048 + jet.width / 2 : -jet.width / 2; // Start from either the far right or left edge of the screen
		jet.y = Math.random() * (2732 - jet.height); // Random initial y position within the screen height
		// Add to appropriate layer based on direction
		if (jet.x < 1024) {
			game.layers.jetLeft.addChild(jet);
		} else {
			game.layers.jetRight.addChild(jet);
		}
		game.jet = jet;
		if (!game.jetSoundPlayed) {
			LK.getSound('jetSound').play(); // Play jet sound when it appears
			game.jetSoundPlayed = true; // Ensure it only plays once
		}
	}
	// Update jet
	if (game.jet) {
		game.jet.update();
		if (game.jet.lastX <= 2048 + game.jet.width / 2 && game.jet.x > 2048 + game.jet.width / 2 || game.jet.lastX >= -game.jet.width / 2 && game.jet.x < -game.jet.width / 2) {
			game.jet.destroy();
			game.jet = null;
			game.jetSoundPlayed = false; // Reset the flag when the jet is removed
			// Set a timer to respawn the jet 5 seconds after it leaves the screen
			jetTimer = LK.setTimeout(function () {
				var jet = new Jet();
				jet.x = Math.random() < 0.5 ? 2048 + jet.width / 2 : -jet.width / 2; // Start from either the far right or left edge of the screen
				jet.y = Math.random() * (2732 - jet.height); // Random initial y position within the screen height
				game.addChild(jet);
				game.jet = jet;
				if (!game.jetSoundPlayed) {
					LK.getSound('jetSound').play(); // Play jet sound when it appears
					game.jetSoundPlayed = true; // Ensure it only plays once
				}
			}, 5000);
		}
	}
	if (ufo) {
		ufo.customUpdate();
		// Update each laser
		game.children.forEach(function (child) {
			if (child instanceof Laser) {
				child.update();
				// Check for intersections with birds and UFO
				birds.forEach(function (bird) {
					if (!child.lastIntersecting && child.intersects(bird)) {
						if (bird instanceof Bird1) {
							score += 5;
							scoreDisplay.updateScore(score); // Update the score display
							bird.destroy(); // Remove the bird when hit by a laser
							birds.splice(birds.indexOf(bird), 1); // Remove bird from the array
							child.destroy();
						} else if (bird instanceof Bird2) {
							score += 1;
							scoreDisplay.updateScore(score); // Update the score display
							bird.destroy(); // Remove the bird when hit by a laser
							birds.splice(birds.indexOf(bird), 1); // Remove bird from the array
							child.destroy();
						}
					}
					child.lastIntersecting = birds.some(function (bird) {
						return child.intersects(bird);
					});
				});
				if (ufo && !child.lastIntersecting && child.intersects(ufo)) {
					score += 25;
					scoreDisplay.updateScore(score);
					// Make laser bounce away at 90 degrees
					var temp = child.vx;
					child.vx = -child.vy;
					child.vy = temp;
					child.lastIntersecting = true; // Mark as intersecting
				}
				child.lastIntersecting = birds.some(function (bird) {
					return child.intersects(bird);
				}) || ufo && child.intersects(ufo);
			}
		});
		// Check for intersections between UFO and birds
		birds.forEach(function (bird) {
			if (!ufo.lastIntersecting && ufo.intersects(bird)) {
				bird.destroy(); // Remove the bird when touched by the UFO
				birds.splice(birds.indexOf(bird), 1); // Remove bird from the array
				LK.getSound('electro').play(); // Play the 'electro' sound
			}
			ufo.lastIntersecting = birds.some(function (bird) {
				return ufo.intersects(bird);
			});
		});
		if (ufo.lastX <= 2048 + ufo.width / 2 && ufo.x > 2048 + ufo.width / 2 || ufo.lastX >= -ufo.width / 2 && ufo.x < -ufo.width / 2) {
			// Destroy the UFO and set it to null
			ufo.destroy();
			ufo = null;
			// Trigger reappearance logic
			handleUFOReappearance();
		}
		ufo.lastX = ufo.x; // Update lastX for the UFO
	}
	// Removed auto-targeting update function
};
// Function to spawn a third kind of bird
// Consolidated bird spawning functions are inserted below
// Ensure there are always 3 birds on screen
game.update = function () {
	// Update each bird
	birds.forEach(function (bird, index) {
		bird.update();
		// Check for intersections with other birds
		birds.forEach(function (otherBird, otherIndex) {
			if (index !== otherIndex && !bird.lastIntersecting && bird.intersects(otherBird)) {
				// Calculate bounce direction
				var dx = bird.x - otherBird.x;
				var dy = bird.y - otherBird.y;
				var distance = Math.sqrt(dx * dx + dy * dy);
				var bounceFactor = 5; // Adjust bounce factor for desired effect
				// Apply bounce with acceleration
				bird.x += dx / distance * bounceFactor;
				bird.y += dy / distance * bounceFactor;
				otherBird.x -= dx / distance * bounceFactor;
				otherBird.y -= dy / distance * bounceFactor;
				// Mark as intersecting
				bird.lastIntersecting = true;
				otherBird.lastIntersecting = true;
			}
		});
		// Reset intersection state
		bird.lastIntersecting = birds.some(function (otherBird, otherIndex) {
			return index !== otherIndex && bird.intersects(otherBird);
		});
		// 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
		}
	});
};
// Note: Tree and stack1 are already added to their respective layers earlier in the code
// This section is redundant and can be removed
var score = 0;
// Add the grass floor to the game
var grassBack = game.layers.grassBack.addChild(new GrassBack()); // grassBack layer
grassBack.x = 1020;
grassBack.y = 2735; // Position grassBack at the bottom
// Note: grassFront and mirror are already added to their respective layers earlier in the code
// This section is redundant and can be removed as it causes duplicate rendering
// Function to handle bgm1 end event
function onBgm1End() {
	// Set a timer to replay bgm1 after 50-80 seconds
	var bgmTimer = LK.setTimeout(function () {
		LK.playMusic('bgm1', {
			loop: true,
			fade: {
				start: 0,
				end: 1,
				duration: 4000
			},
			onEnd: onBgm1End
		});
	}, Math.random() * 30000 + 50000);
}
;
// Add the cat to the game
var cat = game.addChild(new Cat());
cat.x = 230; // Move the cat 20px to the left
cat.y = 2732; // Position the cat at the bottom of the screen
// Ensure cat is added to the game before setting its index
if (game.children.includes(cat)) {
	game.setChildIndex(cat, game.children.length - 1); // Bring the cat to the front by setting its index to the highest value
}
// Play bgm1 once on load and set a timer to replay it every 20-50 seconds
LK.playMusic('bgm1', {
	loop: false,
	// Play once
	fade: {
		start: 0,
		end: 0.02,
		// Set to the lowest volume
		duration: 4000
	},
	onEnd: function onEnd() {
		// Set a timer to replay bgm1 every 20-50 seconds
		LK.setTimeout(function () {
			LK.playMusic('bgm1', {
				loop: false,
				// Play once
				fade: {
					start: 0,
					end: 0.5,
					// Set to the lowest volume
					duration: 4000
				},
				onEnd: onEnd // Set the onEnd function to replay bgm1
			});
		}, Math.random() * 30000 + 20000); // Random time between 20-50 seconds
	}
});
// Initialize a timer to play the wings1 sound at a random time between 10 and 30 seconds
var wingsTimer = LK.setTimeout(function () {
	LK.getSound('wings1').play();
	wingsTimer = LK.setTimeout(arguments.callee, Math.random() * 20000 + 10000);
}, Math.random() * 20000 + 10000);
// Create an array for all sounds except ufo1, including all birdsong sounds
var sounds = ['cricket1', 'frog1', 'wings1', 'songbird1'];
var currentAmbientSound = null;
// Initialize random timers for each sound to play between 30-50 seconds
sounds.forEach(function (soundId) {
	var sound = LK.getSound(soundId);
	var ambientSoundTimer = LK.setTimeout(function () {
		if (currentAmbientSound) {
			currentAmbientSound.stop(); // Stop the currently playing ambient sound
		}
		sound.play();
		currentAmbientSound = sound; // Set the current ambient sound
		// Set a timeout to reset the current ambient sound after it finishes playing
		LK.setTimeout(function () {
			currentAmbientSound = null;
		}, sound.duration * 1000); // Convert duration from seconds to milliseconds
		// Reset the timer to play the sound again between 30-50 seconds, plus an additional 5 seconds
		ambientSoundTimer = LK.setTimeout(arguments.callee, Math.random() * 20000 + 30000 + 5000);
	}, Math.random() * 20000 + 30000);
});
function checkInteractions() {
	// Lasers vs Enemies
	game.layers.laser.children.forEach(function (laser) {
		game.layers.enemies.children.forEach(function (enemy) {
			if (laser.intersects(enemy)) {
				// Handle scoring and destruction
				if (enemy instanceof Bird1) {
					score += 5;
				} else if (enemy instanceof Bird2) {
					score += 1;
				} else if (enemy instanceof UFO) {
					score += 25;
				}
				if (enemy instanceof UFO) {
					// Make laser bounce away at 90 degrees
					var temp = laser.vx;
					laser.vx = -laser.vy;
					laser.vy = temp;
				} else {
					enemy.destroy();
					laser.destroy();
				}
				// Update score display if it exists
				if (scoreDisplay) {
					scoreDisplay.updateScore(score);
				}
			}
		});
	});
	// UFO vs Enemies
	var ufo = game.layers.enemies.children.find(function (child) {
		return child instanceof UFO;
	});
	if (ufo) {
		game.layers.enemies.children.forEach(function (enemy) {
			if (enemy !== ufo && ufo.intersects(enemy)) {
				enemy.destroy();
				LK.getSound('electro').play();
			}
		});
	}
}

===================================================================
--- original.js
+++ change.js
@@ -539,9 +539,16 @@
 // This is a duplicate checkInteractions function that has been consolidated elsewhere
 // Object placements are handled in the main initialization section
 // This is a duplicate addUFO function that has been consolidated elsewhere
 // Consolidated bird spawning functions
-// Consolidated bird spawning functions are inserted below
+// Function to spawn Bird2
+function spawnBird2() {
+	var bird2 = new Bird2();
+	bird2.x = Math.random() * 2048;
+	bird2.y = Math.random() * 2732;
+	birds.push(bird2);
+	game.layers.enemies.addChild(bird2);
+}
 var jetTimer = LK.setTimeout(function () {
 	var jet = new Jet();
 	jet.x = Math.random() < 0.5 ? 2048 + jet.width / 2 : -jet.width / 2;
 	jet.y = Math.random() * (2732 / 2 - jet.height);