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

/**** 
* Classes
****/ 
// Nyan Cat class
var NyanCat = Container.expand(function () {
	var self = Container.call(this);
	// Rainbow trail (visual only, not collidable)
	var rainbow = self.attachAsset('rainbow', {
		anchorX: 1,
		anchorY: 0.5,
		x: -90,
		y: 0,
		scaleY: 1.2
	});
	// Add a soft highlight to rainbow for polish
	rainbow.alpha = 0.92;
	rainbow.tint = 0xffe0fa;
	// Nyan Cat sprite
	var cat = self.attachAsset('nyanCat', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 0,
		y: 0
	});
	// Add a soft shadow to Nyan Cat for depth
	cat.alpha = 1;
	cat.tint = 0xffffff;
	self.catShadow = LK.getAsset('nyanCat', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 8,
		y: 18
	});
	self.catShadow.alpha = 0.22;
	self.catShadow.tint = 0x000000;
	self.addChildAt(self.catShadow, 0);
	// For collision, use the cat's bounds (not rainbow)
	self.getCollisionBounds = function () {
		return {
			x: self.x - cat.width / 2,
			y: self.y - cat.height / 2,
			width: cat.width,
			height: cat.height
		};
	};
	// Flash effect on hit
	self.flash = function () {
		tween(cat, {
			alpha: 0.3
		}, {
			duration: 80,
			onFinish: function onFinish() {
				tween(cat, {
					alpha: 1
				}, {
					duration: 120
				});
			}
		});
	};
	// Rainbow parallax movement for quality polish
	self.update = function () {
		// Rainbow trail parallax: slight horizontal movement for visual polish
		rainbow.x = -90 + Math.sin(LK.ticks * 0.12) * 12;
		// Bobbing handled in main update
	};
	return self;
});
// Obstacle class (cloud or star)
var Obstacle = Container.expand(function () {
	var self = Container.call(this);
	// Randomly choose cloud or star
	var isStar = Math.random() < 0.4;
	var assetId = isStar ? 'star' : 'cloud';
	var asset = self.attachAsset(assetId, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Add soft shadow for depth
	self.shadow = self.attachAsset(assetId, {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 10,
		y: 18
	});
	self.shadow.alpha = 0.18;
	self.shadow.tint = 0x000000;
	self.addChildAt(self.shadow, 0);
	self.isStar = isStar;
	// For collision
	self.getCollisionBounds = function () {
		return {
			x: self.x - asset.width / 2,
			y: self.y - asset.height / 2,
			width: asset.width,
			height: asset.height
		};
	};
	// Speed will be set on spawn
	self.speed = 0;
	self.update = function () {
		self.x -= self.speed;
	};
	return self;
});
// Shooting Star class for lively background
var ShootingStar = Container.expand(function () {
	var self = Container.call(this);
	// Use the 'star' asset, small and bright
	var star = self.attachAsset('star', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 0.32,
		scaleY: 0.32
	});
	self.star = star;
	// Randomize speed and angle
	self.speed = 38 + Math.random() * 22;
	self.angle = Math.PI * (0.18 + Math.random() * 0.12); // ~10deg downward
	self.alpha = 0.7 + Math.random() * 0.3;
	// Trail effect (simple, fade out)
	self.update = function () {
		self.x += Math.cos(self.angle) * self.speed;
		self.y += Math.sin(self.angle) * self.speed;
		self.alpha -= 0.018 + Math.random() * 0.008;
		if (self.alpha <= 0.01) {
			self.destroy();
		}
	};
	return self;
});
// Treat class (collectible)
var Treat = Container.expand(function () {
	var self = Container.call(this);
	var treat = self.attachAsset('treat', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Add soft shadow for treat
	self.shadow = self.attachAsset('treat', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 10,
		y: 18
	});
	self.shadow.alpha = 0.18;
	self.shadow.tint = 0x000000;
	self.addChildAt(self.shadow, 0);
	// For collision
	self.getCollisionBounds = function () {
		return {
			x: self.x - treat.width / 2,
			y: self.y - treat.height / 2,
			width: treat.width,
			height: treat.height
		};
	};
	// Speed will be set on spawn
	self.speed = 0;
	self.update = function () {
		self.x -= self.speed;
	};
	return self;
});

