/**** 
* 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 = 18 + Math.random() * 10; //{U}  // Reduced speed for slower falling stars
	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
****/ 
// --- Main Menu Overlay ---
var mainMenuOverlay = new Container();
mainMenuOverlay.visible = true;
// Ensure backgroundPlanets is always defined before menu background is created
if (typeof backgroundPlanets === "undefined" || !backgroundPlanets) backgroundPlanets = [];
// Take a screenshot of the game area for menu background (simulate by rendering planets and Nyan Cat in background)
function createMenuBackground() {
	// Remove all children from overlay
	while (mainMenuOverlay.children.length > 0) mainMenuOverlay.removeChildAt(0);
	// Add background planets (simulate by copying their positions)
	for (var i = 0; i < backgroundPlanets.length; i++) {
		var p = backgroundPlanets[i];
		var planet = LK.getAsset(p.assetId || p._assetId || p.id || 'planetBlue', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		planet.x = p.x;
		planet.y = p.y;
		planet.scaleX = planet.scaleY = p.scaleX || 1;
		planet.alpha = p.alpha || 0.18;
		mainMenuOverlay.addChild(planet);
	}
	// Add Nyan Cat in the center (large, faded)
	var menuCat = LK.getAsset('nyanCat', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	menuCat.x = 2048;
	menuCat.y = 1200;
	menuCat.scaleX = menuCat.scaleY = 2.2;
	menuCat.alpha = 0.18;
	mainMenuOverlay.addChild(menuCat);
}
// Game Title
var titleText = new Text2('NYAN CAT SPACE RUN', {
	size: 220,
	fill: "#fff",
	font: "Impact, Arial Black, Tahoma"
});
titleText.anchor.set(0.5, 0.5);
titleText.x = 2048;
titleText.y = 420;
mainMenuOverlay.addChild(titleText);
// Play Button
var playBtnBg = LK.getAsset('planetYellow', {
	anchorX: 0.5,
	anchorY: 0.5
});
playBtnBg.x = 2048;
playBtnBg.y = 1200 + 420;
playBtnBg.scaleX = playBtnBg.scaleY = 2.2;
mainMenuOverlay.addChild(playBtnBg);
var playBtnText = new Text2('OYNA', {
	size: 180,
	fill: "#222"
});
playBtnText.anchor.set(0.5, 0.5);
playBtnText.x = 2048;
playBtnText.y = 1200 + 420;
mainMenuOverlay.addChild(playBtnText);
// Play button interaction
mainMenuOverlay.down = function (x, y, obj) {
	// Check if touch is inside play button
	var dx = x - playBtnBg.x;
	var dy = y - playBtnBg.y;
	var r = playBtnBg.width * playBtnBg.scaleX * 0.5;
	if (dx * dx + dy * dy < r * r) {
		// Hide menu, start game
		mainMenuOverlay.visible = false;
		game.paused = false;
		// Reset game state
		LK.setScore(0);
		scoreTxt.setText('0');
		for (var i = 0; i < obstacles.length; i++) obstacles[i].destroy();
		obstacles = [];
		for (var j = 0; j < treats.length; j++) treats[j].destroy();
		treats = [];
		nyanCat.x = 3840 * 0.25;
		nyanCat.y = 2160 * 0.6;
		nyanCatBaseY = nyanCat.y;
		speed = baseSpeed;
		spawnInterval = 70;
		treatInterval = 110;
		dragNode = null;
		lastHit = false;
		// Resume music
		LK.playMusic('nyanMusic');
	}
};
mainMenuOverlay.move = function (x, y, obj) {};
mainMenuOverlay.up = function (x, y, obj) {};
// Add overlay to GUI (centered, covers all)
LK.gui.center.addChild(mainMenuOverlay);
// Show menu at start
game.paused = true;
createMenuBackground();
// Animate planets in menu
LK.on('tick', function () {
	if (mainMenuOverlay.visible) {
		// Animate title
		titleText.y = 420 + Math.sin(LK.ticks * 0.06) * 24;
		titleText.scaleX = titleText.scaleY = 1.0 + Math.sin(LK.ticks * 0.09) * 0.04;
		// Animate play button
		playBtnBg.scaleX = playBtnBg.scaleY = 2.2 + Math.sin(LK.ticks * 0.13) * 0.13;
		playBtnText.scaleX = playBtnText.scaleY = 1.0 + Math.sin(LK.ticks * 0.13) * 0.04;
	}
});
// Animate background planets (subtle drifting and glow, and spawn new ones as needed)
var backgroundPlanets = [];
// Sparkle and nebula arrays for lively background
if (!game.backgroundSparkles) game.backgroundSparkles = [];
if (!game.backgroundNebulas) game.backgroundNebulas = [];
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;
}
// --- Sparkle background effect ---
if (game.backgroundSparkles.length < 32 && Math.random() < 0.18) {
	// Add a new sparkle at random position, random size
	var sparkle = LK.getAsset('star', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 0.13 + Math.random() * 0.11,
		scaleY: 0.13 + Math.random() * 0.11
	});
	sparkle.x = Math.random() * (GAME_RIGHT + 400) - 200;
	sparkle.y = Math.random() * (GAME_BOTTOM + 400) - 200;
	sparkle.alpha = 0.13 + Math.random() * 0.13;
	sparkle._twinklePhase = Math.random() * Math.PI * 2;
	sparkle._twinkleSpeed = 0.04 + Math.random() * 0.07;
	sparkle._baseAlpha = sparkle.alpha;
	sparkle._baseScale = sparkle.scaleX;
	game.backgroundSparkles.push(sparkle);
	game.addChildAt(sparkle, 0);
}
// Animate sparkles
for (var s = game.backgroundSparkles.length - 1; s >= 0; s--) {
	var sparkle = game.backgroundSparkles[s];
	// Twinkle alpha and scale
	sparkle._twinklePhase += sparkle._twinkleSpeed;
	sparkle.alpha = sparkle._baseAlpha * (0.7 + 0.6 * Math.abs(Math.sin(sparkle._twinklePhase)));
	sparkle.scaleX = sparkle.scaleY = sparkle._baseScale * (0.9 + 0.2 * Math.abs(Math.cos(sparkle._twinklePhase * 0.7)));
	// Slow drift
	sparkle.x += Math.sin(sparkle._twinklePhase * 0.5) * 0.13;
	sparkle.y += Math.cos(sparkle._twinklePhase * 0.5) * 0.13;
	// Remove if off screen
	if (sparkle.x < -300 || sparkle.x > GAME_RIGHT + 300 || sparkle.y < -300 || sparkle.y > GAME_BOTTOM + 300) {
		if (sparkle.destroy) sparkle.destroy();
		game.backgroundSparkles.splice(s, 1);
	}
}
// --- Nebula cloud effect (soft colored clouds drifting) ---
if (game.backgroundNebulas.length < 5 && Math.random() < 0.04) {
	var nebulaColors = [0xf9d423, 0x9b59b6, 0x4a90e2, 0x7ed957, 0xe94e77];
	var color = nebulaColors[Math.floor(Math.random() * nebulaColors.length)];
	var nebula = LK.getAsset('cloud', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 1.2 + Math.random() * 1.8,
		scaleY: 1.2 + Math.random() * 1.8
	});
	nebula.x = GAME_RIGHT + 400 + Math.random() * 400;
	nebula.y = 200 + Math.random() * (GAME_BOTTOM - 400);
	nebula.alpha = 0.08 + Math.random() * 0.08;
	nebula.tint = color;
	nebula._speed = 0.18 + Math.random() * 0.22;
	nebula._drift = 0.12 + Math.random() * 0.13;
	nebula._driftPhase = Math.random() * Math.PI * 2;
	game.backgroundNebulas.push(nebula);
	game.addChildAt(nebula, 0);
}
// Animate nebulas
for (var n = game.backgroundNebulas.length - 1; n >= 0; n--) {
	var nebula = game.backgroundNebulas[n];
	nebula.x -= nebula._speed;
	nebula._driftPhase += nebula._drift;
	nebula.y += Math.sin(nebula._driftPhase) * 0.7;
	// Subtle alpha pulsing
	nebula.alpha = Math.abs(Math.sin(LK.ticks * 0.006 + n)) * 0.04 + 0.08;
	// Remove if off screen
	if (nebula.x < -600) {
		if (nebula.destroy) nebula.destroy();
		game.backgroundNebulas.splice(n, 1);
	}
}
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
@@ -288,8 +288,11 @@
 	}
 });
 // Animate background planets (subtle drifting and glow, and spawn new ones as needed)
 var backgroundPlanets = [];
