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

/**** 
* Classes
****/ 
var BackgroundTile = Container.expand(function () {
	var self = Container.call(this);
	// Randomly pick one of two backgrounds for variety
	var bgTypes = ['background', 'background2'];
	var bgType = bgTypes[Math.floor(Math.random() * bgTypes.length)];
	var graphics = self.attachAsset(bgType, {
		anchorX: 0,
		anchorY: 0
	});
	// Slower speed for new game pace
	self.speed = 0.7;
	// Store width for seamless tiling
	self.tileWidth = graphics.width;
	self.update = function () {
		self.x -= self.speed;
	};
	return self;
});
var Enemy = Container.expand(function () {
	var self = Container.call(this);
	self.health = 30;
	self.maxHealth = 30;
	self.speed = 1;
	self.hitRecently = false;
	// Randomize parts
	var headTypes = ['enemyHead1', 'enemyHead2', 'enemyHead3'];
	var bodyTypes = ['enemyBody1', 'enemyBody2', 'enemyBody3'];
	var legTypes = ['enemyLeg1', 'enemyLeg2'];
	var headType = headTypes[Math.floor(Math.random() * headTypes.length)];
	var bodyType = bodyTypes[Math.floor(Math.random() * bodyTypes.length)];
	var legType = legTypes[Math.floor(Math.random() * legTypes.length)];
	// Create parts with adjusted positioning
	var head = self.attachAsset(headType, {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 0,
		y: -105
	});
	var body = self.attachAsset(bodyType, {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 0,
		y: 0
	});
	var leftLeg = self.attachAsset(legType, {
		anchorX: 0.5,
		anchorY: 0.5,
		x: -20,
		y: 95
	});
	var rightLeg = self.attachAsset(legType, {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 20,
		y: 95
	});
	self.head = head;
	self.body = body;
	self.leftLeg = leftLeg;
	self.rightLeg = rightLeg;
	// Set up layering - legs under body, head on top
	self.setChildIndex(leftLeg, 0);
	self.setChildIndex(rightLeg, 1);
	self.setChildIndex(body, 2);
	self.setChildIndex(head, 3);
	// Walking animation variables
	self.walkTimer = 0;
	self.walkSpeed = 0.3;
	self.takeDamage = function (damage, isHeadshot) {
		if (self.hitRecently) return;
		var actualDamage = isHeadshot ? damage * 2 : damage;
		self.health -= actualDamage;
		self.hitRecently = true;
		// Flash effect
		LK.effects.flashObject(self, 0xFF0000, 200);
		LK.setTimeout(function () {
			self.hitRecently = false;
		}, 300);
		if (self.health <= 0) {
			LK.setScore(LK.getScore() + 10);
			return true; // Enemy died
		}
		return false;
	};
	self.update = function () {
		self.x -= self.speed;
		// Walking animation
		self.walkTimer += self.walkSpeed;
		var leftLegOffset = Math.sin(self.walkTimer) * 15;
		var rightLegOffset = Math.sin(self.walkTimer + Math.PI) * 15;
		// Animate legs - one forward while other goes back
		tween(self.leftLeg, {
			x: -20 + leftLegOffset
		}, {
			duration: 100
		});
		tween(self.rightLeg, {
			x: 20 + rightLegOffset
		}, {
			duration: 100
		});
	};
	return self;
});
var InventorySlot = Container.expand(function (itemType, count) {
	var self = Container.call(this);
	self.itemType = itemType || 'normal';
	self.count = count || 5;
	self.maxCount = 10;
	var slot = self.attachAsset('inventorySlot', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.countText = new Text2(self.count.toString(), {
		size: 30,
		fill: 0xFFFFFF
	});
	self.countText.anchor.set(0.5, 0.5);
	self.countText.x = 0;
	self.countText.y = 0;
	self.addChild(self.countText);
	self.updateCount = function () {
		self.countText.setText(self.count.toString());
	};
	self.canUse = function () {
		return self.count > 0;
	};
	self.use = function () {
		if (self.canUse()) {
			self.count--;
			self.updateCount();
			return true;
		}
		return false;
	};
	self.down = function (x, y, obj) {
		if (self.canUse()) {
			selectedItem = self.itemType;
			selectedSlot = self;
		}
	};
	return self;
});
var Projectile = Container.expand(function (type) {
	var self = Container.call(this);
	self.type = type || 'normal';
	self.speed = 8;
	self.damage = 10;
	self.hasHit = false;
	var graphics = self.attachAsset('projectile', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.velocityX = 0;
	self.velocityY = 0;
	self.update = function () {
		self.x += self.velocityX;
		self.y += self.velocityY;
		// Apply gravity
		self.velocityY += 0.3;
	};
	return self;
});

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

/**** 
* Game Code
****/ 
var player;
var enemies = [];
var projectiles = [];
var backgroundTiles = [];
var inventorySlots = [];
var trajectoryDots = [];
var selectedItem = null;
var selectedSlot = null;
var isDragging = false;
var dragStartX = 0;
var dragStartY = 0;
var launchPower = 0;
var launchAngle = 0;
var enemySpawnTimer = 0;
var backgroundSpawnTimer = 0;
// Add inventory texture to bottom left corner
var inventoryTexture = game.addChild(LK.getAsset('inventory', {
	anchorX: 0,
	anchorY: 1,
	x: 50,
	y: 2732 - 50
}));
// Initialize inventory
var inventoryTypes = ['normal', 'bouncing', 'explosive'];
for (var i = 0; i < inventoryTypes.length; i++) {
	var slot = new InventorySlot(inventoryTypes[i], 5);
	slot.x = 100;
	slot.y = 200 + i * 120;
	// Make first slot (normal projectiles) unlimited
	if (i === 0) {
		slot.count = 999;
		slot.maxCount = 999;
		slot.updateCount();
	}
	inventorySlots.push(slot);
	game.addChild(slot);
}
// Initialize background
// Use enough tiles to cover the screen horizontally, based on tile width
var initialTile = new BackgroundTile();
var tileWidth = initialTile.tileWidth;
initialTile.x = 0;
initialTile.y = 0;
backgroundTiles.push(initialTile);
game.addChild(initialTile);
var numTiles = Math.ceil(2048 / tileWidth) + 2; // +2 for seamless wrap
for (var i = 1; i < numTiles; i++) {
	var tile = new BackgroundTile();
	tile.x = i * tileWidth;
	tile.y = 0;
	backgroundTiles.push(tile);
	game.addChild(tile);
}
// Initialize player with running animation (after background to appear in front)
player = game.addChild(new Container());
var playerGraphics = player.attachAsset('player', {
	anchorX: 0.5,
	anchorY: 0.5
});
player.x = 390;
player.y = 1366;
// Animation variables
player.animationFrame = 0;
player.animationFrames = ['player', 'player2', 'player3', 'player2'];
player.currentGraphics = playerGraphics;
// Start running animation
function animatePlayer() {
	// Change to next frame
	player.animationFrame = (player.animationFrame + 1) % player.animationFrames.length;
	var nextFrame = player.animationFrames[player.animationFrame];
	// Add new frame first
	var newGraphics = player.attachAsset(nextFrame, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Wait 50ms before removing old graphics to prevent disappearing
	LK.setTimeout(function () {
		player.removeChild(player.currentGraphics);
		player.currentGraphics = newGraphics;
	}, 50);
	// Schedule next frame change
	LK.setTimeout(animatePlayer, 200);
}
// Start the animation
LK.setTimeout(animatePlayer, 200);
// Auto-select first slot (unlimited standard projectiles)
selectedItem = inventorySlots[0].itemType;
selectedSlot = inventorySlots[0];
// Score display
var scoreText = new Text2('Score: 0', {
	size: 60,
	fill: 0xFFFFFF
});
scoreText.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreText);
function updateTrajectory(startX, startY, endX, endY) {
	// Clear existing trajectory dots
	for (var i = 0; i < trajectoryDots.length; i++) {
		trajectoryDots[i].destroy();
	}
	trajectoryDots = [];
	if (!isDragging) return;
	var deltaX = startX - endX;
	var deltaY = startY - endY;
	var distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
	launchPower = Math.min(distance / 10, 30);
	launchAngle = Math.atan2(deltaY, deltaX);
	var velocityX = Math.cos(launchAngle) * launchPower;
	var velocityY = Math.sin(launchAngle) * launchPower;
	// Create trajectory preview
	var simX = startX;
	var simY = startY;
	var simVelX = velocityX;
	var simVelY = velocityY;
	for (var i = 0; i < 60; i++) {
		if (i % 3 === 0) {
			var dot = game.addChild(LK.getAsset('trajectoryDot', {
				anchorX: 0.5,
				anchorY: 0.5,
				x: simX,
				y: simY
			}));
			// Ensure trajectory dot appears in front of background
			game.setChildIndex(dot, game.children.length - 1);
			trajectoryDots.push(dot);
		}
		simX += simVelX;
		simY += simVelY;
		simVelY += 0.3; // Gravity
		if (simY > 2732) break;
	}
}
function launchProjectile(startX, startY, endX, endY) {
	if (!selectedItem || !selectedSlot || !selectedSlot.canUse()) return;
	var deltaX = startX - endX;
	var deltaY = startY - endY;
	var distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
	launchPower = Math.min(distance / 10, 30);
	launchAngle = Math.atan2(deltaY, deltaX);
	var projectile = new Projectile(selectedItem);
	projectile.x = startX;
	projectile.y = startY;
	projectile.velocityX = Math.cos(launchAngle) * launchPower;
	projectile.velocityY = Math.sin(launchAngle) * launchPower;
	projectiles.push(projectile);
	game.addChild(projectile);
	// Ensure projectile appears in front of background
	game.setChildIndex(projectile, game.children.length - 1);
	selectedSlot.use();
	selectedItem = null;
	selectedSlot = null;
	LK.getSound('launch').play();
}
game.down = function (x, y, obj) {
	// Check if touch/click is within expanded area around player (200px radius for easier interaction)
	var distanceToPlayer = Math.sqrt((x - player.x) * (x - player.x) + (y - player.y) * (y - player.y));
	if (selectedItem && distanceToPlayer < 200) {
		isDragging = true;
		dragStartX = player.x;
		dragStartY = player.y;
		updateTrajectory(player.x, player.y, x, y);
	}
};
game.move = function (x, y, obj) {
	if (isDragging) {
		updateTrajectory(player.x, player.y, x, y);
	}
};
game.up = function (x, y, obj) {
	if (isDragging) {
		launchProjectile(player.x, player.y, x, y);
		isDragging = false;
		// Clear trajectory dots
		for (var i = 0; i < trajectoryDots.length; i++) {
			trajectoryDots[i].destroy();
		}
		trajectoryDots = [];
	}
};
game.update = function () {
	// Update score display
	scoreText.setText('Score: ' + LK.getScore());
	// Spawn enemies
	enemySpawnTimer++;
	if (enemySpawnTimer > 180) {
		enemySpawnTimer = 0;
		var enemy = new Enemy();
		enemy.x = 2200;
		enemy.y = player.y - 40 + Math.random() * 80;
		enemies.push(enemy);
		game.addChild(enemy);
	}
	// Update background tiles for seamless looping
	for (var i = 0; i < backgroundTiles.length; i++) {
		var tile = backgroundTiles[i];
		tile.update();
	}
	// If the leftmost tile is fully off screen, move it to the right of the rightmost tile
	// This creates a seamless infinite scroll
	if (backgroundTiles.length > 0) {
		var leftmost = backgroundTiles[0];
		var rightmost = backgroundTiles[backgroundTiles.length - 1];
		// Use tileWidth from the tile itself for accuracy
		if (leftmost.x + leftmost.tileWidth < 0) {
			// Move leftmost tile to the right of the rightmost tile
			leftmost.x = rightmost.x + rightmost.tileWidth;
			// Move to end of array
			backgroundTiles.push(backgroundTiles.shift());
		}
	}
	// Update enemies
	for (var i = enemies.length - 1; i >= 0; i--) {
		var enemy = enemies[i];
		if (enemy.x < -200) {
			enemy.destroy();
			enemies.splice(i, 1);
		}
	}
	// Update projectiles
	for (var i = projectiles.length - 1; i >= 0; i--) {
		var projectile = projectiles[i];
		if (projectile.x > 2200 || projectile.y > 2800 || projectile.x < -100) {
			projectile.destroy();
			projectiles.splice(i, 1);
			continue;
		}
		// Check collision with enemies
		for (var j = enemies.length - 1; j >= 0; j--) {
			var enemy = enemies[j];
			if (projectile.intersects(enemy) && !projectile.hasHit) {
				projectile.hasHit = true;
				// Check if headshot
				var isHeadshot = projectile.intersects(enemy.head);
				var died = enemy.takeDamage(projectile.damage, isHeadshot);
				LK.getSound('hit').play();
				if (died) {
					enemy.destroy();
					enemies.splice(j, 1);
				}
				if (projectile.type !== 'piercing') {
					projectile.destroy();
					projectiles.splice(i, 1);
					break;
				}
			}
		}
	}
	// Replenish inventory occasionally
	if (LK.ticks % 600 === 0) {
		for (var i = 0; i < inventorySlots.length; i++) {
			var slot = inventorySlots[i];
			if (slot.count < slot.maxCount) {
				slot.count = Math.min(slot.count + 1, slot.maxCount);
				slot.updateCount();
			}
		}
	}
};