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

/**** 
* Classes
****/ 
var Bullet = Container.expand(function () {
	var self = Container.call(this);
	var bulletGraphics = self.attachAsset('bullet', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 8;
	self.directionX = 0;
	self.directionY = 0;
	self.lastX = 0;
	self.lastY = 0;
	self.update = function () {
		self.lastX = self.x;
		self.lastY = self.y;
		self.x += self.directionX * self.speed;
		self.y += self.directionY * self.speed;
	};
	return self;
});
var Enemy = Container.expand(function () {
	var self = Container.call(this);
	var enemyGraphics = self.attachAsset('enemy', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.health = 1;
	self.moveTimer = 0;
	self.moveDirection = 0; // 0=up, 1=right, 2=down, 3=left
	self.speed = 1;
	self.lastX = 0;
	self.lastY = 0;
	self.update = function () {
		self.lastX = self.x;
		self.lastY = self.y;
		// Multi-directional movement pattern - can move in any direction
		self.moveTimer++;
		if (self.moveTimer > 120) {
			// Change direction every 2 seconds
			// Stop current tweens
			tween.stop(self, {
				x: true,
				y: true
			});
			// Calculate movement range in all directions
			var leftBound = self.x - 100;
			var rightBound = self.x + 100;
			var upBound = self.y - 100;
			var downBound = self.y + 100;
			// Ensure bounds are within maze
			var gridLeftX = Math.floor(leftBound / cellSize);
			var gridRightX = Math.floor(rightBound / cellSize);
			var gridUpY = Math.floor((upBound - 150) / cellSize);
			var gridDownY = Math.floor((downBound - 150) / cellSize);
			var gridCurrentY = Math.floor((self.y - 150) / cellSize);
			var gridCurrentX = Math.floor(self.x / cellSize);
			// Adjust bounds to avoid walls
			while (gridLeftX >= 0 && maze[gridCurrentY] && maze[gridCurrentY][gridLeftX] === 1) {
				leftBound += cellSize;
				gridLeftX++;
			}
			while (gridRightX < mazeWidth && maze[gridCurrentY] && maze[gridCurrentY][gridRightX] === 1) {
				rightBound -= cellSize;
				gridRightX--;
			}
			while (gridUpY >= 0 && maze[gridUpY] && maze[gridUpY][gridCurrentX] === 1) {
				upBound += cellSize;
				gridUpY++;
			}
			while (gridDownY < mazeHeight && maze[gridDownY] && maze[gridDownY][gridCurrentX] === 1) {
				downBound -= cellSize;
				gridDownY--;
			}
			// Choose direction: 0 = right, 1 = left, 2 = up, 3 = down
			var direction = Math.floor(Math.random() * 4);
			var targetX = self.x;
			var targetY = self.y;
			switch (direction) {
				case 0:
					// right
					targetX = rightBound;
					// Flip to face right
					enemyGraphics.scaleX = Math.abs(enemyGraphics.scaleX);
					break;
				case 1:
					// left
					targetX = leftBound;
					// Flip to face left
					enemyGraphics.scaleX = -Math.abs(enemyGraphics.scaleX);
					break;
				case 2:
					// up
					targetY = upBound;
					break;
				case 3:
					// down
					targetY = downBound;
					break;
			}
			// Ensure target is valid
			if (!checkWallCollision(targetX, targetY)) {
				// Move to target position over 1 second
				tween(self, {
					x: targetX,
					y: targetY
				}, {
					duration: 1000,
					easing: tween.easeInOut,
					onFinish: function onFinish() {
						// After reaching target, choose a new random direction
						var newDirection = Math.floor(Math.random() * 4);
						var newTargetX = self.x;
						var newTargetY = self.y;
						switch (newDirection) {
							case 0:
								// right
								newTargetX = rightBound;
								// Flip to face right
								enemyGraphics.scaleX = Math.abs(enemyGraphics.scaleX);
								break;
							case 1:
								// left
								newTargetX = leftBound;
								// Flip to face left
								enemyGraphics.scaleX = -Math.abs(enemyGraphics.scaleX);
								break;
							case 2:
								// up
								newTargetY = upBound;
								break;
							case 3:
								// down
								newTargetY = downBound;
								break;
						}
						if (!checkWallCollision(newTargetX, newTargetY)) {
							tween(self, {
								x: newTargetX,
								y: newTargetY
							}, {
								duration: 1000,
								easing: tween.easeInOut
							});
						}
					}
				});
			}
			self.moveTimer = 0;
		}
	};
	return self;
});
var Player = Container.expand(function () {
	var self = Container.call(this);
	var playerGraphics = self.attachAsset('player', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.health = 3;
	self.speed = 3;
	self.shootCooldown = 0;
	self.lastX = 0;
	self.lastY = 0;
	self.update = function () {
		self.lastX = self.x;
		self.lastY = self.y;
		if (self.shootCooldown > 0) {
			self.shootCooldown--;
		}
	};
	self.shoot = function (targetX, targetY) {
		if (self.shootCooldown > 0) return;
		var dx = targetX - self.x;
		var dy = targetY - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance > 0) {
			var bullet = new Bullet();
			bullet.x = self.x;
			bullet.y = self.y;
			bullet.directionX = dx / distance;
			bullet.directionY = dy / distance;
			bullet.lastX = bullet.x;
			bullet.lastY = bullet.y;
			bullets.push(bullet);
			game.addChild(bullet);
			self.shootCooldown = 15;
			LK.getSound('shoot').play();
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Game variables
var player;
var enemies = [];
var bullets = [];
var walls = [];
var currentLevel = 1;
var mazeWidth = 26;
var mazeHeight = 20;
var cellSize = 50;
var maze = [];
// UI elements
var levelText = new Text2('Level: 1', {
	size: 60,
	fill: 0xFFFFFF
});
levelText.anchor.set(0.5, 0);
LK.gui.top.addChild(levelText);
var healthText = new Text2('Health: 3', {
	size: 50,
	fill: 0xFF0000
});
healthText.anchor.set(0, 0);
healthText.x = 150;
healthText.y = 20;
LK.gui.topLeft.addChild(healthText);
var enemyCountText = new Text2('Enemies: 0', {
	size: 50,
	fill: 0xFFFF00
});
enemyCountText.anchor.set(1, 0);
LK.gui.topRight.addChild(enemyCountText);
// Maze generation
function generateMaze() {
	// Initialize maze with walls
	maze = [];
	for (var y = 0; y < mazeHeight; y++) {
		maze[y] = [];
		for (var x = 0; x < mazeWidth; x++) {
			maze[y][x] = 1; // 1 = wall, 0 = floor
		}
	}
	// Simple maze generation - create random paths
	function carvePath(x, y) {
		maze[y][x] = 0;
		var directions = [[0, -2], [2, 0], [0, 2], [-2, 0]];
		// Shuffle directions
		for (var i = directions.length - 1; i > 0; i--) {
			var j = Math.floor(Math.random() * (i + 1));
			var temp = directions[i];
			directions[i] = directions[j];
			directions[j] = temp;
		}
		for (var i = 0; i < directions.length; i++) {
			var nx = x + directions[i][0];
			var ny = y + directions[i][1];
			if (nx > 0 && nx < mazeWidth - 1 && ny > 0 && ny < mazeHeight - 1 && maze[ny][nx] === 1) {
				maze[y + directions[i][1] / 2][x + directions[i][0] / 2] = 0;
				carvePath(nx, ny);
			}
		}
	}
	// Start carving from top-left area
	carvePath(1, 1);
	// Add some random openings
	for (var i = 0; i < currentLevel * 5; i++) {
		var rx = Math.floor(Math.random() * (mazeWidth - 2)) + 1;
		var ry = Math.floor(Math.random() * (mazeHeight - 2)) + 1;
		maze[ry][rx] = 0;
	}
}
function createMazeWalls() {
	// Clear existing walls
	for (var i = walls.length - 1; i >= 0; i--) {
		walls[i].destroy();
	}
	walls = [];
	// Create wall objects
	for (var y = 0; y < mazeHeight; y++) {
		for (var x = 0; x < mazeWidth; x++) {
			if (maze[y][x] === 1) {
				var wall = LK.getAsset('wall', {
					x: x * cellSize + cellSize / 2,
					y: y * cellSize + cellSize / 2 + 150,
					anchorX: 0.5,
					anchorY: 0.5
				});
				walls.push(wall);
				game.addChild(wall);
			}
		}
	}
}
function findFloorPosition() {
	var attempts = 0;
	while (attempts < 100) {
		var x = Math.floor(Math.random() * mazeWidth);
		var y = Math.floor(Math.random() * mazeHeight);
		if (maze[y][x] === 0) {
			return {
				x: x * cellSize + cellSize / 2,
				y: y * cellSize + cellSize / 2 + 150
			};
		}
		attempts++;
	}
	// Fallback to a guaranteed floor position
	return {
		x: cellSize + cellSize / 2,
		y: cellSize + cellSize / 2 + 150
	};
}
function checkWallCollision(x, y) {
	var gridX = Math.floor(x / cellSize);
	var gridY = Math.floor((y - 150) / cellSize);
	if (gridX < 0 || gridX >= mazeWidth || gridY < 0 || gridY >= mazeHeight) {
		return true;
	}
	return maze[gridY][gridX] === 1;
}
function spawnEnemies() {
	// Clear existing enemies
	for (var i = enemies.length - 1; i >= 0; i--) {
		enemies[i].destroy();
	}
	enemies = [];
	var enemyCount = Math.min(currentLevel + 2, 15);
	for (var i = 0; i < enemyCount; i++) {
		var pos = findFloorPosition();
		var enemy = new Enemy();
		enemy.x = pos.x;
		enemy.y = pos.y;
		enemy.lastX = enemy.x;
		enemy.lastY = enemy.y;
		enemies.push(enemy);
		game.addChild(enemy);
	}
	updateEnemyCount();
}
function initLevel() {
	generateMaze();
	createMazeWalls();
	// Position player
	var playerPos = findFloorPosition();
	player.x = playerPos.x;
	player.y = playerPos.y;
	player.lastX = player.x;
	player.lastY = player.y;
	spawnEnemies();
	levelText.setText('Level: ' + currentLevel);
}
function updateEnemyCount() {
	enemyCountText.setText('Enemies: ' + enemies.length);
}
function updateHealthText() {
	healthText.setText('Health: ' + player.health);
}
function nextLevel() {
	currentLevel++;
	// Clear bullets
	for (var i = bullets.length - 1; i >= 0; i--) {
		bullets[i].destroy();
		bullets.splice(i, 1);
	}
	initLevel();
}
// Initialize player
player = new Player();
game.addChild(player);
// Initialize first level
initLevel();
updateHealthText();
// Swipe controls
var swipeStartX = 0;
var swipeStartY = 0;
var isSwipeActive = false;
var moveX = 0;
var moveY = 0;
var minSwipeDistance = 30;
// Double tap controls
var lastTapTime = 0;
var doubleTapDelay = 300; // milliseconds
var lastTapX = 0;
var lastTapY = 0;
var tapDistance = 50; // max distance between taps to consider as double tap
game.down = function (x, y, obj) {
	var currentTime = Date.now();
	var timeDiff = currentTime - lastTapTime;
	var distanceDiff = Math.sqrt(Math.pow(x - lastTapX, 2) + Math.pow(y - lastTapY, 2));
	// Check for double tap
	if (timeDiff < doubleTapDelay && distanceDiff < tapDistance) {
		// Double tap detected - shoot
		player.shoot(x, y);
		lastTapTime = 0; // Reset to prevent triple tap
	} else {
		// Single tap - prepare for swipe
		swipeStartX = x;
		swipeStartY = y;
		isSwipeActive = true;
		lastTapTime = currentTime;
		lastTapX = x;
		lastTapY = y;
	}
};
game.move = function (x, y, obj) {
	if (isSwipeActive) {
		var swipeDeltaX = x - swipeStartX;
		var swipeDeltaY = y - swipeStartY;
		var swipeDistance = Math.sqrt(swipeDeltaX * swipeDeltaX + swipeDeltaY * swipeDeltaY);
		if (swipeDistance > minSwipeDistance) {
			// Normalize swipe direction and apply player speed
			moveX = swipeDeltaX / swipeDistance * player.speed;
			moveY = swipeDeltaY / swipeDistance * player.speed;
		}
	}
};
game.up = function (x, y, obj) {
	isSwipeActive = false;
	moveX = 0;
	moveY = 0;
};
// Main game loop
game.update = function () {
	// Move player
	if (moveX !== 0 || moveY !== 0) {
		var newX = player.x + moveX;
		var newY = player.y + moveY;
		if (!checkWallCollision(newX, newY)) {
			player.x = newX;
			player.y = newY;
		}
	}
	// Update bullets
	for (var i = bullets.length - 1; i >= 0; i--) {
		var bullet = bullets[i];
		// Check wall collision
		if (checkWallCollision(bullet.x, bullet.y)) {
			bullet.destroy();
			bullets.splice(i, 1);
			continue;
		}
		// Check bounds
		if (bullet.x < 0 || bullet.x > mazeWidth * cellSize || bullet.y < 150 || bullet.y > mazeHeight * cellSize + 150) {
			bullet.destroy();
			bullets.splice(i, 1);
			continue;
		}
		// Check enemy collision
		var hitEnemy = false;
		for (var j = enemies.length - 1; j >= 0; j--) {
			if (bullet.intersects(enemies[j])) {
				LK.getSound('enemyHit').play();
				LK.effects.flashObject(enemies[j], 0xffffff, 200);
				enemies[j].destroy();
				enemies.splice(j, 1);
				bullet.destroy();
				bullets.splice(i, 1);
				hitEnemy = true;
				updateEnemyCount();
				break;
			}
		}
		if (hitEnemy) continue;
	}
	// Check player-enemy collision
	for (var i = enemies.length - 1; i >= 0; i--) {
		if (player.intersects(enemies[i])) {
			LK.getSound('playerHit').play();
			LK.effects.flashObject(player, 0xff0000, 500);
			player.health--;
			updateHealthText();
			// Move enemy away to prevent multiple hits
			enemies[i].x += (Math.random() - 0.5) * 60;
			enemies[i].y += (Math.random() - 0.5) * 60;
			if (player.health <= 0) {
				LK.showGameOver();
				return;
			}
		}
	}
	// Check win condition
	if (enemies.length === 0) {
		LK.setTimeout(function () {
			nextLevel();
		}, 500);
	}
};

===================================================================
--- original.js
+++ change.js
@@ -105,14 +105,14 @@
 					break;
 			}
 			// Ensure target is valid
 			if (!checkWallCollision(targetX, targetY)) {
-				// Move to target position over 2 seconds
+				// Move to target position over 1 second
 				tween(self, {
 					x: targetX,
 					y: targetY
 				}, {
-					duration: 2000,
+					duration: 1000,
 					easing: tween.easeInOut,
 					onFinish: function onFinish() {
 						// After reaching target, choose a new random direction
 						var newDirection = Math.floor(Math.random() * 4);
@@ -144,9 +144,9 @@
 							tween(self, {
 								x: newTargetX,
 								y: newTargetY
 							}, {
-								duration: 2000,
+								duration: 1000,
 								easing: tween.easeInOut
 							});
 						}
 					}