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

/**** 
* Classes
****/ 
var Breadcrumb = Container.expand(function () {
	var self = Container.call(this);
	var breadcrumbGraphic = self.attachAsset('breadcrumb', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = -15;
	self.damage = 1;
	self.update = function () {
		self.y += self.speed;
		// Handle off-screen removal in game.update
	};
	return self;
});
var Building = Container.expand(function () {
	var self = Container.call(this);
	var buildingGraphic = self.attachAsset('building', {
		anchorX: 0.5,
		anchorY: 0
	});
	// Random height variation
	var heightScale = 0.5 + Math.random() * 0.5;
	buildingGraphic.scaleY = heightScale;
	// Random gray shade
	var grayShade = 100 + Math.floor(Math.random() * 100);
	buildingGraphic.tint = grayShade << 16 | grayShade << 8 | grayShade;
	return self;
});
var Enemy = Container.expand(function (type) {
	var self = Container.call(this);
	self.type = type || 'cat';
	self.health = 1;
	self.speed = 3;
	self.points = 10;
	// Customize based on enemy type
	if (self.type === 'cat') {
		self.health = 2;
		self.speed = 3;
		self.points = 10;
	} else if (self.type === 'hawk') {
		self.health = 1;
		self.speed = 5;
		self.points = 15;
	} else if (self.type === 'truck') {
		self.health = 4;
		self.speed = 2;
		self.points = 25;
	}
	var enemyGraphic = self.attachAsset(self.type, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.update = function () {
		self.y += self.speed;
		// Zigzag movement for hawks
		if (self.type === 'hawk') {
			self.x += Math.sin(LK.ticks / 10) * 5;
		}
		// Handle off-screen and collisions in game.update
	};
	self.takeDamage = function (amount) {
		self.health -= amount;
		// Visual feedback
		LK.effects.flashObject(self, 0xff0000, 300);
		if (self.health <= 0) {
			return true; // Enemy is defeated
		}
		return false;
	};
	return self;
});
var Pigeon = Container.expand(function () {
	var self = Container.call(this);
	var pigeonGraphic = self.attachAsset('pigeon', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.fireRate = 30; // Frames between shots
	self.lastFired = 0;
	self.powerups = {
		multishot: 0,
		speed: 0,
		shield: 0
	};
	self.update = function () {
		// Automatic firing
		if (LK.ticks - self.lastFired >= self.fireRate) {
			self.fire();
			self.lastFired = LK.ticks;
		}
		// Countdown powerup durations
		for (var powerup in self.powerups) {
			if (self.powerups[powerup] > 0) {
				self.powerups[powerup]--;
			}
		}
	};
	self.fire = function () {
		// Basic breadcrumb
		var breadcrumb = new Breadcrumb();
		breadcrumb.x = self.x;
		breadcrumb.y = self.y - 50;
		game.addChild(breadcrumb);
		game.breadcrumbs.push(breadcrumb);
		// Multishot powerup
		if (self.powerups.multishot > 0) {
			var breadcrumbLeft = new Breadcrumb();
			breadcrumbLeft.x = self.x - 40;
			breadcrumbLeft.y = self.y - 30;
			game.addChild(breadcrumbLeft);
			game.breadcrumbs.push(breadcrumbLeft);
			var breadcrumbRight = new Breadcrumb();
			breadcrumbRight.x = self.x + 40;
			breadcrumbRight.y = self.y - 30;
			game.addChild(breadcrumbRight);
			game.breadcrumbs.push(breadcrumbRight);
		}
		// Speed powerup affects fire rate
		if (self.powerups.speed > 0) {
			self.lastFired -= 10; // Allow next shot sooner
		}
		// Play sound
		LK.getSound('shoot').play();
	};
	self.activatePowerup = function (type) {
		// Duration in frames (60 = 1 second)
		var duration = 300; // 5 seconds
		self.powerups[type] = duration;
		// Visual feedback
		if (type === 'multishot') {
			LK.effects.flashObject(self, 0xFF0000, 500);
		} else if (type === 'speed') {
			LK.effects.flashObject(self, 0x00FF00, 500);
		} else if (type === 'shield') {
			LK.effects.flashObject(self, 0x0000FF, 500);
			// Create shield visual if needed
		}
	};
	self.down = function (x, y, obj) {
		// Not needed, movement handled in game.down
	};
	return self;
});
var PowerUp = Container.expand(function (type) {
	var self = Container.call(this);
	self.type = type || 'multishot';
	self.speed = 4;
	var powerupGraphic = self.attachAsset('powerup', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Different colors based on power-up type
	if (self.type === 'multishot') {
		powerupGraphic.tint = 0xFF0000; // Red for multishot
	} else if (self.type === 'speed') {
		powerupGraphic.tint = 0x00FF00; // Green for speed
	} else if (self.type === 'shield') {
		powerupGraphic.tint = 0x0000FF; // Blue for shield
	}
	self.update = function () {
		self.y += self.speed;
		// Handle off-screen and collection in game.update
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Game state variables
var level = storage.level || 1;
var score = 0;
var lives = 3;
var isPaused = false;
var isGameOver = false;
var spawnRate = 120; // Frames between enemy spawns
var lastSpawn = 0;
var powerupChance = 0.1; // 10% chance of powerup from defeated enemies
// Game objects collections
game.breadcrumbs = [];
game.enemies = [];
game.powerups = [];
game.buildings = [];
// Create the pigeon player
var pigeon = new Pigeon();
pigeon.x = 2048 / 2;
pigeon.y = 2732 - 200;
game.addChild(pigeon);
// Create background buildings
function createBackgroundBuildings() {
	// Clear existing buildings
	for (var i = 0; i < game.buildings.length; i++) {
		game.buildings[i].destroy();
	}
	game.buildings = [];
	// Create new buildings
	var buildingCount = 5;
	var spacing = 2048 / buildingCount;
	for (var i = 0; i < buildingCount; i++) {
		var building = new Building();
		building.x = i * spacing + spacing / 2;
		building.y = 2732 - 100; // Position from bottom
		// Ensure buildings are behind gameplay elements
		game.addChildAt(building, 0);
		game.buildings.push(building);
	}
}
// Create UI elements
var scoreTxt = new Text2('Score: 0', {
	size: 60,
	fill: 0xFFFFFF
});
scoreTxt.anchor.set(0, 0);
LK.gui.topRight.addChild(scoreTxt);
var livesTxt = new Text2('Lives: 3', {
	size: 60,
	fill: 0xFFFFFF
});
livesTxt.anchor.set(1, 0);
LK.gui.top.addChild(livesTxt);
var levelTxt = new Text2('Level: 1', {
	size: 60,
	fill: 0xFFFFFF
});
levelTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(levelTxt);
// Initialize game
function initGame() {
	// Clear all game objects
	for (var i = 0; i < game.breadcrumbs.length; i++) {
		if (game.breadcrumbs[i]) {
			game.breadcrumbs[i].destroy();
		}
	}
	game.breadcrumbs = [];
	for (var i = 0; i < game.enemies.length; i++) {
		if (game.enemies[i]) {
			game.enemies[i].destroy();
		}
	}
	game.enemies = [];
	for (var i = 0; i < game.powerups.length; i++) {
		if (game.powerups[i]) {
			game.powerups[i].destroy();
		}
	}
	game.powerups = [];
	// Reset game state
	level = storage.level || 1;
	score = 0;
	lives = 3;
	isGameOver = false;
	spawnRate = Math.max(120 - level * 10, 30); // Faster spawns at higher levels
	// Reset pigeon position
	pigeon.x = 2048 / 2;
	pigeon.y = 2732 - 200;
	// Update UI
	updateUI();
	// Create background
	createBackgroundBuildings();
	// Start game music
	LK.playMusic('gameMusic', {
		fade: {
			start: 0,
			end: 0.3,
			duration: 1000
		}
	});
}
// Update UI elements
function updateUI() {
	scoreTxt.setText('Score: ' + score);
	livesTxt.setText('Lives: ' + lives);
	levelTxt.setText('Level: ' + level);
}
// Spawn enemies
function spawnEnemy() {
	var enemyTypes = ['cat', 'hawk', 'truck'];
	var weights = [60, 30, 10]; // Probability distribution
	// Adjust weights based on level
	if (level >= 3) {
		weights = [50, 35, 15];
	}
	if (level >= 5) {
		weights = [40, 40, 20];
	}
	if (level >= 8) {
		weights = [30, 40, 30];
	}
	// Select enemy type based on weighted random
	var totalWeight = weights.reduce(function (a, b) {
		return a + b;
	}, 0);
	var random = Math.random() * totalWeight;
	var enemyTypeIndex = 0;
	var weightSum = 0;
	for (var i = 0; i < weights.length; i++) {
		weightSum += weights[i];
		if (random <= weightSum) {
			enemyTypeIndex = i;
			break;
		}
	}
	var enemy = new Enemy(enemyTypes[enemyTypeIndex]);
	// Position randomly across top of screen
	enemy.x = Math.random() * 1948 + 50; // Keep away from edges
	enemy.y = -100; // Start above screen
	// Adjust speed based on level
	enemy.speed += Math.min(level * 0.5, 3);
	game.addChild(enemy);
	game.enemies.push(enemy);
}
// Handle collecting powerups
function collectPowerup(powerup) {
	LK.getSound('powerupCollect').play();
	pigeon.activatePowerup(powerup.type);
	// Visual feedback
	LK.effects.flashObject(pigeon, 0xFFFFFF, 500);
}
// Handle pigeon hit by enemy
function pigeonHit() {
	if (pigeon.powerups.shield > 0) {
		// Shield absorbs hit
		pigeon.powerups.shield = 0;
		LK.effects.flashObject(pigeon, 0x0000FF, 500);
		return;
	}
	lives--;
	updateUI();
	LK.getSound('pigeonHit').play();
	LK.effects.flashObject(pigeon, 0xFF0000, 500);
	if (lives <= 0) {
		gameOver();
	}
}
// Handle level completion
function checkLevelComplete() {
	// Level up after certain score thresholds
	var nextLevelThreshold = level * 100;
	if (score >= nextLevelThreshold) {
		level++;
		storage.level = level;
		// Update spawn rate for new level
		spawnRate = Math.max(120 - level * 10, 30);
		// Update UI
		updateUI();
		// Visual effect for level up
		LK.effects.flashScreen(0xFFFFFF, 500);
	}
}
// Game over function
function gameOver() {
	isGameOver = true;
	// Update high score if needed
	if (score > storage.highScore) {
		storage.highScore = score;
	}
	// Show game over screen
	LK.showGameOver();
}
// Spawn a power-up
function spawnPowerup(x, y) {
	var powerupTypes = ['multishot', 'speed', 'shield'];
	var type = powerupTypes[Math.floor(Math.random() * powerupTypes.length)];
	var powerup = new PowerUp(type);
	powerup.x = x;
	powerup.y = y;
	game.addChild(powerup);
	game.powerups.push(powerup);
}
// Touch/mouse handlers
game.down = function (x, y, obj) {
	// Move pigeon to touch position (x only)
	pigeon.x = x;
};
game.move = function (x, y, obj) {
	// Only update position if pressed
	if (obj.pressed) {
		pigeon.x = x;
	}
};
// Game update loop
game.update = function () {
	if (isGameOver) {
		return;
	}
	// Update player
	pigeon.update();
	// Spawn enemies
	if (LK.ticks - lastSpawn >= spawnRate) {
		spawnEnemy();
		lastSpawn = LK.ticks;
	}
	// Update breadcrumbs
	for (var i = game.breadcrumbs.length - 1; i >= 0; i--) {
		var breadcrumb = game.breadcrumbs[i];
		// Remove if off screen
		if (breadcrumb.y < -50) {
			breadcrumb.destroy();
			game.breadcrumbs.splice(i, 1);
			continue;
		}
		// Check for collisions with enemies
		for (var j = game.enemies.length - 1; j >= 0; j--) {
			var enemy = game.enemies[j];
			if (breadcrumb.intersects(enemy)) {
				// Handle hit
				var defeated = enemy.takeDamage(breadcrumb.damage);
				if (defeated) {
					// Add score
					score += enemy.points;
					updateUI();
					// Chance to spawn powerup
					if (Math.random() < powerupChance) {
						spawnPowerup(enemy.x, enemy.y);
					}
					// Remove enemy
					enemy.destroy();
					game.enemies.splice(j, 1);
					// Play sound
					LK.getSound('enemyHit').play();
				}
				// Remove breadcrumb
				breadcrumb.destroy();
				game.breadcrumbs.splice(i, 1);
				break;
			}
		}
	}
	// Update enemies
	for (var i = game.enemies.length - 1; i >= 0; i--) {
		var enemy = game.enemies[i];
		// Check if enemy passed bottom of screen
		if (enemy.y > 2732 + 100) {
			// Player loses a life
			pigeonHit();
			// Remove enemy
			enemy.destroy();
			game.enemies.splice(i, 1);
			continue;
		}
		// Check collision with pigeon
		if (enemy.intersects(pigeon)) {
			// Player loses a life
			pigeonHit();
			// Remove enemy
			enemy.destroy();
			game.enemies.splice(i, 1);
			continue;
		}
	}
	// Update powerups
	for (var i = game.powerups.length - 1; i >= 0; i--) {
		var powerup = game.powerups[i];
		// Remove if off screen
		if (powerup.y > 2732 + 50) {
			powerup.destroy();
			game.powerups.splice(i, 1);
			continue;
		}
		// Check collision with pigeon
		if (powerup.intersects(pigeon)) {
			collectPowerup(powerup);
			// Remove powerup
			powerup.destroy();
			game.powerups.splice(i, 1);
			continue;
		}
	}
	// Check for level completion
	checkLevelComplete();
};
// Initialize game
initGame();