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

/**** 
* Classes
****/ 
var Bullet = Container.expand(function (startX, startY, targetX, targetY) {
	var self = Container.call(this);
	var bulletGraphics = self.attachAsset('hitMarker', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 0.3,
		scaleY: 0.3
	});
	self.x = startX;
	self.y = startY;
	// Calculate direction and speed
	var dx = targetX - startX;
	var dy = targetY - startY;
	var distance = Math.sqrt(dx * dx + dy * dy);
	self.speed = 45;
	self.velocityX = dx / distance * self.speed;
	self.velocityY = dy / distance * self.speed;
	self.update = function () {
		self.x += self.velocityX;
		self.y += self.velocityY;
		// Remove bullet if it goes off screen - 100x increased range
		if (self.x < -10000 || self.x > 12048 || self.y < -10000 || self.y > 12732) {
			self.shouldDestroy = true;
		}
	};
	return self;
});
var Fortification = Container.expand(function () {
	var self = Container.call(this);
	var wallGraphics = self.attachAsset('turretBase', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 0.8,
		scaleY: 0.8,
		tint: 0x8B4513
	});
	self.health = 30;
	self.maxHealth = 30;
	self.lastDamageTime = 0;
	self.takeDamage = function (damage) {
		self.health -= damage;
		if (self.health <= 0) {
			self.health = 0;
			self.shouldDestroy = true;
		}
		// Visual feedback for damage
		LK.effects.flashObject(self, 0xff0000, 300);
	};
	return self;
});
var Obstacle = Container.expand(function () {
	var self = Container.call(this);
	var obstacleGraphics = self.attachAsset('turretBase', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 0.6,
		scaleY: 0.6,
		tint: 0x654321
	});
	self.width = 200;
	self.height = 200;
	self.health = 5;
	self.maxHealth = 5;
	self.trappedEnemies = [];
	self.trapTimer = {};
	self.takeDamage = function (damage) {
		self.health -= damage;
		if (self.health <= 0) {
			self.health = 0;
			self.shouldDestroy = true;
		}
		// Visual feedback for damage
		LK.effects.flashObject(self, 0xff0000, 300);
	};
	self.trapEnemy = function (enemy) {
		if (self.trappedEnemies.indexOf(enemy) === -1) {
			self.trappedEnemies.push(enemy);
			// Start attacking the obstacle instead of killing enemy immediately
			self.startAttackingObstacle(enemy);
		}
	};
	self.startAttackingObstacle = function (enemy) {
		// Enemy attacks obstacle every second
		self.trapTimer[enemy] = LK.setInterval(function () {
			if (self.health > 0) {
				self.takeDamage(1);
				if (self.health <= 0) {
					// Obstacle destroyed, enemy can move freely
					self.releaseEnemy(enemy);
				}
			} else {
				self.releaseEnemy(enemy);
			}
		}, 1000);
	};
	self.releaseEnemy = function (enemy) {
		// Remove from trapped enemies list
		var index = self.trappedEnemies.indexOf(enemy);
		if (index !== -1) {
			self.trappedEnemies.splice(index, 1);
		}
		// Clear timer
		if (self.trapTimer[enemy]) {
			LK.clearInterval(self.trapTimer[enemy]);
			delete self.trapTimer[enemy];
		}
	};
	self.explodeEnemy = function (enemy) {
		// Remove from trapped enemies list
		var index = self.trappedEnemies.indexOf(enemy);
		if (index !== -1) {
			self.trappedEnemies.splice(index, 1);
		}
		// Clear timer
		if (self.trapTimer[enemy]) {
			LK.clearTimeout(self.trapTimer[enemy]);
			delete self.trapTimer[enemy];
		}
		// Create explosion effect
		var explosion = game.addChild(LK.getAsset('hitMarker', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: enemy.x,
			y: enemy.y,
			scaleX: 2,
			scaleY: 2,
			tint: 0xff4400
		}));
		// Remove explosion after short time
		LK.setTimeout(function () {
			explosion.destroy();
		}, 300);
		// Play explosion sound
		LK.getSound('explosion').play();
		// Destroy enemy
		enemy.destroy();
		// Remove from zombies array
		var zombieIndex = zombies.indexOf(enemy);
		if (zombieIndex !== -1) {
			zombies.splice(zombieIndex, 1);
		}
		// Add score
		score += 20;
		zombiesKilledThisWave++;
		scoreTxt.setText('Score: ' + score + ' | Power: ' + weaponPower);
	};
	return self;
});
var SniperScope = Container.expand(function () {
	var self = Container.call(this);
	var scopeGraphics = self.attachAsset('scope', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 8,
		scaleY: 8
	});
	var crosshairGraphics = self.attachAsset('crosshair', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 0.5,
		scaleY: 0.5
	});
	self.lastIntersectingZombie = null;
	self.shootCooldown = 0;
	self.update = function () {
		// Decrease shoot cooldown
		if (self.shootCooldown > 0) {
			self.shootCooldown--;
		}
	};
	return self;
});
var WeaponTurret = Container.expand(function () {
	var self = Container.call(this);
	// Create turret base
	var turretBase = self.attachAsset('turretBase', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Create turret barrel
	var turretBarrel = self.attachAsset('turretBarrel', {
		anchorX: 0.2,
		anchorY: 0.5
	});
	self.targetAngle = 0;
	self.currentAngle = 0;
	self.rotationSpeed = 1.6;
	self.aimAt = function (targetX, targetY) {
		var dx = targetX - self.x;
		var dy = targetY - self.y;
		self.targetAngle = Math.atan2(dy, dx);
	};
	self.update = function () {
		// Smooth rotation towards target
		var angleDiff = self.targetAngle - self.currentAngle;
		// Handle angle wrapping
		if (angleDiff > Math.PI) angleDiff -= 2 * Math.PI;
		if (angleDiff < -Math.PI) angleDiff += 2 * Math.PI;
		// Apply rotation speed
		if (Math.abs(angleDiff) > 0.05) {
			self.currentAngle += angleDiff * self.rotationSpeed;
		} else {
			self.currentAngle = self.targetAngle;
		}
		// Update barrel rotation
		turretBarrel.rotation = self.currentAngle;
	};
	return self;
});
// Game variables
var Zombie = Container.expand(function (enemyType) {
	var self = Container.call(this);
	self.enemyType = enemyType || 'enemy';
	var zombieGraphics = self.attachAsset(self.enemyType, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Zombie properties - vary by enemy type
	var speedMultiplier = 1;
	var healthMultiplier = 1;
	switch (self.enemyType) {
		case 'zombie':
			speedMultiplier = 1.0;
			healthMultiplier = 1.0;
			break;
		case 'soldier':
			speedMultiplier = 1.2;
			healthMultiplier = 1.5;
			break;
		case 'robot':
			speedMultiplier = 0.8;
			healthMultiplier = 2;
			break;
		case 'alien':
			speedMultiplier = 1.5;
			healthMultiplier = 1.2;
			break;
		case 'demon':
			speedMultiplier = 2.0;
			healthMultiplier = 2.5;
			break;
		case 'mutant':
			speedMultiplier = 0.6;
			healthMultiplier = 3.0;
			break;
	}
	self.speed = (2 + Math.random() * 3) * speedMultiplier * 0.5; // Random speed between 2-5, reduced by 50%
	self.health = Math.ceil(healthMultiplier);
	self.maxHealth = self.health;
	self.targetX = 1024; // Center of screen
	self.targetY = 1366; // Center of screen
	self.update = function () {
		// Initialize jumping properties if not set
		if (self.jumpOffset === undefined) {
			self.jumpOffset = Math.random() * Math.PI * 2; // Random starting phase
			self.jumpAmplitude = 15 + Math.random() * 25; // Random jump height (15-40 pixels)
			self.jumpFrequency = 0.08 + Math.random() * 0.04; // Random jump speed
			self.baseY = self.y; // Store original Y position
		}
		self.jumpTime = (self.jumpTime || 0) + 1;
		// Move towards player (center of screen)
		var dx = self.targetX - self.x;
		var dy = self.targetY - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance > 5) {
			// Check for obstacles in path and avoid them
			var moveX = dx / distance * self.speed;
			var moveY = dy / distance * self.speed;
			// Add jumping motion - vertical bounce effect
			var jumpValue = Math.abs(Math.sin(self.jumpTime * self.jumpFrequency + self.jumpOffset)) * self.jumpAmplitude;
			// Apply jumping effect by modifying the graphics position, not the collision position
			zombieGraphics.y = -jumpValue; // Negative to jump upward
			// Create tween for smooth jumping motion when starting a new jump cycle
			if (self.jumpTime % Math.floor(Math.PI / self.jumpFrequency) === 0) {
				tween(zombieGraphics, {
					scaleX: 1.1,
					scaleY: 0.9
				}, {
					duration: 100,
					easing: tween.easeOut
				});
				tween(zombieGraphics, {
					scaleX: 1.0,
					scaleY: 1.0
				}, {
					duration: 200,
					easing: tween.easeIn
				});
			}
			var nextX = self.x + moveX;
			var nextY = self.y + moveY;
			// Check collision with obstacles
			var blocked = false;
			for (var i = 0; i < obstacles.length; i++) {
				var obstacle = obstacles[i];
				var obstacleLeft = obstacle.x - obstacle.width / 2;
				var obstacleRight = obstacle.x + obstacle.width / 2;
				var obstacleTop = obstacle.y - obstacle.height / 2;
				var obstacleBottom = obstacle.y + obstacle.height / 2;
				if (nextX > obstacleLeft && nextX < obstacleRight && nextY > obstacleTop && nextY < obstacleBottom) {
					blocked = true;
					// Check if zombie is getting trapped (stuck for a while)
					if (!self.stuckTimer) {
						self.stuckTimer = 0;
					}
					self.stuckTimer++;
					// If stuck for more than 2 seconds (120 ticks), consider trapped
					if (self.stuckTimer > 120) {
						obstacle.trapEnemy(self);
						self.stuckTimer = 0; // Reset to avoid multiple traps
					}
					// Simple avoidance - try to go around
					var centerX = obstacle.x;
					var centerY = obstacle.y;
					var toCenterX = self.x - centerX;
					var toCenterY = self.y - centerY;
					// Move perpendicular to the obstacle
					if (Math.abs(toCenterX) > Math.abs(toCenterY)) {
						moveY = toCenterX > 0 ? self.speed : -self.speed;
						moveX = 0;
					} else {
						moveX = toCenterY > 0 ? self.speed : -self.speed;
						moveY = 0;
					}
					break;
				}
			}
			if (!blocked) {
				// Normal movement toward target
				self.x += moveX;
				self.y += moveY;
				// Reset stuck timer when moving freely
				if (self.stuckTimer) {
					self.stuckTimer = 0;
				}
			} else {
				// Avoidance movement
				self.x += moveX;
				self.y += moveY;
			}
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Game variables
var zombies = [];
var bullets = [];
var score = 0;
var gameStarted = false;
var weaponPower = 1; // Base weapon power
var maxWeaponPower = 5; // Maximum weapon power
var currentLevel = 1;
var currentWave = 1;
var maxLevels = 100;
var maxWaves = 5;
var zombiesKilledThisWave = 0;
var zombiesNeededPerWave = 5;
var waveInProgress = false;
var enemyTypes = ['zombie', 'soldier', 'robot', 'alien', 'demon', 'mutant'];
var currentEnemyType = 'zombie';
var weaponTurretX = 1024; // Weapon turret position X
var weaponTurretY = 1366; // Weapon turret position Y (center of screen)
var weaponTurret = null; // Weapon turret instance
var obstacles = []; // Array to hold obstacles
// Create battlefield background
var battlefield = game.addChild(LK.getAsset('background', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 1024,
	y: 1366
}));
// Create weapon turret
weaponTurret = game.addChild(new WeaponTurret());
weaponTurret.x = weaponTurretX;
weaponTurret.y = weaponTurretY;
// Fortification walls removed per user request
var fortifications = [];
// Create obstacles in enemy advancement paths
var obstaclePositions = [{
	x: 512,
	y: 800
},
// Left path obstacle
{
	x: 1536,
	y: 800
},
// Right path obstacle
{
	x: 1024,
	y: 600
},
// Center top obstacle
{
	x: 300,
	y: 1200
},
// Left side obstacle
{
	x: 1748,
	y: 1200
} // Right side obstacle
];
// Create protective wall below weapon turret
var wallPositions = [{
	x: 624,
	y: 1900
},
// Extended left section of wall
{
	x: 824,
	y: 1900
},
// Left section of wall
{
	x: 1024,
	y: 1900
},
// Center section of wall
{
	x: 1224,
	y: 1900
},
// Right section of wall
{
	x: 1424,
	y: 1900
} // Extended right section of wall
];
for (var i = 0; i < obstaclePositions.length; i++) {
	var obstacle = new Obstacle();
	obstacle.x = obstaclePositions[i].x;
	obstacle.y = obstaclePositions[i].y;
	obstacles.push(obstacle);
	game.addChild(obstacle);
}
// Create protective wall below weapon turret
for (var i = 0; i < wallPositions.length; i++) {
	var wall = new Obstacle();
	wall.x = wallPositions[i].x;
	wall.y = wallPositions[i].y;
	obstacles.push(wall);
	game.addChild(wall);
}
// Scope removed per user request
// Create score display
var scoreTxt = new Text2('Score: 0', {
	size: 60,
	fill: 0xFFFFFF
});
scoreTxt.anchor.set(0, 0);
scoreTxt.x = 50;
scoreTxt.y = 50;
LK.gui.topLeft.addChild(scoreTxt);
// Create level and wave display
var levelTxt = new Text2('Level: 1 Wave: 1', {
	size: 50,
	fill: 0xFFFFFF
});
levelTxt.anchor.set(0, 0);
levelTxt.x = 50;
levelTxt.y = 120;
LK.gui.topLeft.addChild(levelTxt);
// Fortification health display removed since walls are removed
// Function to start next wave
function startNextWave() {
	waveInProgress = true;
	zombiesKilledThisWave = 0;
	// Determine enemy type based on level - cycle through all 6 types more frequently
	var typeIndex = (currentLevel - 1) % enemyTypes.length; // Cycle through all 6 types every 6 levels
	currentEnemyType = enemyTypes[typeIndex];
}
// Function to spawn enemy for current wave
function spawnEnemy() {
	if (!waveInProgress) return;
	// Add variety by sometimes spawning different types within the same wave
	var spawnType = currentEnemyType;
	if (Math.random() < 0.3) {
		// 30% chance to spawn a different type
		spawnType = enemyTypes[Math.floor(Math.random() * enemyTypes.length)];
	}
	var zombie = new Zombie(spawnType);
	// Spawn from random edges of the screen
	var side = Math.floor(Math.random() * 4);
	switch (side) {
		case 0:
			// Top
			zombie.x = Math.random() * 2048;
			zombie.y = -100;
			break;
		case 1:
			// Right
			zombie.x = 2148;
			zombie.y = Math.random() * 2732;
			break;
		case 2:
			// Bottom
			zombie.x = Math.random() * 2048;
			zombie.y = 2832;
			break;
		case 3:
			// Left
			zombie.x = -100;
			zombie.y = Math.random() * 2732;
			break;
	}
	zombie.lastX = zombie.x;
	zombie.lastY = zombie.y;
	zombie.lastIntersecting = false;
	zombies.push(zombie);
	game.addChild(zombie);
}
// Start first wave
startNextWave();
// Spawn enemies periodically
var spawnTimer = LK.setInterval(function () {
	spawnEnemy();
}, 1333); // Spawn every 1.333 seconds (50% faster spawn rate)
// Removed automatic turret shooting - now only shoots on touch
// Game variables for continuous shooting
var isTouchActive = false;
var lastTouchX = 0;
var lastTouchY = 0;
var shootTimer = null;
// Function to fire a bullet
function fireBullet(x, y) {
	// Aim turret at touch position
	weaponTurret.aimAt(x, y);
	// Check if we touched an enemy
	var touchedEnemy = null;
	for (var i = 0; i < zombies.length; i++) {
		var zombie = zombies[i];
		var dx = x - zombie.x;
		var dy = y - zombie.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance < 60) {
			// Touch tolerance
			touchedEnemy = zombie;
			break;
		}
	}
	if (touchedEnemy) {
		// Fire at the touched enemy
		var bullet = new Bullet(weaponTurretX, weaponTurretY, touchedEnemy.x, touchedEnemy.y);
		bullets.push(bullet);
		game.addChild(bullet);
		// Play shooting sound
		LK.getSound('shoot').play();
	} else {
		// Create bullet from weapon turret to touched position (original behavior)
		var bullet = new Bullet(weaponTurretX, weaponTurretY, x, y);
		bullets.push(bullet);
		game.addChild(bullet);
		// Play shooting sound
		LK.getSound('shoot').play();
	}
}
// Game event handlers
game.down = function (x, y, obj) {
	isTouchActive = true;
	lastTouchX = x;
	lastTouchY = y;
	// Fire immediately on touch down
	fireBullet(x, y);
	// Start continuous shooting
	shootTimer = LK.setInterval(function () {
		if (isTouchActive) {
			fireBullet(lastTouchX, lastTouchY);
		}
	}, 200); // Fire every 200ms while touching
};
game.up = function (x, y, obj) {
	isTouchActive = false;
	if (shootTimer) {
		LK.clearInterval(shootTimer);
		shootTimer = null;
	}
};
game.move = function (x, y, obj) {
	if (isTouchActive) {
		lastTouchX = x;
		lastTouchY = y;
	}
};
// Main game update loop
game.update = function () {
	// Update bullets and check for collisions
	for (var i = bullets.length - 1; i >= 0; i--) {
		var bullet = bullets[i];
		// Check collision with zombies
		for (var j = zombies.length - 1; j >= 0; j--) {
			var zombie = zombies[j];
			var dx = bullet.x - zombie.x;
			var dy = bullet.y - zombie.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance < 40) {
				// Hit detection
				// Create hit marker at impact point
				var hitMarker = game.addChild(LK.getAsset('hitMarker', {
					anchorX: 0.5,
					anchorY: 0.5,
					x: zombie.x,
					y: zombie.y,
					scaleX: weaponPower * 0.5,
					scaleY: weaponPower * 0.5
				}));
				// Remove hit marker after short time
				LK.setTimeout(function () {
					hitMarker.destroy();
				}, 200);
				// Play explosion sound on impact
				LK.getSound('explosion').play();
				// Remove zombie
				zombie.destroy();
				zombies.splice(j, 1);
				// Remove bullet
				bullet.destroy();
				bullets.splice(i, 1);
				// Increase score
				score += 10 * weaponPower;
				zombiesKilledThisWave++;
				scoreTxt.setText('Score: ' + score + ' | Power: ' + weaponPower);
				levelTxt.setText('Level: ' + currentLevel + ' Wave: ' + currentWave);
				break;
			}
		}
		// Remove bullets that are off screen
		if (bullet.shouldDestroy) {
			bullet.destroy();
			bullets.splice(i, 1);
		}
	}
	// Scope functionality removed - now using fixed weapon power
	weaponPower = 3; // Fixed weapon power without scope
	// Fortification update logic removed since walls are removed
	// Update obstacles and remove destroyed ones
	for (var i = obstacles.length - 1; i >= 0; i--) {
		var obstacle = obstacles[i];
		if (obstacle.shouldDestroy) {
			// Release all trapped enemies
			for (var j = 0; j < obstacle.trappedEnemies.length; j++) {
				var enemy = obstacle.trappedEnemies[j];
				if (obstacle.trapTimer[enemy]) {
					LK.clearInterval(obstacle.trapTimer[enemy]);
				}
			}
			obstacle.destroy();
			obstacles.splice(i, 1);
		}
	}
	// Update all zombies
	for (var i = zombies.length - 1; i >= 0; i--) {
		var zombie = zombies[i];
		// Check if zombie reached center (player position)
		var dx = zombie.x - 1024;
		var dy = zombie.y - 1366;
		var distanceToCenter = Math.sqrt(dx * dx + dy * dy);
		if (distanceToCenter < 50) {
			// Game over - zombie reached player
			LK.effects.flashScreen(0xff0000, 1000);
			LK.showGameOver();
			return;
		}
		// Remove zombies that are too far (cleanup)
		if (zombie.x < -200 || zombie.x > 2248 || zombie.y < -200 || zombie.y > 2932) {
			zombie.destroy();
			zombies.splice(i, 1);
		}
	}
	// Fortification health display update removed since walls are removed
	// Check wave completion
	if (waveInProgress && zombiesKilledThisWave >= zombiesNeededPerWave && zombies.length === 0) {
		waveInProgress = false;
		currentWave++;
		// Check if completed all waves in level
		if (currentWave > maxWaves) {
			currentWave = 1;
			currentLevel++;
			zombiesNeededPerWave += 2; // Increase difficulty
		}
		// Check if completed all levels
		if (currentLevel > maxLevels) {
			LK.showYouWin();
			return;
		}
		// Start next wave after short delay
		LK.setTimeout(function () {
			startNextWave();
		}, 1000);
	}
	// Win condition - complete all 100 levels
	if (currentLevel > maxLevels) {
		LK.showYouWin();
	}
};