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

/**** 
* Classes
****/ 
// Define a class for enemies
var Enemy = Container.expand(function () {
	var self = Container.call(this);
	var enemyGraphics = self.attachAsset('enemy', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 5;
	// Start continuous rotation animation for the world/enemy
	tween(enemyGraphics, {
		rotation: enemyGraphics.rotation + Math.PI * 2
	}, {
		duration: 4000,
		easing: tween.linear,
		onFinish: function onFinish() {
			// Restart rotation animation continuously
			self.startRotation();
		}
	});
	self.startRotation = function () {
		tween(enemyGraphics, {
			rotation: enemyGraphics.rotation + Math.PI * 2
		}, {
			duration: 4000,
			easing: tween.linear,
			onFinish: function onFinish() {
				self.startRotation();
			}
		});
	};
	self.update = function () {
		self.x -= self.speed;
		if (self.x < -50) {
			self.destroy();
		}
	};
	return self;
});

/**** 
* Initialize Game
****/ 
var game = new LK.Game({
	backgroundColor: 0x0B0B2F // Dark space blue background
});

/**** 
* Game Code
****/ 
// Galaxy pixel theme assets
// Create galaxy pixel theme space elements arrays
var stars = [];
var bigStars = [];
var galaxies = [];
var planets = [];
var backgroundSpeed = 2; // Speed of background scrolling
// Generate pixel stars
for (var i = 0; i < 200; i++) {
	var star = game.addChild(LK.getAsset('star', {
		anchorX: 0.5,
		anchorY: 0.5
	}));
	star.x = Math.random() * 2048;
	star.y = Math.random() * 2732;
	star.alpha = Math.random() * 0.9 + 0.1;
	stars.push(star);
}
// Generate bigger pixel stars
for (var i = 0; i < 50; i++) {
	var bigStar = game.addChild(LK.getAsset('bigStar', {
		anchorX: 0.5,
		anchorY: 0.5
	}));
	bigStar.x = Math.random() * 2048;
	bigStar.y = Math.random() * 2732;
	bigStar.alpha = Math.random() * 0.8 + 0.2;
	bigStars.push(bigStar);
}
// Generate pixel galaxies
for (var i = 0; i < 12; i++) {
	var galaxy = game.addChild(LK.getAsset('galaxy', {
		anchorX: 0.5,
		anchorY: 0.5
	}));
	galaxy.x = Math.random() * 2048;
	galaxy.y = Math.random() * 2732;
	galaxy.alpha = Math.random() * 0.6 + 0.2;
	galaxy.scaleX = Math.random() * 1.2 + 0.8;
	galaxy.scaleY = Math.random() * 1.2 + 0.8;
	galaxies.push(galaxy);
}
// Create sidewalk platforms
var sidewalks = [];
var sidewalkY = 2732 / 2 + 235; // Position platforms below player starting position (adjusted for thicker platform)
for (var i = 0; i < 20; i++) {
	var sidewalk = game.addChild(LK.getAsset('sidewalk', {
		anchorX: 0.5,
		anchorY: 0.5
	}));
	sidewalk.x = i * 180 - 200; // Space platforms 180 pixels apart
	sidewalk.y = sidewalkY;
	sidewalks.push(sidewalk);
}
// Generate planets (Jupiter, Mars, Uranus, Saturn, Neptune)
var planetTypes = ['jupiter', 'mars', 'uranus', 'saturn', 'neptune'];
for (var i = 0; i < 15; i++) {
	var planetType = planetTypes[Math.floor(Math.random() * planetTypes.length)];
	var planet = game.addChild(LK.getAsset(planetType, {
		anchorX: 0.5,
		anchorY: 0.5
	}));
	planet.x = Math.random() * 2048;
	planet.y = Math.random() * 2732;
	planet.alpha = Math.random() * 0.7 + 0.3;
	planet.scaleX = Math.random() * 0.6 + 0.4;
	planet.scaleY = Math.random() * 0.6 + 0.4;
	planet.passed = false; // Initialize passed flag for planet scoring
	planets.push(planet);
}
// Animate galaxy pixel theme elements
function animateSpaceElements() {
	// Animate pixel stars twinkling
	for (var i = 0; i < stars.length; i++) {
		var star = stars[i];
		var targetAlpha = Math.random() * 0.9 + 0.1;
		tween(star, {
			alpha: targetAlpha
		}, {
			duration: Math.random() * 1500 + 800,
			easing: tween.easeInOut
		});
	}
	// Animate bigger pixel stars
	for (var i = 0; i < bigStars.length; i++) {
		var bigStar = bigStars[i];
		var targetAlpha = Math.random() * 0.8 + 0.2;
		tween(bigStar, {
			alpha: targetAlpha
		}, {
			duration: Math.random() * 2500 + 1200,
			easing: tween.easeInOut
		});
	}
	// Animate pixel galaxies with rotation
	for (var i = 0; i < galaxies.length; i++) {
		var galaxy = galaxies[i];
		tween(galaxy, {
			rotation: galaxy.rotation + Math.PI * 2
		}, {
			duration: Math.random() * 12000 + 18000,
			easing: tween.linear
		});
	}
	// Animate planets with gentle rotation and scale pulsing
	for (var i = 0; i < planets.length; i++) {
		var planet = planets[i];
		// Rotate planets slowly
		tween(planet, {
			rotation: planet.rotation + Math.PI * 2
		}, {
			duration: Math.random() * 20000 + 25000,
			easing: tween.linear
		});
		// Gentle scale pulsing for planets
		var scaleVariation = Math.random() * 0.1 + 0.05;
		tween(planet, {
			scaleX: planet.scaleX + scaleVariation,
			scaleY: planet.scaleY + scaleVariation
		}, {
			duration: Math.random() * 4000 + 3000,
			easing: tween.easeInOut
		});
	}
}
// Start galaxy pixel theme animations
animateSpaceElements();
// Re-animate space elements periodically
LK.setInterval(function () {
	animateSpaceElements();
}, 3000);
// Initialize player as simple astronaut image
var player = game.addChild(LK.getAsset('astronautCat', {
	anchorX: 0.5,
	anchorY: 0.5,
	scaleX: 1.3,
	scaleY: 1.3
}));
player.x = 2048 / 2;
player.y = 2732 / 2 + 175; // Position player on sidewalk platform
player.speed = 3;
player.jumpHeight = 40;
player.isJumping = false;
player.velocityY = 0;
player.groundY = 2732 / 2 + 175; // Set ground level to platform height
player.update = function () {
	// Jump animation is now handled by tween system
};
player.jump = function () {
	// Allow jump even if already jumping (for better control)
	// Stop any existing tweens on player position
	tween.stop(player, {
		y: true
	});
	player.isJumping = true;
	// Use current position as start point
	var startY = player.y;
	var jumpY = startY - 550; // Higher jump for better obstacle navigation
	tween(player, {
		y: jumpY
	}, {
		duration: 200,
		// Fast upward movement
		easing: tween.easeOut,
		onFinish: function onFinish() {
			// Animate falling down with gravity acceleration
			tween(player, {
				y: player.groundY
			}, {
				duration: 600,
				// Slower controlled falling speed with gravity acceleration
				easing: tween.easeIn,
				// Accelerated falling like gravity
				onFinish: function onFinish() {
					player.isJumping = false;
				}
			});
		}
	});
};
// Initialize enemies
var enemies = [];
var enemySpawnInterval = 100;
var enemySpawnCounter = 0;
// Create a new Text2 object to display the score
var scoreText = new Text2('0', {
	size: 100,
	fill: 0xFFFFFF
});
// Add the score text to the game GUI at the top center of the screen
LK.gui.top.addChild(scoreText);
scoreText.x = 2048 / 2;
scoreText.y = 0;
// Create high score display
var highScoreText = new Text2('High Score: ' + (storage.highScore || 0), {
	size: 60,
	fill: 0xFFD700
});
LK.gui.topRight.addChild(highScoreText);
highScoreText.x = -20;
highScoreText.y = 20;
// Handle game updates
game.update = function () {
	player.update();
	// Move background elements to create scrolling effect
	// Move stars
	for (var i = 0; i < stars.length; i++) {
		stars[i].x -= backgroundSpeed * 0.5; // Slower parallax for distant stars
		if (stars[i].x < -10) {
			stars[i].x = 2048 + Math.random() * 100;
			stars[i].y = Math.random() * 2732;
		}
	}
	// Move big stars
	for (var i = 0; i < bigStars.length; i++) {
		bigStars[i].x -= backgroundSpeed * 0.8; // Medium parallax for big stars
		if (bigStars[i].x < -20) {
			bigStars[i].x = 2048 + Math.random() * 100;
			bigStars[i].y = Math.random() * 2732;
		}
	}
	// Move galaxies
	for (var i = 0; i < galaxies.length; i++) {
		galaxies[i].x -= backgroundSpeed * 1.2; // Faster parallax for galaxies
		if (galaxies[i].x < -120) {
			galaxies[i].x = 2048 + Math.random() * 200;
			galaxies[i].y = Math.random() * 2732;
		}
	}
	// Move planets
	for (var i = 0; i < planets.length; i++) {
		planets[i].x -= backgroundSpeed * 1.5; // Fastest parallax for planets
		if (planets[i].x < -100) {
			planets[i].x = 2048 + Math.random() * 300;
			planets[i].y = Math.random() * 2732;
			planets[i].passed = false; // Reset passed flag when planet respawns
		}
		// Check if player jumped over this planet
		if (player.isJumping && player.x > planets[i].x && !planets[i].passed && Math.abs(player.x - planets[i].x) < 100) {
			planets[i].passed = true;
			LK.setScore(LK.getScore() + 10); // Award 10 points for jumping over planet
			scoreText.setText(LK.getScore());
			// Update high score if current score exceeds it
			var currentScore = LK.getScore();
			var highScore = storage.highScore || 0;
			if (currentScore > highScore) {
				storage.highScore = currentScore;
				highScoreText.setText('High Score: ' + currentScore);
			}
			// Save current game progress
			storage.currentScore = currentScore;
			// Create floating score text above planet
			var planetScoreText = new Text2('+10', {
				size: 60,
				fill: 0xFFD700 // Gold color for planet points
			});
			planetScoreText.x = planets[i].x;
			planetScoreText.y = planets[i].y - 80;
			game.addChild(planetScoreText);
			// Animate the planet score text upward and fade out
			tween(planetScoreText, {
				y: planetScoreText.y - 120,
				alpha: 0
			}, {
				duration: 1500,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					planetScoreText.destroy();
				}
			});
		}
	}
	// Move sidewalk platforms
	for (var i = 0; i < sidewalks.length; i++) {
		sidewalks[i].x -= backgroundSpeed * 2; // Move platforms with background
		if (sidewalks[i].x < -200) {
			sidewalks[i].x = 2048 + Math.random() * 100;
		}
	}
	// Spawn enemies
	enemySpawnCounter++;
	if (enemySpawnCounter >= enemySpawnInterval) {
		var enemy = new Enemy();
		enemy.x = 2048;
		enemy.y = 2732 / 2 + 175; // Spawn enemies on platform level
		enemies.push(enemy);
		game.addChild(enemy);
		// Randomize the spawn interval for the next enemy
		enemySpawnInterval = Math.floor(Math.random() * 150) + 50;
		enemySpawnCounter = 0;
	}
	// Update enemies
	for (var j = enemies.length - 1; j >= 0; j--) {
		enemies[j].update();
		// Only check collision when player is not jumping
		if (!player.isJumping && player.intersects(enemies[j])) {
			// Save high score before game over
			var currentScore = LK.getScore();
			var highScore = storage.highScore || 0;
			if (currentScore > highScore) {
				storage.highScore = currentScore;
			}
			LK.effects.flashScreen(0xff0000, 1000);
			LK.showGameOver();
		} else if (player.x > enemies[j].x && !enemies[j].passed) {
			enemies[j].passed = true;
			LK.setScore(LK.getScore() + 1);
			scoreText.setText(LK.getScore());
			// Update high score if current score exceeds it
			var currentScore = LK.getScore();
			var highScore = storage.highScore || 0;
			if (currentScore > highScore) {
				storage.highScore = currentScore;
				highScoreText.setText('High Score: ' + currentScore);
			}
			// Save current game progress
			storage.currentScore = currentScore;
		}
	}
};
// Handle player jump
game.down = function (x, y, obj) {
	player.jump();
	// Create jump score text
	var jumpScoreText = new Text2('+1', {
		size: 80,
		fill: 0x00FF00
	});
	jumpScoreText.x = player.x;
	jumpScoreText.y = player.y - 100;
	game.addChild(jumpScoreText);
	// Animate the jump score text upward and fade out
	tween(jumpScoreText, {
		y: jumpScoreText.y - 150,
		alpha: 0
	}, {
		duration: 1000,
		easing: tween.easeOut,
		onFinish: function onFinish() {
			jumpScoreText.destroy();
		}
	});
};