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

/**** 
* Classes
****/ 
var Background = Container.expand(function () {
	var self = Container.call(this);
	var backgroundGraphics = self.attachAsset('background', {
		anchorX: 0,
		anchorY: 0
	});
	self.speed = gameSpeed;
	self.update = function () {
		self.x -= self.speed * 0.5; // Move slower than obstacles for parallax effect
		// Reset position when background scrolls off screen
		if (self.x <= -2048) {
			self.x = 0;
		}
	};
	return self;
});
var Coin = Container.expand(function () {
	var self = Container.call(this);
	var coinGraphics = self.attachAsset('coin', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 8;
	self.update = function () {
		if (!showingUpgrades) {
			self.x -= self.speed;
			// Add floating animation
			self.y += Math.sin(LK.ticks * 0.2) * 0.8;
			// Add rotation for visual appeal
			coinGraphics.rotation += 0.1;
		}
	};
	return self;
});
var Ground = Container.expand(function () {
	var self = Container.call(this);
	var groundGraphics = self.attachAsset('ground', {
		anchorX: 0,
		anchorY: 0
	});
	return self;
});
var Obstacle = Container.expand(function () {
	var self = Container.call(this);
	var obstacleGraphics = self.attachAsset('obstacle', {
		anchorX: 0.5,
		anchorY: 1.0
	});
	self.speed = 8;
	self.update = function () {
		if (!showingUpgrades) {
			self.x -= self.speed;
		}
	};
	return self;
});
var Player = Container.expand(function () {
	var self = Container.call(this);
	var playerGraphics = self.attachAsset('player', {
		anchorX: 0.5,
		anchorY: 1.0
	});
	self.isJumping = false;
	self.jumpSpeed = 0;
	self.gravity = 0.8;
	self.groundY = 2732 - 150;
	self.jumpPower = -18;
	self.jump = function () {
		if (!self.isJumping) {
			self.isJumping = true;
			self.jumpSpeed = self.jumpPower;
			LK.getSound('jump').play();
		}
	};
	self.update = function () {
		if (self.isJumping) {
			self.jumpSpeed += self.gravity;
			self.y += self.jumpSpeed;
			if (self.y >= self.groundY) {
				self.y = self.groundY;
				self.isJumping = false;
				self.jumpSpeed = 0;
			}
		}
	};
	return self;
});
var PowerUp = Container.expand(function (type) {
	var self = Container.call(this);
	self.type = type || 'speed';
	var assetId = self.type === 'ghost' ? 'ghostpowerup' : 'powerup';
	var powerupGraphics = self.attachAsset(assetId, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 8;
	self.update = function () {
		if (!showingUpgrades) {
			self.x -= self.speed;
			// Add floating animation
			self.y += Math.sin(LK.ticks * 0.1) * 0.5;
		}
	};
	return self;
});

/**** 
* Initialize Game
****/ 
var game = new LK.Game({
	backgroundColor: 0x87CEEB
});

/**** 
* Game Code
****/ 
var distance = 0;
var obstacles = [];
var powerups = [];
var gameRunning = true;
var powerupSpawnRate = 300;
var nextPowerupSpawn = powerupSpawnRate;
var speedBoostActive = false;
var speedBoostEndTime = 0;
var ghostModeActive = false;
var ghostModeEndTime = 0;
var coins = [];
var coinSpawnRate = 200;
var nextCoinSpawn = coinSpawnRate;
var money = storage.money || 0;
var highestScore = storage.highestScore || 0;
var jumpUpgradeLevel = storage.jumpUpgradeLevel || 0;
var jumpUpgradeCost = 50;
var speedUpgradeLevel = storage.speedUpgradeLevel || 0;
var speedUpgradeCost = 50;
var showingUpgrades = false;
// Initialize game speed after upgrades are loaded
var gameSpeed = 8 + speedUpgradeLevel * 1;
var speedIncrement = 0.005;
var maxSpeed = 20 + speedUpgradeLevel * 2;
var obstacleSpawnRate = 120;
var nextObstacleSpawn = obstacleSpawnRate;
var originalSpeed = gameSpeed;
// Create background (two instances for seamless scrolling)
var background1 = game.addChild(new Background());
background1.x = 0;
background1.y = 0;
var background2 = game.addChild(new Background());
background2.x = 2048;
background2.y = 0;
// Create ground
var ground = game.addChild(new Ground());
ground.x = 0;
ground.y = 2732 - 150;
// Create player
var player = game.addChild(new Player());
player.x = 300;
player.y = 2732 - 150;
// Apply jump upgrades
player.jumpPower = -18 - jumpUpgradeLevel * 2;
// Create score display
var scoreText = new Text2('Distance: 0', {
	size: 60,
	fill: '#ffffff'
});
scoreText.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreText);
// Create speed display
var speedText = new Text2('Speed: 8', {
	size: 40,
	fill: '#ffffff'
});
speedText.anchor.set(1, 0);
speedText.x = -50;
speedText.y = 50;
LK.gui.topRight.addChild(speedText);
// Create money display
var moneyText = new Text2('Money: ' + money, {
	size: 50,
	fill: '#FFD700'
});
moneyText.anchor.set(0, 0);
moneyText.x = 50;
moneyText.y = 50;
LK.gui.topLeft.addChild(moneyText);
// Create highest score display
var highestScoreText = new Text2('Best: ' + highestScore, {
	size: 40,
	fill: '#FFD700'
});
highestScoreText.anchor.set(1, 0);
highestScoreText.x = -50;
highestScoreText.y = 100;
LK.gui.topRight.addChild(highestScoreText);
// Create upgrades button
var upgradesButton = new Text2('UPGRADES', {
	size: 45,
	fill: '#00FF00'
});
upgradesButton.anchor.set(0, 0);
upgradesButton.x = 50;
upgradesButton.y = 120;
LK.gui.topLeft.addChild(upgradesButton);
// Create upgrades shop UI (initially hidden)
var upgradesPanel = new Container();
upgradesPanel.visible = false;
LK.gui.center.addChild(upgradesPanel);
// Shop background
var shopBackground = LK.getAsset('ground', {
	anchorX: 0.5,
	anchorY: 0.5,
	scaleX: 3,
	scaleY: 4,
	tint: 0x333333
});
upgradesPanel.addChild(shopBackground);
// Shop title
var shopTitle = new Text2('UPGRADES SHOP', {
	size: 70,
	fill: '#FFD700'
});
shopTitle.anchor.set(0.5, 0.5);
shopTitle.y = -200;
upgradesPanel.addChild(shopTitle);
// Jump upgrade section
var jumpUpgradeText = new Text2('Jump Higher (Level ' + jumpUpgradeLevel + '/10)', {
	size: 50,
	fill: '#FFFFFF'
});
jumpUpgradeText.anchor.set(0.5, 0.5);
jumpUpgradeText.y = -50;
upgradesPanel.addChild(jumpUpgradeText);
var jumpUpgradeCostText = new Text2('Cost: ' + (jumpUpgradeLevel < 10 ? jumpUpgradeCost + jumpUpgradeLevel * 25 : 'MAX'), {
	size: 40,
	fill: '#FFFF00'
});
jumpUpgradeCostText.anchor.set(0.5, 0.5);
jumpUpgradeCostText.y = 10;
upgradesPanel.addChild(jumpUpgradeCostText);
// Buy button
var buyJumpButton = new Text2('BUY', {
	size: 50,
	fill: '#00FF00'
});
buyJumpButton.anchor.set(0.5, 0.5);
buyJumpButton.y = 70;
upgradesPanel.addChild(buyJumpButton);
// Speed upgrade section
var speedUpgradeText = new Text2('Faster Speed (Level ' + speedUpgradeLevel + '/10)', {
	size: 50,
	fill: '#FFFFFF'
});
speedUpgradeText.anchor.set(0.5, 0.5);
speedUpgradeText.y = 130;
upgradesPanel.addChild(speedUpgradeText);
var speedUpgradeCostText = new Text2('Cost: ' + (speedUpgradeLevel < 10 ? speedUpgradeCost + speedUpgradeLevel * 25 : 'MAX'), {
	size: 40,
	fill: '#FFFF00'
});
speedUpgradeCostText.anchor.set(0.5, 0.5);
speedUpgradeCostText.y = 190;
upgradesPanel.addChild(speedUpgradeCostText);
// Buy speed button
var buySpeedButton = new Text2('BUY', {
	size: 50,
	fill: '#00FF00'
});
buySpeedButton.anchor.set(0.5, 0.5);
buySpeedButton.y = 250;
upgradesPanel.addChild(buySpeedButton);
// Reset upgrades button
var resetButton = new Text2('RESET ALL', {
	size: 45,
	fill: '#FF4500'
});
resetButton.anchor.set(0.5, 0.5);
resetButton.y = 320;
upgradesPanel.addChild(resetButton);
// Close button
var closeButton = new Text2('CLOSE', {
	size: 50,
	fill: '#FF0000'
});
closeButton.anchor.set(0.5, 0.5);
closeButton.y = 380;
upgradesPanel.addChild(closeButton);
function spawnObstacle() {
	var obstacle = new Obstacle();
	obstacle.x = 2048 + 60;
	obstacle.y = 2732 - 150;
	obstacle.speed = gameSpeed;
	obstacles.push(obstacle);
	game.addChild(obstacle);
}
function spawnPowerUp() {
	var powerupType = Math.random() < 0.2 ? 'ghost' : 'speed';
	var powerup = new PowerUp(powerupType);
	powerup.x = 2048 + 80;
	powerup.y = 2732 - 150 - 100 - Math.random() * 200;
	powerups.push(powerup);
	game.addChild(powerup);
}
function spawnCoin() {
	var coin = new Coin();
	coin.x = 2048 + 60;
	coin.y = 2732 - 150 - 50 - Math.random() * 300;
	coins.push(coin);
	game.addChild(coin);
}
function createBloodParticles() {
	// Create 15 blood particles
	for (var i = 0; i < 15; i++) {
		var particle = LK.getAsset('obstacle', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 0.3,
			scaleY: 0.3,
			tint: 0xFF0000
		});
		// Position particle at player location
		particle.x = player.x;
		particle.y = player.y;
		game.addChild(particle);
		// Random velocity for each particle
		var velocityX = (Math.random() - 0.5) * 20;
		var velocityY = (Math.random() - 0.5) * 20 - 5; // Slightly upward bias
		var gravity = 0.5;
		// Animate particle with physics
		var animateParticle = function animateParticle() {
			particle.x += velocityX;
			particle.y += velocityY;
			velocityY += gravity; // Apply gravity
			velocityX *= 0.98; // Air resistance
		};
		// Update particle position over time
		var particleInterval = LK.setInterval(animateParticle, 16);
		// Fade out and destroy particle
		tween(particle, {
			alpha: 0,
			scaleX: 0.1,
			scaleY: 0.1
		}, {
			duration: 1500,
			onFinish: function onFinish() {
				LK.clearInterval(particleInterval);
				particle.destroy();
			}
		});
	}
}
function updateObstacles() {
	for (var i = obstacles.length - 1; i >= 0; i--) {
		var obstacle = obstacles[i];
		obstacle.speed = gameSpeed;
		// Remove obstacles that are off screen
		if (obstacle.x < -100) {
			obstacle.destroy();
			obstacles.splice(i, 1);
			continue;
		}
		// Check collision with player
		if (gameRunning && !ghostModeActive && obstacle.intersects(player)) {
			gameRunning = false;
			createBloodParticles(); // Create blood particles on death
			LK.getSound('collision').play();
			LK.effects.flashScreen(0xFF0000, 1000);
			var currentScore = Math.floor(distance / 10);
			LK.setScore(currentScore);
			// Update highest score if current score is higher
			if (currentScore > highestScore) {
				highestScore = currentScore;
				storage.highestScore = highestScore;
				highestScoreText.setText('Best: ' + highestScore);
			}
			LK.setTimeout(function () {
				LK.showGameOver();
			}, 500);
			return; // Exit function early after collision
		}
	}
}
function updatePowerUps() {
	for (var i = powerups.length - 1; i >= 0; i--) {
		var powerup = powerups[i];
		powerup.speed = gameSpeed;
		// Remove power-ups that are off screen
		if (powerup.x < -100) {
			powerup.destroy();
			powerups.splice(i, 1);
			continue;
		}
		// Check collision with player
		if (gameRunning && powerup.intersects(player)) {
			if (powerup.type === 'speed') {
				activateSpeedBoost();
			} else if (powerup.type === 'ghost') {
				activateGhostMode();
			}
			LK.getSound('powerup').play();
			LK.effects.flashObject(player, 0xFFD700, 500);
			powerup.destroy();
			powerups.splice(i, 1);
		}
	}
}
function updateCoins() {
	for (var i = coins.length - 1; i >= 0; i--) {
		var coin = coins[i];
		coin.speed = gameSpeed;
		// Remove coins that are off screen
		if (coin.x < -100) {
			coin.destroy();
			coins.splice(i, 1);
			continue;
		}
		// Check collision with player
		if (gameRunning && coin.intersects(player)) {
			money += 2;
			storage.money = money;
			moneyText.setText('Money: ' + money);
			LK.getSound('coin').play();
			LK.effects.flashObject(coin, 0xFFD700, 300);
			coin.destroy();
			coins.splice(i, 1);
		}
	}
}
function activateSpeedBoost() {
	speedBoostActive = true;
	speedBoostEndTime = LK.ticks + 300; // 5 seconds at 60 FPS
	gameSpeed = Math.min(gameSpeed * 1.5, maxSpeed);
	// Tween player color to indicate speed boost
	tween(player, {
		tint: 0x00FF00
	}, {
		duration: 200
	});
}
function activateGhostMode() {
	ghostModeActive = true;
	ghostModeEndTime = LK.ticks + 300; // 5 seconds at 60 FPS
	// Tween player to semi-transparent blue to indicate ghost mode
	tween(player, {
		tint: 0x0099FF,
		alpha: 0.6
	}, {
		duration: 200
	});
}
function updateSpeedBoost() {
	if (speedBoostActive && LK.ticks >= speedBoostEndTime) {
		speedBoostActive = false;
		gameSpeed = originalSpeed;
		// Tween player back to normal color
		tween(player, {
			tint: 0xFFFFFF
		}, {
			duration: 200
		});
	}
}
function updateGhostMode() {
	if (ghostModeActive && LK.ticks >= ghostModeEndTime) {
		ghostModeActive = false;
		// Tween player back to normal appearance
		tween(player, {
			tint: 0xFFFFFF,
			alpha: 1.0
		}, {
			duration: 200
		});
	}
}
function updateGameSpeed() {
	if (!speedBoostActive && gameSpeed < maxSpeed) {
		gameSpeed += speedIncrement;
		originalSpeed = gameSpeed;
	}
	// Adjust obstacle spawn rate based on speed
	obstacleSpawnRate = Math.max(60, 120 - (gameSpeed - 8) * 5);
}
function updateUpgradesDisplay() {
	jumpUpgradeText.setText('Jump Higher (Level ' + jumpUpgradeLevel + '/10)');
	var cost = jumpUpgradeLevel < 10 ? jumpUpgradeCost + jumpUpgradeLevel * 25 : 'MAX';
	jumpUpgradeCostText.setText('Cost: ' + cost);
	buyJumpButton.visible = jumpUpgradeLevel < 10 && money >= jumpUpgradeCost + jumpUpgradeLevel * 25;
	speedUpgradeText.setText('Faster Speed (Level ' + speedUpgradeLevel + '/10)');
	var speedCost = speedUpgradeLevel < 10 ? speedUpgradeCost + speedUpgradeLevel * 25 : 'MAX';
	speedUpgradeCostText.setText('Cost: ' + speedCost);
	buySpeedButton.visible = speedUpgradeLevel < 10 && money >= speedUpgradeCost + speedUpgradeLevel * 25;
}
function buyJumpUpgrade() {
	if (jumpUpgradeLevel < 10) {
		var cost = jumpUpgradeCost + jumpUpgradeLevel * 25;
		if (money >= cost) {
			money -= cost;
			jumpUpgradeLevel++;
			storage.money = money;
			storage.jumpUpgradeLevel = jumpUpgradeLevel;
			// Update player jump power
			player.jumpPower = -18 - jumpUpgradeLevel * 2;
			moneyText.setText('Money: ' + money);
			updateUpgradesDisplay();
			LK.getSound('powerup').play();
		}
	}
}
function buySpeedUpgrade() {
	if (speedUpgradeLevel < 10) {
		var cost = speedUpgradeCost + speedUpgradeLevel * 25;
		if (money >= cost) {
			money -= cost;
			speedUpgradeLevel++;
			storage.money = money;
			storage.speedUpgradeLevel = speedUpgradeLevel;
			// Update game speed and max speed
			gameSpeed = Math.max(gameSpeed, 8 + speedUpgradeLevel * 1);
			maxSpeed = 20 + speedUpgradeLevel * 2;
			originalSpeed = gameSpeed;
			moneyText.setText('Money: ' + money);
			updateUpgradesDisplay();
			LK.getSound('powerup').play();
		}
	}
}
function resetAllUpgrades() {
	// Reset upgrade levels to 0
	jumpUpgradeLevel = 0;
	speedUpgradeLevel = 0;
	// Save to storage
	storage.jumpUpgradeLevel = 0;
	storage.speedUpgradeLevel = 0;
	// Reset player jump power to default
	player.jumpPower = -18;
	// Reset game speed to default
	gameSpeed = 8;
	maxSpeed = 20;
	originalSpeed = gameSpeed;
	// Update background speeds
	background1.speed = gameSpeed;
	background2.speed = gameSpeed;
	// Update display
	updateUpgradesDisplay();
	LK.getSound('powerup').play();
}
function updateDistance() {
	if (gameRunning) {
		distance += gameSpeed * 0.1;
		var distanceScore = Math.floor(distance / 10);
		scoreText.setText('Distance: ' + distanceScore);
		speedText.setText('Speed: ' + Math.floor(gameSpeed));
	}
}
// Game input handling
game.down = function (x, y, obj) {
	if (gameRunning && !showingUpgrades) {
		player.jump();
	}
};
// Add click handlers for upgrades
upgradesButton.down = function (x, y, obj) {
	if (!gameRunning) return;
	showingUpgrades = true;
	upgradesPanel.visible = true;
	updateUpgradesDisplay();
	// Pause background movement
	background1.speed = 0;
	background2.speed = 0;
	gameRunning = false;
};
buyJumpButton.down = function (x, y, obj) {
	buyJumpUpgrade();
};
buySpeedButton.down = function (x, y, obj) {
	buySpeedUpgrade();
};
resetButton.down = function (x, y, obj) {
	resetAllUpgrades();
};
closeButton.down = function (x, y, obj) {
	showingUpgrades = false;
	upgradesPanel.visible = false;
	// Resume background movement
	background1.speed = gameSpeed;
	background2.speed = gameSpeed;
	gameRunning = true;
};
// Main game loop
game.update = function () {
	if (!gameRunning && !showingUpgrades) return;
	if (showingUpgrades) {
		updateUpgradesDisplay();
		return;
	}
	// Update distance and speed
	updateDistance();
	updateGameSpeed();
	// Update speed boost
	updateSpeedBoost();
	// Update ghost mode
	updateGhostMode();
	// Spawn obstacles
	nextObstacleSpawn--;
	if (nextObstacleSpawn <= 0) {
		spawnObstacle();
		nextObstacleSpawn = obstacleSpawnRate + Math.random() * 30 - 15;
	}
	// Spawn power-ups
	nextPowerupSpawn--;
	if (nextPowerupSpawn <= 0) {
		spawnPowerUp();
		nextPowerupSpawn = powerupSpawnRate + Math.random() * 200 - 100;
	}
	// Spawn coins
	nextCoinSpawn--;
	if (nextCoinSpawn <= 0) {
		spawnCoin();
		nextCoinSpawn = coinSpawnRate + Math.random() * 50 - 25;
	}
	// Update background speed
	background1.speed = gameSpeed;
	background2.speed = gameSpeed;
	// Update obstacles
	updateObstacles();
	// Update power-ups
	updatePowerUps();
	// Update coins
	updateCoins();
};