/**** 
* Initialize Game
****/ 
var game = new LK.Game({
	// No title, no description
	// Always backgroundColor is black
	backgroundColor: 0x000000
});

/**** 
* Game Code
****/ 
var backgroundPlanets = [];
// Animate background planets (subtle drifting and glow, and spawn new ones as needed)
for (var i = backgroundPlanets.length - 1; i >= 0; i--) {
	var p = backgroundPlanets[i];
	// Parallax horizontal movement for planets (move left, speed up with game speed)
	p.x -= (0.7 + speed * 0.18) * (1 + p.drift * 2); // Parallax speed based on drift and game speed
	// If planet is off screen to the left, remove and spawn a new one at right
	if (p.x < -500) {
		p.destroy();
		backgroundPlanets.splice(i, 1);
		// Randomly pick a planet type
		var planetTypes = ['planetBlue', 'planetGreen', 'planetPurple', 'planetRed', 'planetYellow'];
		var newId = planetTypes[Math.floor(Math.random() * planetTypes.length)];
		var newScale = 0.8 + Math.random() * 0.8;
		var newAlpha = 0.12 + Math.random() * 0.13;
		var newDrift = 0.04 + Math.random() * 0.08;
		var newDriftMag = 18 + Math.random() * 30;
		var newY = 300 + Math.random() * (GAME_BOTTOM - 600);
		var newPlanet = LK.getAsset(newId, {
			anchorX: 0.5,
			anchorY: 0.5
		});
		newPlanet.x = GAME_RIGHT + 500 + Math.random() * 400;
		newPlanet.y = newY;
		newPlanet.scaleX = newPlanet.scaleY = newScale;
		newPlanet.alpha = newAlpha;
		newPlanet.drift = newDrift;
		newPlanet.driftMag = newDriftMag;
		backgroundPlanets.push(newPlanet);
		game.addChildAt(newPlanet, 0);
		continue;
	}
	// Subtle drifting
	p.x += Math.sin(LK.ticks * p.drift + i) * 0.2;
	p.y += Math.cos(LK.ticks * p.drift + i) * 0.2;
	// Subtle alpha pulsing for glow
	p.alpha = Math.abs(Math.sin(LK.ticks * 0.008 + i)) * 0.08 + 0.13 + p.drift * 0.7;
	// Twinkle effect: scale planets up/down slightly for more life
	var twinkle = 1 + Math.sin(LK.ticks * 0.04 + i * 1.7) * 0.018;
	p.scaleX = p.scaleY = (p.scaleX || 1) * twinkle;
}
function spawnBackgroundPlanets() {
	// Remove any existing
	for (var i = 0; i < backgroundPlanets.length; i++) {
		backgroundPlanets[i].destroy();
	}
	backgroundPlanets = [];
	// Place a few planets at random positions, different depths/colors
	var planetDefs = [{
		id: 'planetBlue',
		x: 900,
		y: 400,
		scale: 1.2,
		alpha: 0.22,
		drift: 0.08,
		driftMag: 40
	}, {
		id: 'planetGreen',
		x: 3200,
		y: 600,
		scale: 1.1,
		alpha: 0.18,
		drift: 0.06,
		driftMag: 30
	}, {
		id: 'planetPurple',
		x: 2600,
		y: 1700,
		scale: 1.4,
		alpha: 0.16,
		drift: 0.07,
		driftMag: 36
	}, {
		id: 'planetRed',
		x: 1800,
		y: 1400,
		scale: 1.0,
		alpha: 0.19,
		drift: 0.09,
		driftMag: 28
	}, {
		id: 'planetYellow',
		x: 3400,
		y: 1800,
		scale: 0.9,
		alpha: 0.13,
		drift: 0.05,
		driftMag: 22
	}];
	for (var i = 0; i < planetDefs.length; i++) {
		var def = planetDefs[i];
		var planet = LK.getAsset(def.id, {
			anchorX: 0.5,
			anchorY: 0.5
		});
		planet.x = def.x;
		planet.y = def.y;
		planet.scaleX = planet.scaleY = def.scale;
		planet.alpha = def.alpha;
		planet.drift = def.drift;
		planet.driftMag = def.driftMag;
		backgroundPlanets.push(planet);
		game.addChildAt(planet, 0); // Always behind everything
	}
}
spawnBackgroundPlanets();
// Music
// Sound effects
// Rainbow trail
// Treat (pop tart)
// Obstacle (star)
// Obstacle (cloud)
// Nyan Cat (main character)
// Game area margins
var GAME_TOP = 0;
var GAME_BOTTOM = 2160;
var GAME_LEFT = 0;
var GAME_RIGHT = 3840;
// Avoid top left 100x100 for menu
var SAFE_TOP = 120;
// Main character
var nyanCat = new NyanCat();
game.addChild(nyanCat);
// Center Nyan Cat horizontally, place at 60% height
nyanCat.x = 3840 * 0.25;
nyanCat.y = 2160 * 0.6;
var nyanCatBaseY = nyanCat.y;
// Score display
var scoreTxt = new Text2('0', {
	size: 220,
	fill: "#fff"
});
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
// Arrays for obstacles and treats
var obstacles = [];
var treats = [];
// Difficulty parameters
var baseSpeed = 12;
var speed = baseSpeed;
var spawnInterval = 70; // ticks between spawns
var treatInterval = 110; // ticks between treat spawns
var minSpawnInterval = 30;
var maxSpeed = 32;
// Dragging
var dragNode = null;
// Last collision state
var lastHit = false;
// Play music
LK.playMusic('nyanMusic');
// Helper: collision check (AABB)
function isColliding(a, b) {
	var ab = a.getCollisionBounds();
	var bb = b.getCollisionBounds();
	return ab.x < bb.x + bb.width && ab.x + ab.width > bb.x && ab.y < bb.y + bb.height && ab.y + ab.height > bb.y;
}
// Move handler (drag Nyan Cat)
function handleMove(x, y, obj) {
	if (dragNode) {
		// Clamp to game area, avoid top left 100x100
		var cat = dragNode;
		var bounds = cat.getCollisionBounds();
		var halfW = bounds.width / 2;
		var halfH = bounds.height / 2;
		var minX = GAME_LEFT + halfW;
		var maxX = GAME_RIGHT - halfW;
		var minY = Math.max(GAME_TOP + halfH, SAFE_TOP + halfH);
		var maxY = GAME_BOTTOM - halfH;
		cat.x = Math.max(minX, Math.min(maxX, x));
		cat.y = Math.max(minY, Math.min(maxY, y));
	}
}
game.move = handleMove;
game.down = function (x, y, obj) {
	// Only allow drag if touch is on Nyan Cat
	var bounds = nyanCat.getCollisionBounds();
	if (x >= bounds.x && x <= bounds.x + bounds.width && y >= bounds.y && y <= bounds.y + bounds.height) {
		dragNode = nyanCat;
		handleMove(x, y, obj);
	}
};
game.up = function (x, y, obj) {
	dragNode = null;
};
// Game update loop
game.update = function () {
	// Only planets are used for the space background; no starfield, clouds, or other backgrounds
	// Animate shooting stars for lively background
	if (!game.shootingStars) game.shootingStars = [];
	// Spawn a shooting star at random intervals
	if (LK.ticks % 23 === 0 && Math.random() < 0.45) {
		var star = new ShootingStar();
		// Start at random X on left, random Y in upper half
		star.x = Math.random() * 1200;
		star.y = 80 + Math.random() * 900;
		game.shootingStars.push(star);
		game.addChildAt(star, 1); // Behind main gameplay
	}
	// Update and clean up shooting stars
	for (var s = game.shootingStars.length - 1; s >= 0; s--) {
		var star = game.shootingStars[s];
		if (star.destroyed || star.alpha <= 0.01 || star.x > GAME_RIGHT + 200 || star.y > GAME_BOTTOM + 200) {
			if (!star.destroyed) star.destroy();
			game.shootingStars.splice(s, 1);
			continue;
		}
		star.update();
	}
	// Increase difficulty over time
	if (LK.ticks % 180 === 0 && speed < maxSpeed) {
		speed += 1.2;
		spawnInterval = Math.max(minSpawnInterval, spawnInterval - 4);
	}
	// Spawn obstacles
	if (LK.ticks % spawnInterval === 0) {
		var obs = new Obstacle();
		obs.speed = speed;
		// Random Y, avoid top 100px
		var asset = obs.children[0];
		var minY = SAFE_TOP + asset.height / 2;
		var maxY = GAME_BOTTOM - asset.height / 2;
		obs.x = GAME_RIGHT + asset.width / 2 + 10;
		obs.y = Math.random() * (maxY - minY) + minY;
		obstacles.push(obs);
		game.addChild(obs);
	}
	// Spawn treats
	if (LK.ticks % treatInterval === 0) {
		var treat = new Treat();
		treat.speed = speed * 0.95;
		var asset = treat.children[0];
		var minY = SAFE_TOP + asset.height / 2;
		var maxY = GAME_BOTTOM - asset.height / 2;
		treat.x = GAME_RIGHT + asset.width / 2 + 10;
		treat.y = Math.random() * (maxY - minY) + minY;
		treats.push(treat);
		game.addChild(treat);
	}
	// Update obstacles
	for (var i = obstacles.length - 1; i >= 0; i--) {
		var obs = obstacles[i];
		obs.update();
		// Twinkle and pulse for obstacles (clouds/stars)
		if (obs.children && obs.children.length > 1) {
			var obsSprite = obs.children[1];
			obsSprite.rotation = Math.sin(LK.ticks * 0.09 + i) * 0.13;
			obsSprite.scaleX = 1 + Math.sin(LK.ticks * 0.15 + i) * 0.09;
			obsSprite.scaleY = 1 + Math.cos(LK.ticks * 0.13 + i) * 0.09;
		}
		// Remove if off screen
		if (obs.x < -300) {
			obs.destroy();
			obstacles.splice(i, 1);
			continue;
		}
		// Collision with Nyan Cat
		var hit = isColliding(obs, nyanCat);
		if (hit && !lastHit) {
			// Flash, play sound, game over
			nyanCat.flash();
			LK.getSound('hit').play();
			LK.effects.flashScreen(0xff0000, 800);
			LK.showGameOver();
			lastHit = true;
			break; // Stop further checks
		}
	}
	// Update treats
	for (var j = treats.length - 1; j >= 0; j--) {
		var treat = treats[j];
		treat.update();
		// Twinkle effect for treats (make them pulse and rotate for more life)
		if (treat.children && treat.children.length > 1) {
			var treatSprite = treat.children[1];
			treatSprite.rotation = Math.sin(LK.ticks * 0.13 + j) * 0.18;
			treatSprite.scaleX = 1 + Math.sin(LK.ticks * 0.19 + j) * 0.13;
			treatSprite.scaleY = 1 + Math.cos(LK.ticks * 0.17 + j) * 0.13;
		}
		// Remove if off screen
		if (treat.x < -200) {
			treat.destroy();
			treats.splice(j, 1);
			continue;
		}
		// Collision with Nyan Cat
		if (isColliding(treat, nyanCat)) {
			LK.setScore(LK.getScore() + 1);
			scoreTxt.setText(LK.getScore());
			LK.getSound('collect').play();
			// Animate treat
			tween(treat, {
				scaleX: 2.1,
				scaleY: 2.1,
				alpha: 0
			}, {
				duration: 220,
				ease: "outBack",
				onFinish: function onFinish() {
					treat.destroy();
				}
			});
			treats.splice(j, 1);
			continue;
		}
	}
	// Nyan Cat idle bobbing and lively animation
	if (!dragNode) {
		nyanCat.y = nyanCatBaseY + Math.sin(LK.ticks * 0.08) * 22;
		// Subtle rotation and scale for lively effect
		if (nyanCat.children && nyanCat.children.length > 1) {
			var catSprite = nyanCat.children[1];
			catSprite.rotation = Math.sin(LK.ticks * 0.07) * 0.08;
			catSprite.scaleX = 1 + Math.sin(LK.ticks * 0.11) * 0.04;
			catSprite.scaleY = 1 + Math.cos(LK.ticks * 0.13) * 0.04;
		}
		// Subtle color pulsing for rainbow trail
		if (nyanCat.children && nyanCat.children.length > 0) {
			var rainbowSprite = nyanCat.children[0];
			var baseTint = 0xffe0fa;
			var pulse = Math.floor(0x20 * (1 + Math.sin(LK.ticks * 0.09)));
			// Animate tint between pink and yellowish
			rainbowSprite.tint = 0xffe0fa + (pulse << 8);
		}
	}
	// Reset lastHit if not colliding
	if (!obstacles.some(function (obs) {
		return isColliding(obs, nyanCat);
	})) {
		lastHit = false;
	}
};
// Reset score and all game state on game start
LK.setScore(0);
scoreTxt.setText('0');
// Remove all obstacles and treats from game
for (var i = 0; i < obstacles.length; i++) {
	obstacles[i].destroy();
}
obstacles = [];
for (var j = 0; j < treats.length; j++) {
	treats[j].destroy();
}
treats = [];
// Reset Nyan Cat position and base Y
nyanCat.x = 3840 * 0.25;
nyanCat.y = 2160 * 0.6;
nyanCatBaseY = nyanCat.y;
// Reset difficulty
speed = baseSpeed;
spawnInterval = 70;
treatInterval = 110;
// Reset drag and collision state
dragNode = null;
lastHit = false;

