/**** 
* Plugins
****/ 
var tween = LK.import("@upit/tween.v1");
var storage = LK.import("@upit/storage.v1", {
	highScore: 0,
	gems: 0,
	avatarColor: 16754176
});

/**** 
* Classes
****/ 
var BackgroundFire = Container.expand(function () {
	var self = Container.call(this);
	self.speed = -3; // Slower than game elements for parallax effect
	var fireGraphics = self.attachAsset('backgroundFire', {
		anchorX: 0.5,
		anchorY: 1.0,
		alpha: 0.7
	});
	// Randomize initial scale
	var scale = 0.5 + Math.random() * 1.0;
	fireGraphics.scale.set(scale, scale);
	// Animation variables
	self.waveTime = Math.random() * Math.PI * 2; // Random start phase
	self.update = function () {
		self.x += self.speed;
		// Create fire wave effect
		self.waveTime += 0.1;
		var waveScale = Math.sin(self.waveTime) * 0.2;
		fireGraphics.scaleX = scale + waveScale;
		fireGraphics.scaleY = scale - waveScale / 2;
		// Remove if off screen
		if (self.x < -fireGraphics.width) {
			self.destroy();
		}
	};
	return self;
});
var Gem = Container.expand(function () {
	var self = Container.call(this);
	self.speed = -12;
	self.collected = false;
	var gemGraphics = self.attachAsset('gem', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Add pulsing animation
	self.pulseTime = 0;
	self.update = function () {
		self.x += self.speed;
		// Pulsing animation
		self.pulseTime += 0.1;
		var scale = 0.9 + Math.sin(self.pulseTime) * 0.1;
		gemGraphics.scale.set(scale, scale);
		// Remove if off screen
		if (self.x < -100) {
			self.destroy();
		}
	};
	self.collect = function () {
		if (self.collected) {
			return;
		}
		self.collected = true;
		LK.getSound('collect').play();
		// Animate gem collection
		tween(gemGraphics, {
			alpha: 0,
			scaleX: 2,
			scaleY: 2
		}, {
			duration: 300,
			onFinish: function onFinish() {
				self.destroy();
			}
		});
		// Update game stats
		storage.gems = (storage.gems || 0) + 1;
	};
	return self;
});
var Obstacle = Container.expand(function () {
	var self = Container.call(this);
	self.speed = -12;
	self.type = 'standard'; // standard, spikes, moving
	var obstacleGraphics = self.attachAsset('obstacle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.setType = function (newType) {
		self.type = newType;
		if (newType === 'spikes') {
			obstacleGraphics = self.removeChild(obstacleGraphics);
			obstacleGraphics = self.attachAsset('spikes', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		} else if (newType === 'moving') {
			// Add a slight tint to show it's a moving obstacle
			obstacleGraphics.tint = 0xff9900;
			// Start movement animation
			self.startY = self.y;
			self.moveRange = 150;
			self.moveSpeed = 0.05;
			self.moveTime = 0;
		}
	};
	self.update = function () {
		self.x += self.speed;
		// Handle moving obstacles
		if (self.type === 'moving') {
			self.moveTime += self.moveSpeed;
			self.y = self.startY + Math.sin(self.moveTime) * self.moveRange;
		}
		// Remove if off screen
		if (self.x < -100) {
			self.destroy();
		}
	};
	return self;
});
var Particle = Container.expand(function () {
	var self = Container.call(this);
	var particleGraphics = self.attachAsset('particle', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0.8
	});
	// Set random velocity
	self.velocity = {
		x: -5 + Math.random() * 10,
		y: -10 + Math.random() * 5
	};
	self.gravity = 0.5;
	self.lifetime = 30 + Math.random() * 30;
	self.age = 0;
	self.update = function () {
		// Apply physics
		self.velocity.y += self.gravity;
		self.x += self.velocity.x;
		self.y += self.velocity.y;
		// Age the particle
		self.age++;
		// Fade out as it ages
		particleGraphics.alpha = Math.max(0, 1 - self.age / self.lifetime);
		// Destroy when lifetime ends
		if (self.age >= self.lifetime) {
			self.destroy();
		}
	};
	return self;
});
var Platform = Container.expand(function () {
	var self = Container.call(this);
	self.speed = -12;
	var platformGraphics = self.attachAsset('platform', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.update = function () {
		self.x += self.speed;
		// Remove if off screen
		if (self.x < -platformGraphics.width) {
			self.destroy();
		}
	};
	return self;
});
var Player = Container.expand(function () {
	var self = Container.call(this);
	self.velocity = {
		x: 0,
		y: 0
	};
	self.gravity = 0.8;
	self.jumpForce = -20;
	self.isJumping = false;
	self.isDead = false;
	self.isFlying = false;
	// Get player avatar color from storage
	var playerColor = storage.avatarColor || 0xffa600;
	var playerGraphics = self.attachAsset('player', {
		anchorX: 0.5,
		anchorY: 0.5,
		tint: playerColor
	});
	self.update = function () {
		if (self.isDead) {
			return;
		}
		// Apply gravity if not flying
		if (!self.isFlying) {
			self.velocity.y += self.gravity;
		} else {
			// In flying mode, go up slowly
			self.velocity.y = -5;
		}
		// Apply velocity
		self.y += self.velocity.y;
		// Simple rotation based on velocity
		playerGraphics.rotation += 0.05;
		// Check floor collision
		if (self.y > groundLevel - playerGraphics.height / 2) {
			self.y = groundLevel - playerGraphics.height / 2;
			self.velocity.y = 0;
			self.isJumping = false;
		}
	};
	self.jump = function () {
		if (!self.isJumping && !self.isFlying) {
			self.velocity.y = self.jumpForce;
			self.isJumping = true;
			LK.getSound('jump').play();
		}
	};
	self.toggleFlying = function () {
		self.isFlying = !self.isFlying;
		// Change player appearance when flying
		if (self.isFlying) {
			tween(playerGraphics, {
				scaleY: 0.7,
				scaleX: 1.2
			}, {
				duration: 200
			});
		} else {
			tween(playerGraphics, {
				scaleY: 1,
				scaleX: 1
			}, {
				duration: 200
			});
		}
	};
	self.die = function () {
		if (self.isDead) {
			return;
		}
		self.isDead = true;
		LK.getSound('crash').play();
		// Explosion effect
		for (var i = 0; i < 10; i++) {
			createParticle(self.x, self.y);
		}
		// Hide player
		playerGraphics.alpha = 0;
		// Game over after a short delay
		LK.setTimeout(function () {
			LK.showGameOver();
		}, 1000);
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Global variables
var player;
var obstacles = [];
var gems = [];
var platforms = [];
var backgroundFires = [];
var particles = [];
var groundLevel = 2732 - 100; // Ground is 100px from bottom
var score = 0;
var obstacleSpeed = -12;
var obstacleTimer = 0;
var obstacleInterval = 120; // Frames between obstacles
var level = 1;
var gameStarted = false;
var isGameOver = false;
// Game UI elements
var scoreText = new Text2('Score: 0', {
	size: 80,
	fill: 0xFFFFFF
});
scoreText.anchor.set(1.0, 0);
LK.gui.topRight.addChild(scoreText);
var levelText = new Text2('Level: 1', {
	size: 80,
	fill: 0xFFFFFF
});
levelText.anchor.set(0.0, 0);
LK.gui.topLeft.addChild(levelText);
// Move the level text away from the top left corner (platform menu area)
levelText.x = 120;
levelText.y = 20;
var gemCountText = new Text2('Gems: ' + (storage.gems || 0), {
	size: 60,
	fill: 0x00FFFF
});
gemCountText.anchor.set(0.5, 0);
LK.gui.top.addChild(gemCountText);
// Create a tap to start message
var startText = new Text2('Tap to Start', {
	size: 120,
	fill: 0xFFFFFF
});
startText.anchor.set(0.5, 0.5);
LK.gui.center.addChild(startText);
// Create the ground
var ground = game.addChild(LK.getAsset('ground', {
	anchorX: 0.5,
	anchorY: 0.0,
	x: 2048 / 2,
	y: groundLevel
}));
// Create the player
player = game.addChild(new Player());
player.x = 500;
player.y = groundLevel - 100;
// Update the obstacle speed based on level
function updateDifficulty() {
	// Increase speed as level increases
	obstacleSpeed = -12 - level;
	// Decrease interval between obstacles as level increases
	obstacleInterval = Math.max(60, 120 - level * 5);
	// Update all current obstacles and platforms
	for (var i = 0; i < obstacles.length; i++) {
		obstacles[i].speed = obstacleSpeed;
	}
	for (var i = 0; i < platforms.length; i++) {
		platforms[i].speed = obstacleSpeed;
	}
	for (var i = 0; i < gems.length; i++) {
		gems[i].speed = obstacleSpeed;
	}
	// Update level text
	levelText.setText('Level: ' + level);
}
// Create a new obstacle
function createObstacle() {
	var obstacle = new Obstacle();
	obstacle.x = 2048 + 100; // Start just off-screen
	obstacle.y = groundLevel - obstacle.height / 2;
	obstacle.speed = obstacleSpeed;
	// Random obstacle type
	var type = Math.random();
	if (type < 0.3) {
		obstacle.setType('spikes');
	} else if (type < 0.6 && level > 1) {
		obstacle.setType('moving');
		// Position moving obstacles higher so they move up and down
		obstacle.y -= 150;
	}
	obstacles.push(obstacle);
	game.addChild(obstacle);
	// Sometimes add platforms after obstacles
	if (Math.random() < 0.4) {
		createPlatform(obstacle.x + 350, groundLevel - 200 - Math.random() * 150);
	}
	// Sometimes add gems
	if (Math.random() < 0.3) {
		createGem(obstacle.x + 150, obstacle.y - 150);
	}
}
// Create a platform
function createPlatform(x, y) {
	var platform = new Platform();
	platform.x = x || 2048 + 100; // Start just off-screen
	platform.y = y || groundLevel - 300;
	platform.speed = obstacleSpeed;
	platforms.push(platform);
	game.addChild(platform);
}
// Create a gem
function createGem(x, y) {
	var gem = new Gem();
	gem.x = x || 2048 + 100; // Start just off-screen
	gem.y = y || groundLevel - 200;
	gem.speed = obstacleSpeed;
	gems.push(gem);
	game.addChild(gem);
}
// Create a background fire
function createBackgroundFire() {
	var fire = new BackgroundFire();
	fire.x = 2048 + Math.random() * 500;
	fire.y = groundLevel + 10; // Slightly below ground level
	backgroundFires.push(fire);
	game.addChild(fire);
}
// Create a particle
function createParticle(x, y) {
	var particle = new Particle();
	particle.x = x;
	particle.y = y;
	particles.push(particle);
	game.addChild(particle);
}
// Check collision between player and obstacles
function checkCollisions() {
	// Check obstacle collisions
	for (var i = 0; i < obstacles.length; i++) {
		if (player.intersects(obstacles[i]) && !player.isDead) {
			player.die();
			return;
		}
	}
	// Check gem collections
	for (var i = 0; i < gems.length; i++) {
		if (!gems[i].collected && player.intersects(gems[i])) {
			gems[i].collect();
			score += 10;
			updateScore();
		}
	}
	// Check platform collisions
	var onPlatform = false;
	for (var i = 0; i < platforms.length; i++) {
		if (player.intersects(platforms[i]) && player.y < platforms[i].y - 10 && player.velocity.y > 0) {
			player.y = platforms[i].y - platforms[i].height / 2 - player.height / 2;
			player.velocity.y = 0;
			player.isJumping = false;
			onPlatform = true;
		}
	}
}
// Update score display
function updateScore() {
	scoreText.setText('Score: ' + score);
	gemCountText.setText('Gems: ' + (storage.gems || 0));
	// Check for level up
	if (score >= level * 100) {
		levelUp();
	}
	// Update high score
	if (score > storage.highScore) {
		storage.highScore = score;
	}
}
// Level up function
function levelUp() {
	level++;
	// Flash level text
	LK.effects.flashObject(levelText, 0xffff00, 500);
	// Update difficulty
	updateDifficulty();
}
// Start the game
function startGame() {
	if (gameStarted) {
		return;
	}
	gameStarted = true;
	startText.visible = false;
	// Start background music
	LK.playMusic('bgmusic', {
		fade: {
			start: 0,
			end: 0.7,
			duration: 1000
		}
	});
	// Add initial obstacles and fire effects
	createObstacle();
	for (var i = 0; i < 5; i++) {
		createBackgroundFire();
	}
	// Start score counter
	scoreInterval = LK.setInterval(function () {
		if (!player.isDead) {
			score++;
			updateScore();
		}
	}, 1000);
}
// Handle game input
game.down = function (x, y, obj) {
	if (!gameStarted) {
		startGame();
		return;
	}
	// Jump when tapping upper half of screen
	if (y < 2732 / 2) {
		player.jump();
	}
	// Toggle flying mode when tapping lower half
	else {
		player.toggleFlying();
	}
};
// Main game update
game.update = function () {
	if (!gameStarted) {
		return;
	}
	// Spawn obstacles at intervals
	obstacleTimer++;
	if (obstacleTimer >= obstacleInterval && !player.isDead) {
		createObstacle();
		obstacleTimer = 0;
	}
	// Spawn background fires
	if (LK.ticks % 120 === 0 && !player.isDead) {
		createBackgroundFire();
	}
	// Update all game elements
	player.update();
	for (var i = obstacles.length - 1; i >= 0; i--) {
		obstacles[i].update();
		if (!obstacles[i].parent) {
			obstacles.splice(i, 1);
		}
	}
	for (var i = gems.length - 1; i >= 0; i--) {
		gems[i].update();
		if (!gems[i].parent) {
			gems.splice(i, 1);
		}
	}
	for (var i = platforms.length - 1; i >= 0; i--) {
		platforms[i].update();
		if (!platforms[i].parent) {
			platforms.splice(i, 1);
		}
	}
	for (var i = backgroundFires.length - 1; i >= 0; i--) {
		backgroundFires[i].update();
		if (!backgroundFires[i].parent) {
			backgroundFires.splice(i, 1);
		}
	}
	for (var i = particles.length - 1; i >= 0; i--) {
		particles[i].update();
		if (!particles[i].parent) {
			particles.splice(i, 1);
		}
	}
	// Check collisions
	if (!player.isDead) {
		checkCollisions();
	}
};