+// Sparkle and nebula arrays for lively background
+if (!game.backgroundSparkles) game.backgroundSparkles = [];
+if (!game.backgroundNebulas) game.backgroundNebulas = [];
 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
@@ -327,8 +330,77 @@
 	// 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;
 }
+// --- Sparkle background effect ---
+if (game.backgroundSparkles.length < 32 && Math.random() < 0.18) {
+	// Add a new sparkle at random position, random size
+	var sparkle = LK.getAsset('star', {
+		anchorX: 0.5,
+		anchorY: 0.5,
+		scaleX: 0.13 + Math.random() * 0.11,
+		scaleY: 0.13 + Math.random() * 0.11
+	});
+	sparkle.x = Math.random() * (GAME_RIGHT + 400) - 200;
+	sparkle.y = Math.random() * (GAME_BOTTOM + 400) - 200;
+	sparkle.alpha = 0.13 + Math.random() * 0.13;
+	sparkle._twinklePhase = Math.random() * Math.PI * 2;
+	sparkle._twinkleSpeed = 0.04 + Math.random() * 0.07;
+	sparkle._baseAlpha = sparkle.alpha;
+	sparkle._baseScale = sparkle.scaleX;
+	game.backgroundSparkles.push(sparkle);
+	game.addChildAt(sparkle, 0);
+}
+// Animate sparkles
+for (var s = game.backgroundSparkles.length - 1; s >= 0; s--) {
+	var sparkle = game.backgroundSparkles[s];
+	// Twinkle alpha and scale
+	sparkle._twinklePhase += sparkle._twinkleSpeed;
+	sparkle.alpha = sparkle._baseAlpha * (0.7 + 0.6 * Math.abs(Math.sin(sparkle._twinklePhase)));
+	sparkle.scaleX = sparkle.scaleY = sparkle._baseScale * (0.9 + 0.2 * Math.abs(Math.cos(sparkle._twinklePhase * 0.7)));
+	// Slow drift
+	sparkle.x += Math.sin(sparkle._twinklePhase * 0.5) * 0.13;
+	sparkle.y += Math.cos(sparkle._twinklePhase * 0.5) * 0.13;
+	// Remove if off screen
+	if (sparkle.x < -300 || sparkle.x > GAME_RIGHT + 300 || sparkle.y < -300 || sparkle.y > GAME_BOTTOM + 300) {
+		if (sparkle.destroy) sparkle.destroy();
+		game.backgroundSparkles.splice(s, 1);
+	}
+}
+// --- Nebula cloud effect (soft colored clouds drifting) ---
+if (game.backgroundNebulas.length < 5 && Math.random() < 0.04) {
+	var nebulaColors = [0xf9d423, 0x9b59b6, 0x4a90e2, 0x7ed957, 0xe94e77];
+	var color = nebulaColors[Math.floor(Math.random() * nebulaColors.length)];
+	var nebula = LK.getAsset('cloud', {
+		anchorX: 0.5,
+		anchorY: 0.5,
+		scaleX: 1.2 + Math.random() * 1.8,
+		scaleY: 1.2 + Math.random() * 1.8
+	});
+	nebula.x = GAME_RIGHT + 400 + Math.random() * 400;
+	nebula.y = 200 + Math.random() * (GAME_BOTTOM - 400);
+	nebula.alpha = 0.08 + Math.random() * 0.08;
+	nebula.tint = color;
+	nebula._speed = 0.18 + Math.random() * 0.22;
+	nebula._drift = 0.12 + Math.random() * 0.13;
+	nebula._driftPhase = Math.random() * Math.PI * 2;
+	game.backgroundNebulas.push(nebula);
+	game.addChildAt(nebula, 0);
+}
+// Animate nebulas
+for (var n = game.backgroundNebulas.length - 1; n >= 0; n--) {
+	var nebula = game.backgroundNebulas[n];
+	nebula.x -= nebula._speed;
+	nebula._driftPhase += nebula._drift;
+	nebula.y += Math.sin(nebula._driftPhase) * 0.7;
+	// Subtle alpha pulsing
+	nebula.alpha = Math.abs(Math.sin(LK.ticks * 0.006 + n)) * 0.04 + 0.08;
+	// Remove if off screen
+	if (nebula.x < -600) {
+		if (nebula.destroy) nebula.destroy();
+		game.backgroundNebulas.splice(n, 1);
+	}
+}
 function spawnBackgroundPlanets() {
 	// Remove any existing
 	for (var i = 0; i < backgroundPlanets.length; i++) {
 		backgroundPlanets[i].destroy();