===================================================================
--- original.js
+++ change.js
@@ -421,8 +421,15 @@
 	// Update obstacles
 	for (var i = obstacles.length - 1; i >= 0; i--) {
 		var obs = obstacles[i];
 		obs.update();
+		// Twinkle and pulse for obstacles (clouds/stars)
+		if (obs.children && obs.children.length > 1) {
+			var obsSprite = obs.children[1];
+			obsSprite.rotation = Math.sin(LK.ticks * 0.09 + i) * 0.13;
+			obsSprite.scaleX = 1 + Math.sin(LK.ticks * 0.15 + i) * 0.09;
+			obsSprite.scaleY = 1 + Math.cos(LK.ticks * 0.13 + i) * 0.09;
+		}
 		// Remove if off screen
 		if (obs.x < -300) {
 			obs.destroy();
 			obstacles.splice(i, 1);
@@ -443,8 +450,15 @@
 	// Update treats
 	for (var j = treats.length - 1; j >= 0; j--) {
 		var treat = treats[j];
 		treat.update();
+		// Twinkle effect for treats (make them pulse and rotate for more life)
+		if (treat.children && treat.children.length > 1) {
+			var treatSprite = treat.children[1];
+			treatSprite.rotation = Math.sin(LK.ticks * 0.13 + j) * 0.18;
+			treatSprite.scaleX = 1 + Math.sin(LK.ticks * 0.19 + j) * 0.13;
+			treatSprite.scaleY = 1 + Math.cos(LK.ticks * 0.17 + j) * 0.13;
+		}
 		// Remove if off screen
 		if (treat.x < -200) {
 			treat.destroy();
 			treats.splice(j, 1);
@@ -480,8 +494,16 @@
 			catSprite.rotation = Math.sin(LK.ticks * 0.07) * 0.08;
 			catSprite.scaleX = 1 + Math.sin(LK.ticks * 0.11) * 0.04;
 			catSprite.scaleY = 1 + Math.cos(LK.ticks * 0.13) * 0.04;
 		}
+		// Subtle color pulsing for rainbow trail
+		if (nyanCat.children && nyanCat.children.length > 0) {
+			var rainbowSprite = nyanCat.children[0];
+			var baseTint = 0xffe0fa;
+			var pulse = Math.floor(0x20 * (1 + Math.sin(LK.ticks * 0.09)));
+			// Animate tint between pink and yellowish
+			rainbowSprite.tint = 0xffe0fa + (pulse << 8);
+		}
 	}
 	// Reset lastHit if not colliding
 	if (!obstacles.some(function (obs) {
 		return isColliding(obs, nyanCat);