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

/**** 
* Classes
****/ 
var Enemy = Container.expand(function () {
	var self = Container.call(this);
	var enemyGraphics = self.attachAsset('enemigo', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 30; // Enemy movement speed
	self.chaseDelay = 1000; // Time between chase movements
	self.chasePlayer = function () {
		var deltaX = player.x - self.x;
		var deltaY = player.y - self.y;
		var distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
		if (distance > 50) {
			// Calculate movement direction
			var directionX = deltaX / distance;
			var directionY = deltaY / distance;
			// Move continuously towards player at constant speed
			var moveSpeed = 3; // Pixels per frame - set to exactly 3
			self.x += directionX * moveSpeed;
			self.y += directionY * moveSpeed;
			// Keep enemy within bounds
			self.x = Math.max(80, Math.min(1968, self.x));
			self.y = Math.max(120, Math.min(2612, self.y));
			// Rotate to face player smoothly
			var targetRotation = Math.atan2(deltaY, deltaX) + Math.PI / 2;
			var rotationDiff = targetRotation - self.rotation;
			// Normalize rotation difference to [-PI, PI]
			while (rotationDiff > Math.PI) rotationDiff -= 2 * Math.PI;
			while (rotationDiff < -Math.PI) rotationDiff += 2 * Math.PI;
			// Smooth rotation
			self.rotation += rotationDiff * 0.1;
		}
	};
	return self;
});
var Factory = Container.expand(function () {
	var self = Container.call(this);
	var factoryGraphics = self.attachAsset('fabrica', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.spawnTimer = 0;
	self.spawnDelay = 420; // Spawn enemy every 7 seconds (420 frames at 60fps)
	self.spawnEnemy = function () {
		var newEnemy = new Enemy();
		newEnemy.x = self.x;
		newEnemy.y = self.y;
		enemies.push(newEnemy);
		camera.addChild(newEnemy);
	};
	self.update = function () {
		self.spawnTimer++;
		if (self.spawnTimer >= self.spawnDelay) {
			self.spawnEnemy();
			self.spawnTimer = 0;
		}
	};
	return self;
});
var Player = Container.expand(function () {
	var self = Container.call(this);
	var playerGraphics = self.attachAsset('player', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	return self;
});

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

/**** 
* Game Code
****/ 
// Create extended background that covers the entire visible area including camera zoom
var extendedBackground = game.addChild(LK.getAsset('fondo', {
	anchorX: 0,
	anchorY: 0,
	scaleX: 40.96,
	// Double scale to cover zoomed view (2048*2/100)
	scaleY: 54.64,
	// Double scale to cover zoomed view (2732*2/100)
	x: -2048,
	// Offset to center the extended background
	y: -2732 // Offset to center the extended background
}));
// Create additional background for right side
var rightBackground = game.addChild(LK.getAsset('fondo', {
	anchorX: 0,
	anchorY: 0,
	scaleX: 20.48,
	// Scale to cover additional right area
	scaleY: 27.32,
	// Scale to cover full height
	x: 2048,
	// Position to the right of main map
	y: 0
}));
// Create additional background for bottom side
var bottomBackground = game.addChild(LK.getAsset('fondo', {
	anchorX: 0,
	anchorY: 0,
	scaleX: 20.48,
	// Scale to cover full width
	scaleY: 27.32,
	// Scale to cover additional bottom area
	x: 0,
	y: 2732 // Position below main map
}));
// Create additional background for top-right corner
var topRightBackground = game.addChild(LK.getAsset('fondo', {
	anchorX: 0,
	anchorY: 0,
	scaleX: 20.48,
	// Scale to cover corner area
	scaleY: 27.32,
	// Scale to cover corner area
	x: 2048,
	// Position to the right
	y: -2732 // Position above main map
}));
// Create additional background for bottom-right corner
var bottomRightBackground = game.addChild(LK.getAsset('fondo', {
	anchorX: 0,
	anchorY: 0,
	scaleX: 20.48,
	// Scale to cover corner area
	scaleY: 27.32,
	// Scale to cover corner area
	x: 2048,
	// Position to the right
	y: 2732 // Position below main map
}));
// Create additional background for bottom-left corner
var bottomLeftBackground = game.addChild(LK.getAsset('fondo', {
	anchorX: 0,
	anchorY: 0,
	scaleX: 20.48,
	// Scale to cover corner area
	scaleY: 27.32,
	// Scale to cover corner area
	x: -2048,
	// Position to the left
	y: 2732 // Position below main map
}));
// Create large map floor - scale the grass background to cover entire game area
var mapFloor = game.addChild(LK.getAsset('fondo', {
	anchorX: 0,
	anchorY: 0,
	scaleX: 20.48,
	// Scale to cover 2048px width (2048/100)
	scaleY: 27.32,
	// Scale to cover 2732px height (2732/100)
	x: 0,
	y: 0
}));
// Create trees around all borders
var trees = [];
// Top border trees
for (var i = 0; i < 26; i++) {
	var topTree = game.addChild(LK.getAsset('arbol', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: i * 80 + 40,
		y: 60
	}));
	trees.push(topTree);
}
// Bottom border trees
for (var i = 0; i < 26; i++) {
	var bottomTree = game.addChild(LK.getAsset('arbol', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: i * 80 + 40,
		y: 2672
	}));
	trees.push(bottomTree);
}
// Left border trees (excluding corners already covered)
for (var i = 1; i < 33; i++) {
	var leftTree = game.addChild(LK.getAsset('arbol', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 40,
		y: i * 80 + 60
	}));
	trees.push(leftTree);
}
// Right border trees (excluding corners already covered)
for (var i = 1; i < 33; i++) {
	var rightTree = game.addChild(LK.getAsset('arbol', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 2008,
		y: i * 80 + 60
	}));
	trees.push(rightTree);
}
// Create camera container for following player
var camera = game.addChild(new Container());
camera.x = 1024;
camera.y = 1366;
// Move all game elements to camera container
camera.addChild(extendedBackground);
camera.addChild(rightBackground);
camera.addChild(bottomBackground);
camera.addChild(topRightBackground);
camera.addChild(bottomRightBackground);
camera.addChild(bottomLeftBackground);
camera.addChild(mapFloor);
for (var i = 0; i < trees.length; i++) {
	camera.addChild(trees[i]);
}
// Add random trees scattered throughout the map
var randomTrees = [];
for (var i = 0; i < 80; i++) {
	var randomX = Math.random() * (2048 - 160) + 80; // Keep away from borders
	var randomY = Math.random() * (2732 - 240) + 120; // Keep away from borders
	var randomTree = camera.addChild(LK.getAsset('arbol', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: randomX,
		y: randomY
	}));
	randomTrees.push(randomTree);
}
// Create player and add to camera
var player = camera.addChild(new Player());
player.x = 1024;
player.y = 1366;
// Create enemies array
var enemies = [];
// Create factories array
var factories = [];
// Create factory in top-left corner
var topLeftFactory = camera.addChild(new Factory());
topLeftFactory.x = 400;
topLeftFactory.y = 400;
factories.push(topLeftFactory);
// Create factory in top-right corner
var topRightFactory = camera.addChild(new Factory());
topRightFactory.x = 1648;
topRightFactory.y = 400;
factories.push(topRightFactory);
// Create factory in bottom-left corner
var bottomLeftFactory = camera.addChild(new Factory());
bottomLeftFactory.x = 400;
bottomLeftFactory.y = 2332;
factories.push(bottomLeftFactory);
// Create factory in bottom-right corner
var bottomRightFactory = camera.addChild(new Factory());
bottomRightFactory.x = 1648;
bottomRightFactory.y = 2332;
factories.push(bottomRightFactory);
// Set camera scale for closer view
camera.scaleX = 2;
camera.scaleY = 2;
// Game controls - move player toward touch position
var playerSpeed = 4; // Player movement speed
var targetX = player.x;
var targetY = player.y;
var isMoving = false;
function updatePlayerMovement(x, y) {
	// Convert screen coordinates to world coordinates accounting for camera transform
	var worldX = (x - camera.x) / camera.scaleX;
	var worldY = (y - camera.y) / camera.scaleY;
	targetX = worldX;
	targetY = worldY;
	isMoving = true;
}
game.down = function (x, y, obj) {
	updatePlayerMovement(x, y);
};
game.move = function (x, y, obj) {
	updatePlayerMovement(x, y);
};
game.up = function (x, y, obj) {
	isMoving = false;
};
// Main game update loop
game.update = function () {
	// Move player toward target position if moving
	if (isMoving) {
		var deltaX = targetX - player.x;
		var deltaY = targetY - player.y;
		var distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
		if (distance > 5) {
			// Only move if not close enough to target
			// Calculate movement direction
			var directionX = deltaX / distance;
			var directionY = deltaY / distance;
			// Move player toward target
			player.x += directionX * playerSpeed;
			player.y += directionY * playerSpeed;
			// Rotate player to face movement direction
			var targetRotation = Math.atan2(deltaY, deltaX) + Math.PI / 2;
			var rotationDiff = targetRotation - player.rotation;
			// Normalize rotation difference to [-PI, PI]
			while (rotationDiff > Math.PI) rotationDiff -= 2 * Math.PI;
			while (rotationDiff < -Math.PI) rotationDiff += 2 * Math.PI;
			// Smooth rotation
			player.rotation += rotationDiff * 0.15;
		}
	}
	// Keep player within bounds, accounting for tree borders
	player.x = Math.max(80, Math.min(1968, player.x));
	player.y = Math.max(120, Math.min(2612, player.y));
	// Update camera position to follow player
	var targetCameraX = 1024 - player.x * camera.scaleX;
	var targetCameraY = 1366 - player.y * camera.scaleY;
	// Smooth camera following
	camera.x += (targetCameraX - camera.x) * 0.1;
	camera.y += (targetCameraY - camera.y) * 0.1;
	// Handle enemy collision detection - prevent enemies from overlapping
	for (var i = 0; i < enemies.length; i++) {
		for (var j = i + 1; j < enemies.length; j++) {
			var enemy1 = enemies[i];
			var enemy2 = enemies[j];
			var deltaX = enemy2.x - enemy1.x;
			var deltaY = enemy2.y - enemy1.y;
			var distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
			var minDistance = 80; // Minimum distance between enemies
			if (distance < minDistance && distance > 0) {
				// Calculate separation force
				var separationForce = (minDistance - distance) / 2;
				var separationX = deltaX / distance * separationForce;
				var separationY = deltaY / distance * separationForce;
				// Push enemies apart
				enemy1.x -= separationX;
				enemy1.y -= separationY;
				enemy2.x += separationX;
				enemy2.y += separationY;
				// Keep enemies within bounds after separation
				enemy1.x = Math.max(80, Math.min(1968, enemy1.x));
				enemy1.y = Math.max(120, Math.min(2612, enemy1.y));
				enemy2.x = Math.max(80, Math.min(1968, enemy2.x));
				enemy2.y = Math.max(120, Math.min(2612, enemy2.y));
			}
		}
	}
	// Update factories
	for (var i = 0; i < factories.length; i++) {
		factories[i].update();
	}
	// Update enemies - make them chase player every frame for smooth movement
	for (var i = 0; i < enemies.length; i++) {
		enemies[i].chasePlayer();
	}
};