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

/**** 
* Classes
****/ 
var Explosion = Container.expand(function () {
	var self = Container.call(this);
	// Attach the explosion sprite
	var explosionSprite = self.attachAsset('Explosion', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Animation properties
	self.animationTimer = 500; // Animation duration in ms
	self.initialScale = 0.1;
	self.finalScale = 3.0;
	// Set initial scale
	explosionSprite.scaleX = self.initialScale;
	explosionSprite.scaleY = self.initialScale;
	// Start explosion animation
	tween(explosionSprite, {
		scaleX: self.finalScale,
		scaleY: self.finalScale,
		alpha: 0
	}, {
		duration: self.animationTimer,
		easing: tween.easeOut,
		onFinish: function onFinish() {
			self.destroy();
		}
	});
	return self;
});
var Guerrero = Container.expand(function () {
	var self = Container.call(this);
	// Attach the warrior sprite
	var guerreroSprite = self.attachAsset('Guerrero', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Movement properties
	self.speed = 600; // Speed for tween animation
	self.isAttacking = false;
	self.attackDuration = 300; // Attack animation duration in ms
	self.attackTimer = 0;
	// Target position for automatic movement
	self.targetX = null;
	self.targetY = null;
	self.isMoving = false;
	// Track last movement direction for slash attacks
	self.lastDirection = {
		x: 1,
		y: 0
	}; // Default direction (right)
	// Update method called every frame
	self.update = function () {
		// Handle attack animation
		if (self.isAttacking) {
			self.attackTimer -= 16; // Approximate 60fps
			if (self.attackTimer <= 0) {
				self.isAttacking = false;
				guerreroSprite.rotation = 0;
				guerreroSprite.scaleX = 1;
			} else {
				// Simple attack animation - rotate and scale
				var progress = 1 - self.attackTimer / self.attackDuration;
				guerreroSprite.rotation = Math.sin(progress * Math.PI) * 0.5;
				guerreroSprite.scaleX = 1 + Math.sin(progress * Math.PI) * 0.3;
			}
		}
	};
	// Move to target position using tween
	self.moveToTarget = function (targetX, targetY) {
		// Stop any current movement
		tween.stop(self, {
			x: true,
			y: true
		});
		// Set new target
		self.targetX = targetX;
		self.targetY = targetY;
		self.isMoving = true;
		// Calculate distance for duration
		var distance = Math.sqrt(Math.pow(targetX - self.x, 2) + Math.pow(targetY - self.y, 2));
		var duration = distance / self.speed * 1000; // Convert to milliseconds
		// Update last movement direction
		if (distance > 0) {
			self.lastDirection.x = (targetX - self.x) / distance;
			self.lastDirection.y = (targetY - self.y) / distance;
		}
		// Start continuous walking animation
		self.startWalkingAnimation();
		// Start tween to target position
		tween(self, {
			x: targetX,
			y: targetY
		}, {
			duration: duration,
			easing: tween.linear,
			onFinish: function onFinish() {
				self.isMoving = false;
				self.targetX = null;
				self.targetY = null;
				// Stop walking animation and reset sprite to normal state
				tween.stop(guerreroSprite, {
					scaleX: true,
					scaleY: true
				});
				guerreroSprite.scaleX = 1;
				guerreroSprite.scaleY = 1;
				// Hide joystick when target is reached
				if (joystickSprite) {
					joystickSprite.destroy();
					joystickSprite = null;
				}
			}
		});
	};
	// Attack method
	self.attack = function () {
		if (!self.isAttacking) {
			self.isAttacking = true;
			self.attackTimer = self.attackDuration;
			// Create and launch slash in last movement direction
			self.createSlash();
		}
	};
	// Create slash method
	self.createSlash = function () {
		var slash = new Slash();
		slash.x = self.x;
		slash.y = self.y;
		slash.setDirection(self.lastDirection.x, self.lastDirection.y);
		game.addChild(slash);
	};
	// Start continuous walking animation
	self.startWalkingAnimation = function () {
		self.walkCycle();
	};
	// Continuous walking cycle animation
	self.walkCycle = function () {
		if (!self.isMoving) return; // Stop animation if not moving
		tween(guerreroSprite, {
			scaleX: 1.1,
			scaleY: 0.9
		}, {
			duration: 200,
			easing: tween.easeInOut,
			onFinish: function onFinish() {
				if (!self.isMoving) return; // Check again before next cycle
				tween(guerreroSprite, {
					scaleX: 0.9,
					scaleY: 1.1
				}, {
					duration: 200,
					easing: tween.easeInOut,
					onFinish: function onFinish() {
						if (self.isMoving) {
							self.walkCycle(); // Continue the loop
						}
					}
				});
			}
		});
	};
	return self;
});
var RedSlimeEnemy = Container.expand(function () {
	var self = Container.call(this);
	// Attach the red slime sprite
	var slimeSprite = self.attachAsset('Slime_Red', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Movement properties
	self.speed = 160; // Double the speed of blue slimes (80 * 2)
	// Update method called every frame
	self.update = function () {
		// Calculate direction towards player
		var dx = guerrero.x - self.x;
		var dy = guerrero.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		// Move towards player if distance > 0
		if (distance > 0) {
			var normalizedX = dx / distance;
			var normalizedY = dy / distance;
			self.x += normalizedX * self.speed * (16 / 1000); // 16ms per frame at 60fps
			self.y += normalizedY * self.speed * (16 / 1000);
		}
	};
	return self;
});
var Slash = Container.expand(function () {
	var self = Container.call(this);
	// Attach the slash sprite
	var slashSprite = self.attachAsset('tajo', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Movement properties
	self.speed = 3200; // Quadruple fast movement speed
	self.directionX = 1; // Movement direction X
	self.directionY = 0; // Movement direction Y
	// Update method called every frame
	self.update = function () {
		// Move in the specified direction
		self.x += self.directionX * self.speed * (16 / 1000); // 16ms per frame at 60fps
		self.y += self.directionY * self.speed * (16 / 1000);
		// Check if slash is off screen and destroy it
		if (self.x < -50 || self.x > 2048 + 50 || self.y < -50 || self.y > 2732 + 50) {
			self.destroy();
		}
	};
	// Set direction method
	self.setDirection = function (dirX, dirY) {
		self.directionX = dirX;
		self.directionY = dirY;
		// Rotate sprite to match direction
		slashSprite.rotation = Math.atan2(dirY, dirX);
	};
	return self;
});
var SlimeEnemy = Container.expand(function () {
	var self = Container.call(this);
	// Attach the slime sprite
	var slimeSprite = self.attachAsset('slime_blue', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Movement properties
	self.speed = 80; // Slightly faster movement speed
	// Update method called every frame
	self.update = function () {
		// Calculate direction towards player
		var dx = guerrero.x - self.x;
		var dy = guerrero.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		// Move towards player if distance > 0
		if (distance > 0) {
			var normalizedX = dx / distance;
			var normalizedY = dy / distance;
			self.x += normalizedX * self.speed * (16 / 1000); // 16ms per frame at 60fps
			self.y += normalizedY * self.speed * (16 / 1000);
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Calculate how many tiles we need to cover the full screen (2048x2732)
// Create ground background covering the entire screen
var tileWidth = 100;
var tileHeight = 100;
var tilesX = Math.ceil(2048 / tileWidth);
var tilesY = Math.ceil(2732 / tileHeight);
// Create a container for all ground tiles
var groundContainer = new Container();
game.addChild(groundContainer);
// Fill the entire screen with ground tiles
for (var x = 0; x < tilesX; x++) {
	for (var y = 0; y < tilesY; y++) {
		var groundTile = LK.getAsset('Suelo', {
			x: x * tileWidth,
			y: y * tileHeight
		});
		groundContainer.addChild(groundTile);
	}
	;
	// Game update loop
	game.update = function () {
		// Update enemy spawn timer
		enemySpawnTimer += 16; // 16ms per frame at 60fps
		// Spawn enemy every 8 seconds
		if (enemySpawnTimer >= enemySpawnInterval) {
			spawnEnemy();
			enemySpawnTimer = 0;
		}
		// Update red slime spawn timer
		redSlimeSpawnTimer += 16; // 16ms per frame at 60fps
		// Spawn red slime every 7 seconds
		if (redSlimeSpawnTimer >= redSlimeSpawnInterval) {
			spawnRedSlime();
			redSlimeSpawnTimer = 0;
		}
		// Update auto attack timer
		autoAttackTimer += 16; // 16ms per frame at 60fps
		// Auto attack every 2 seconds
		if (autoAttackTimer >= autoAttackInterval) {
			guerrero.attack();
			autoAttackTimer = 0;
		}
		// Check slash-enemy collisions
		var slashes = [];
		for (var i = 0; i < game.children.length; i++) {
			if (game.children[i] instanceof Slash) {
				slashes.push(game.children[i]);
			}
		}
		for (var s = 0; s < slashes.length; s++) {
			var slash = slashes[s];
			for (var e = enemies.length - 1; e >= 0; e--) {
				var enemy = enemies[e];
				if (slash.intersects(enemy)) {
					// Create explosion effect at enemy position
					var explosion = new Explosion();
					explosion.x = enemy.x;
					explosion.y = enemy.y;
					game.addChild(explosion);
					// Destroy only the enemy, keep the slash
					enemy.destroy();
					enemies.splice(e, 1);
					// Don't break here so slash can hit multiple enemies
				}
			}
		}
		// Clean up enemies that are too far off screen
		for (var i = enemies.length - 1; i >= 0; i--) {
			var enemy = enemies[i];
			if (enemy.x < -200 || enemy.x > 2248 || enemy.y < -200 || enemy.y > 2932) {
				enemy.destroy();
				enemies.splice(i, 1);
			}
		}
	};
}
// Create the warrior player
var guerrero = new Guerrero();
guerrero.x = 2048 / 2; // Center horizontally
guerrero.y = 2732 / 2; // Center vertically
game.addChild(guerrero);
// Joystick sprite for target indication
var joystickSprite = null;
// Auto attack timer (every 2 seconds = 2000ms)
var autoAttackTimer = 0;
var autoAttackInterval = 2000;
// Enemy tracking array
var enemies = [];
// Enemy spawn timer (every 8 seconds = 8000ms)
var enemySpawnTimer = 0;
var enemySpawnInterval = 8000;
// Red slime spawn timer (every 7 seconds = 7000ms)
var redSlimeSpawnTimer = 0;
var redSlimeSpawnInterval = 7000;
// Function to spawn enemy at random edge
function spawnEnemy() {
	var enemy = new SlimeEnemy();
	// Choose random edge (0=top, 1=right, 2=bottom, 3=left)
	var edge = Math.floor(Math.random() * 4);
	switch (edge) {
		case 0:
			// Top edge
			enemy.x = Math.random() * 2048;
			enemy.y = -50;
			break;
		case 1:
			// Right edge
			enemy.x = 2048 + 50;
			enemy.y = Math.random() * 2732;
			break;
		case 2:
			// Bottom edge
			enemy.x = Math.random() * 2048;
			enemy.y = 2732 + 50;
			break;
		case 3:
			// Left edge
			enemy.x = -50;
			enemy.y = Math.random() * 2732;
			break;
	}
	enemies.push(enemy);
	game.addChild(enemy);
}
// Function to spawn red slime at random edge
function spawnRedSlime() {
	var redSlime = new RedSlimeEnemy();
	// Choose random edge (0=top, 1=right, 2=bottom, 3=left)
	var edge = Math.floor(Math.random() * 4);
	switch (edge) {
		case 0:
			// Top edge
			redSlime.x = Math.random() * 2048;
			redSlime.y = -50;
			break;
		case 1:
			// Right edge
			redSlime.x = 2048 + 50;
			redSlime.y = Math.random() * 2732;
			break;
		case 2:
			// Bottom edge
			redSlime.x = Math.random() * 2048;
			redSlime.y = 2732 + 50;
			break;
		case 3:
			// Left edge
			redSlime.x = -50;
			redSlime.y = Math.random() * 2732;
			break;
	}
	enemies.push(redSlime);
	game.addChild(redSlime);
}
// Handle touch/mouse down for movement only
game.down = function (x, y, obj) {
	// Remove existing joystick if it exists
	if (joystickSprite) {
		joystickSprite.destroy();
		joystickSprite = null;
	}
	// Create new joystick at clicked position
	joystickSprite = LK.getAsset('joystick', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: x,
		y: y
	});
	game.addChild(joystickSprite);
	// Make warrior move to clicked position
	guerrero.moveToTarget(x, y);
};

===================================================================
--- original.js
+++ change.js
@@ -175,9 +175,9 @@
 		anchorX: 0.5,
 		anchorY: 0.5
 	});
 	// Movement properties
-	self.speed = 100; // Slightly faster than blue slimes
+	self.speed = 160; // Double the speed of blue slimes (80 * 2)
 	// Update method called every frame
 	self.update = function () {
 		// Calculate direction towards player
 		var dx = guerrero.x - self.x;