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

/**** 
* Classes
****/ 
//<Write imports for supported plugins here>
// NyanCat class to represent the player character
var Chicken = Container.expand(function () {
	var self = Container.call(this);
	var chickenGraphics = self.attachAsset('NyanCat', {
		anchorX: 0.5,
		anchorY: 1
	});
	// Add a collision element inside the NyanCat
	var collisionElement = self.attachAsset('collisionElement', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: chickenGraphics.width * 0.4,
		height: chickenGraphics.height * 0.2
	});
	collisionElement.alpha = 0;
	collisionElement.y = -30; // Adjusted for NyanCat's shape
	chickenGraphics.y = 40; // Adjusted for NyanCat's shape
	self.speed = 8; // Increased from 5 to make the cat move faster horizontally
	self.jumpHeight = 400;
	self.isJumping = true;
	self.jumpVelocity = 0;
	self.update = function () {
		self.y += self.jumpVelocity;
		self.jumpVelocity += 1; // Gravity effect
		if (self.jumpVelocity > 30) {
			self.jumpVelocity = 30;
		}
		var targetPlatform = undefined;
		var isOnPlatform = platforms.some(function (platform) {
			if (collisionElement.intersects(platform)) {
				if (self.y - platform.y < 100) {
					targetPlatform = platform;
					return true;
				}
			}
		});
		if (isOnPlatform && self.jumpVelocity > 0) {
			// Ground level
			self.y = targetPlatform.y + 70;
			if (self.isJumping) {
				for (var a = 0; a < 30; a++) {
					particles.addDirtParticle(chicken.x, chicken.y);
				}
				chickenGraphics.scale.y = .8;
				chickenGraphics.scale.x = 1.2;
				tween(chickenGraphics, {
					scaleY: 1,
					scaleX: 1
				}, {
					duration: 1000,
					easing: tween.elasticOut
				});
			}
			self.isJumping = false;
			self.jumpVelocity = 0; // Reset jump velocity when hitting the ground
			// Apply a bounce effect using tween when the chicken lands
		}
		self.x = 2048 / 2; // Center the chicken horizontally
	};
	function groove() {
		tween(self, {
			scaleX: 1.03,
			scaleY: 1.03
		}, {
			duration: 300,
			onFinish: function onFinish() {
				tween(self, {
					scaleX: 1,
					scaleY: 1
				}, {
					onFinish: groove,
					duration: 300
				});
			}
		});
	}
	groove();
	self.jump = function (strength) {
		if (platforms[0].x > -1500) {
			return;
		}
		var isOnPlatform = platforms.some(function (platform) {
			if (collisionElement.intersects(platform)) {
				return self.y - platform.y < 100;
			}
		});
		if (!self.isJumping && isOnPlatform) {
			self.isJumping = true;
			for (var a = 0; a < 30; a++) {
				particles.addDirtParticle(chicken.x, chicken.y);
			}
			chicken.jumpVelocity = -40; // Fixed jump velocity - increased to jump higher
			self.update();
		}
	};
});
var Countdown = Container.expand(function () {
	var self = Container.call(this);
	var currentNumber = 16;
	var countdownTextShadow = new Text2("GO!", {
		size: 500,
		fill: 0x000000,
		weight: 800
	});
	var countdownText = new Text2("GO!", {
		size: 500,
		fill: 0xFFFFFF,
		weight: 800
	});
	countdownText.anchor.set(0.5, 0.5);
	countdownTextShadow.anchor.set(0.5, 0.5);
	self.addChild(countdownTextShadow);
	self.addChild(countdownText);
	self.x = 2048 / 2;
	self.y = 400;
	countdownTextShadow.x = 15;
	countdownTextShadow.y = 15;
	function tweenIt() {
		self.scale.set(1, 1);
		tween(self, {
			scaleX: .8,
			scaleY: .8
		}, {
			duration: 400,
			easing: tween.bounceOut
		});
	}
	var countdownInterval = LK.setInterval(function () {
		currentNumber--;
		if (currentNumber > 0) {
			countdownText.setText(currentNumber.toString());
			countdownTextShadow.setText(currentNumber.toString());
		} else {
			self.destroy();
			LK.clearInterval(countdownInterval);
			LK.effects.flashScreen(0xff0000, 3000); // Flash screen red for 1 second (1000ms) to show we are dead.
			LK.showGameOver();
		}
		tweenIt();
	}, 1000);
	tweenIt();
});
// DebugMarker class to visualize the pitch level
var DebugMarker = Container.expand(function () {
	var self = Container.call(this);
	var debugGraphics = self.attachAsset('debugMark', {
		anchorX: 0,
		anchorY: 0.5
	});
	// Set initial width
	debugGraphics.width = 1;
	// Update method will be called automatically
	self.update = function () {
		// Scale width based on mouth openness
		debugGraphics.width = facekit.mouthOpen ? 1000 : 100;
		// Change color based on mouth state
		debugGraphics.tint = facekit.mouthOpen ? 0x00ff00 : 0xff0000;
	};
	return self;
});
// DirtParticle class to represent a fading dirt particle
var DirtParticle = Container.expand(function () {
	var self = Container.call(this);
	var dirtGraphics = self.attachAsset('dirtparticle', {
		anchorX: 0.5,
		anchorY: 1
	});
	var speed = Math.random() * 3;
	var angle = -Math.random() * Math.PI;
	var scale = 1;
	// Update function to handle fading
	self.update = function () {
		scale -= 0.02; // Reduce alpha to fade out
		self.scale.set(scale, scale);
		if (scale <= 0) {
			self.destroy(); // Remove particle when fully transparent
		}
		self.x += Math.cos(angle) * speed;
		self.y += Math.sin(angle) * speed;
	};
});
// LargeBork class to represent the large bork overlay
var LargeBork = Container.expand(function () {
	var self = Container.call(this);
	self.moveMultiplier = 0;
	self.moveSpeed = -5; // Base move speed
	var largeBorkGraphicsChicken = self.attachAsset('NyanCat', {
		anchorX: 0.5,
		anchorY: 1
	});
	largeBorkGraphicsChicken.y = -50;
	var largeBorkGraphics = self.attachAsset('large_bork', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.update = function () {
		self.moveMultiplier = xspeed * 6;
		self.x += self.moveSpeed * self.moveMultiplier;
	};
	self.bork = function () {
		var speechBubbleLarge = new SpeechBubbleLarge();
		var offset = Math.PI / 4 * Math.random() - Math.PI / 2 - Math.PI / 4;
		speechBubbleLarge.x = -50 + Math.cos(offset) * 350;
		speechBubbleLarge.y = -100 + Math.sin(offset) * 350;
		speechBubbleLarge.rotation = offset + Math.PI * 0.5 + .3;
		self.addChild(speechBubbleLarge);
		largeBorkGraphicsChicken.scale.y = 1.05;
		largeBorkGraphicsChicken.scale.x = 1.05;
		largeBorkGraphicsChicken.rotation = .2;
		tween(largeBorkGraphicsChicken, {
			scaleY: 1,
			scaleX: 1,
			rotation: 0
		}, {
			duration: 1000,
			easing: tween.elasticOut
		});
	};
});
// Particles class to manage dirt particles
var Particles = Container.expand(function () {
	var self = Container.call(this);
	// Method to add a dirt particle at a specific position
	self.moveMultiplier = 0;
	self.moveSpeed = -5; // Base move speed
	self.addDirtParticle = function (x, y) {
		var dirtParticle = new DirtParticle();
		dirtParticle.x = x - self.x + Math.random() * 130 - 40;
		dirtParticle.y = y + 90;
		self.addChild(dirtParticle);
	};
	self.update = function () {
		self.moveMultiplier = xspeed * 6;
		self.x += self.moveSpeed * self.moveMultiplier;
	};
});
// Platform class to represent moving platforms
var Platform = Container.expand(function () {
	var self = Container.call(this);
	self.moveSpeed = -5; // Base move speed
	self.moveMultiplier = 1; // Default move multiplier
	var groundGraphics = self.attachAsset('ground', {
		anchorX: 0,
		anchorY: 0
	});
	self.width = groundGraphics.width;
	self.update = function () {
		self.moveMultiplier = xspeed * 6;
		self.x += self.moveSpeed * self.moveMultiplier;
		// If the platform moves off screen to the left, reposition it to the right
		/*if (self.x < -self.width) {
			// Reposition the platform to the right with a random gap
			self.x += self.width + 2048 + Math.random() * 1000;
		}*/ 
	};
});
var SpeechBubble = Container.expand(function () {
	var self = Container.call(this);
	var bubbleGraphics = self.attachAsset('small_bork_speach', {
		anchorX: 0.8,
		anchorY: 1
	});
	// Initial position and scale
	self.y -= 50;
	self.alpha = 1;
	// Update function to handle fading and moving up
	self.update = function () {
		self.y -= 1; // Move up
		self.alpha -= 0.01; // Fade out
		if (self.alpha <= 0) {
			self.destroy(); // Remove bubble when fully transparent
		}
	};
	// Apply a tween for smooth fading
	tween(self, {
		alpha: 0
	}, {
		duration: 2000,
		easing: tween.linear,
		onFinish: function onFinish() {
			self.destroy();
		}
	});
});
var SpeechBubbleLarge = Container.expand(function () {
	var self = Container.call(this);
	var bubbleGraphics = self.attachAsset('large_bork_speach', {
		anchorX: 0.2,
		anchorY: 1
	});
	// Initial position and scale
	self.y -= 50;
	self.alpha = 1;
	// Update function to handle fading and moving up
	self.scale.set(0, 0);
	tween(self, {
		scaleX: 1,
		scaleY: 1
	}, {
		duration: 800,
		easing: tween.elasticOut
	});
	// Apply a tween for smooth fading
	LK.setTimeout(function () {
		tween(self, {
			alpha: 0,
			y: self.y - 100
		}, {
			duration: 100,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				self.destroy();
			}
		});
	}, 800);
});
// Spikes class to represent dangerous spikes
var Spikes = Container.expand(function () {
	var self = Container.call(this);
	self.moveMultiplier = 0;
	self.moveSpeed = -5; // Base move speed
	var spikesGraphics = self.attachAsset('spikes', {
		anchorX: 0,
		anchorY: 0
	});
	self.update = function () {
		self.moveMultiplier = xspeed * 6;
		self.x += self.moveSpeed * self.moveMultiplier;
	};
});
// TrailManager class to manage trail particles behind the chicken
var TrailManager = Container.expand(function () {
	var self = Container.call(this);
	var trailParticles = [];
	var spawnInterval = 5; // Spawn a trail particle every 5 frames
	var trailLength = 20; // Maximum number of trail particles
	var frameCount = 0;
	self.update = function () {
		frameCount++;
		// Clean up old trail particles
		while (trailParticles.length > trailLength) {
			var oldParticle = trailParticles.shift();
			oldParticle.destroy();
		}
		// Create new trail particles
		if (frameCount % spawnInterval === 0 && chicken) {
			var particle = self.attachAsset('trail', {
				anchorX: 0.5,
				anchorY: 0.5,
				width: 30,
				height: 200
			});
			// Position the particle where the chicken is
			particle.x = chicken.x;
			particle.y = chicken.y;
			// Store creation time and add to array
			particle.creationTime = Date.now();
			trailParticles.push(particle);
			// Start with full size and opacity
			particle.scale.set(1, 1);
			particle.alpha = 0.8;
			// Animate the particle to fade out and shrink
			tween(particle, {
				alpha: 0,
				scaleX: 0.2,
				scaleY: 0.2
			}, {
				duration: 1000,
				easing: tween.linear,
				onFinish: function onFinish() {
					// Remove the particle when animation completes
					var index = trailParticles.indexOf(particle);
					if (index !== -1) {
						trailParticles.splice(index, 1);
					}
					particle.destroy();
				}
			});
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Create a volume label at the bottom right corner
var volumeLabel = new Text2('Volume: 0', {
	size: 50,
	fill: 0xFFFFFF
});
volumeLabel.anchor.set(1, 1); // Anchor to the bottom right corner
volumeLabel.alpha = .3;
LK.gui.bottomRight.addChild(volumeLabel);
// Create a mouth status label at the bottom left corner
var pitchLabel = new Text2('Mouth: closed', {
	size: 50,
	fill: 0xFFFFFF
});
pitchLabel.anchor.set(0, 1); // Anchor to the bottom left corner
pitchLabel.alpha = .3;
LK.gui.bottomLeft.addChild(pitchLabel);
// Initialize platforms 
function addPlatformAt(x, y) {
	var platform = game.addChild(new Platform());
	platform.x = x; //i * 1900 + i * Math.random() * 1000; // Space platforms with gaps
	platform.y = y; //2200; // Ground level
	platforms.push(platform);
	return platform;
}
var xspeed = 0;
var platforms = [];
addPlatformAt(1000, 2200);
addPlatformAt(2450, 2200);
addPlatformAt(3000 + 1500, 2200);
var platform3 = addPlatformAt(5000 + 1500, 1800);
var spikes = game.addChild(new Spikes());
spikes.x = platform3.x;
spikes.y = platform3.y - 1500; // position spikes higher above the platform
addPlatformAt(7000 + 1500, 2200);
var platform1 = platforms[0];
var smallBork = platform1.attachAsset('small_bork', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: platform1.width / 2 - 500,
	y: -550
});
var chickenBork = platform1.attachAsset('NyanCat', {
	anchorX: 0.5,
	anchorY: 1,
	x: smallBork.x - 50,
	y: -700
});
var platform2 = platforms[1];
var largeBork = game.addChild(new LargeBork());
largeBork.x = platform2.x + platform2.width + 250;
largeBork.y = platform2.y - 500;
var startFlag = platform2.attachAsset('start', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 130,
	y: -140
});
var lastPlatform = addPlatformAt(9000 + 1500, 1600);
var trophy = lastPlatform.attachAsset('trophy', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: lastPlatform.width / 2,
	y: -100
});
var boffset = 0;
function doSmallBork() {
	var speechBubble = new SpeechBubble();
	var offset = Math.PI / 2 * Math.random() - Math.PI / 2 - Math.PI / 4;
	speechBubble.x = smallBork.x - 25 + Math.cos(offset) * 150;
	speechBubble.y = smallBork.y - 150 + Math.sin(offset) * 150;
	speechBubble.rotation = offset + Math.PI * 0.5 - .1;
	platform1.addChild(speechBubble);
	LK.setTimeout(doSmallBork, 200 + Math.random() * 200);
	chickenBork.scale.y = 1.05;
	chickenBork.scale.x = 1.05;
	tween(chickenBork, {
		scaleY: 1,
		scaleX: 1
	}, {
		duration: 800,
		easing: tween.elasticOut
	});
	if (boffset++ % 3 == 0) {
		largeBork.bork();
	}
}
doSmallBork();
// Initialize chicken
//<Write imports for supported plugins here> 
var chicken = game.addChild(new Chicken());
var particles = game.addChild(new Particles());
var trailManager = game.addChild(new TrailManager());
Platform.prototype.chicken = chicken; // Make chicken accessible in Platform class
chicken.x = 2048 / 2; // Center the chicken horizontally
chicken.y = 2200; // Start the chicken at the ground level
// Add debug marker for visual pitch display
var pitchDebugMarker = game.addChild(new DebugMarker());
pitchDebugMarker.x = 50;
pitchDebugMarker.y = 2600; // Position near bottom of screen
pitchDebugMarker.alpha = 0.7; // Make it semi-transparent
var countdown;
// Update game logic 
game.update = function () {
	// Remove excess platforms if more than 3 exist
	/*while (platforms.length > 3) {
		var excessPlatform = platforms.shift();
		excessPlatform.destroy();
	}*/ 
	// Create and add a dirt particle at the chicken's position
	if (platform1.x < -500 && !countdown) {
		countdown = game.addChild(new Countdown());
	}
	if (!chicken.isJumping) {
		//if (facekit.volume > 0.05) 
		{
			xspeed += Math.max(facekit.volume, .5);
			particles.addDirtParticle(chicken.x, chicken.y);
		}
		xspeed *= .4;
	}
	if (facekit.mouthOpen && !chicken.isJumping) {
		chicken.jump(1.0); // Use a fixed value for jump strength
	}
	// Check if the chicken has fallen off the screen
	if (chicken.y > 3000) {
		// End the game if the chicken  has fallen off the screen
		LK.effects.flashScreen(0xff0000, 3000); // Flash screen red for 1 second (1000ms) to show we are dead.
		LK.showGameOver();
	}
	// Check if the chicken touches the spikes
	if (chicken.intersects(spikes)) {
		// End the game if the chicken touches the spikes
		LK.effects.flashScreen(0xff0000, 3000); // Flash screen red for 1 second (1000ms) to show we are dead.
		LK.showGameOver();
	}
	// Check if the chicken touches the trophy
	if (chicken.intersects(trophy)) {
		// End the game with a win if the chicken touches the trophy
		LK.showYouWin();
	}
	// Play the background music
	LK.playMusic('nyanLikeMusic');
	volumeLabel.setText('Volume: ' + facekit.volume.toFixed(2)); // Update volume label text
	pitchLabel.setText('Mouth: ' + (facekit.mouthOpen ? 'OPEN' : 'closed')); // Show mouth open status
};

===================================================================
--- original.js
+++ change.js
@@ -357,18 +357,16 @@
 			var particle = self.attachAsset('trail', {
 				anchorX: 0.5,
 				anchorY: 0.5,
 				width: 30,
-				height: 30
+				height: 200
 			});
 			// Position the particle where the chicken is
 			particle.x = chicken.x;
 			particle.y = chicken.y;
 			// Store creation time and add to array
 			particle.creationTime = Date.now();
 			trailParticles.push(particle);
-			// Apply random tint for rainbow effect
-			particle.tint = Math.random() * 0xFFFFFF;
 			// Start with full size and opacity
 			particle.scale.set(1, 1);
 			particle.alpha = 0.8;
 			// Animate the particle to fade out and shrink