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

/**** 
* Classes
****/ 
var Bullet = Container.expand(function (isPlayer, gunType) {
	var self = Container.call(this);
	self.isPlayer = isPlayer || false;
	self.gunType = gunType || 'pistol';
	var bulletGraphics = self.attachAsset(self.isPlayer ? 'bullet' : 'enemyBullet', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Different bullet properties based on gun type
	if (self.isPlayer) {
		switch (self.gunType) {
			case 'pistol':
				self.speed = 12;
				self.damage = 1;
				break;
			case 'rifle':
				self.speed = 18;
				self.damage = 2;
				break;
			case 'shotgun':
				self.speed = 10;
				self.damage = 3;
				break;
		}
	} else {
		self.speed = 8;
		self.damage = 1;
	}
	self.direction = 0;
	self.active = true;
	self.update = function () {
		if (!self.active) return;
		self.x += Math.cos(self.direction) * self.speed;
		self.y += Math.sin(self.direction) * self.speed;
		// Check bounds
		if (self.x < -100 || self.x > 2148 || self.y < -100 || self.y > 2832) {
			self.active = false;
		}
	};
	return self;
});
var Enemy = Container.expand(function (roomLevel) {
	var self = Container.call(this);
	var enemyGraphics = self.attachAsset('enemy', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Scale difficulty with room level
	self.health = Math.min(1 + Math.floor(roomLevel / 2), 5);
	self.speed = Math.min(1 + roomLevel * 0.2, 3);
	self.shootTimer = 0;
	self.shootCooldown = Math.max(120 - roomLevel * 5, 60);
	self.active = true;
	self.lastPlayerX = 0;
	self.lastPlayerY = 0;
	self.update = function () {
		if (!self.active || !player) return;
		// Track last position for intersection detection
		self.lastPlayerX = player.x;
		self.lastPlayerY = player.y;
		// Move towards player
		var dx = player.x - self.x;
		var dy = player.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance > 40) {
			self.x += dx / distance * self.speed;
			self.y += dy / distance * self.speed;
		}
		// Shooting logic
		self.shootTimer++;
		if (self.shootTimer >= self.shootCooldown && distance < 500) {
			self.shoot();
			self.shootTimer = 0;
		}
	};
	self.shoot = function () {
		var bullet = new Bullet(false);
		var angle = Math.atan2(player.y - self.y, player.x - self.x);
		bullet.direction = angle;
		bullet.x = self.x;
		bullet.y = self.y;
		enemyBullets.push(bullet);
		game.addChild(bullet);
	};
	self.takeDamage = function (damage) {
		self.health -= damage;
		LK.effects.flashObject(self, 0xFFFFFF, 200);
		if (self.health <= 0) {
			self.active = false;
			LK.setScore(LK.getScore() + 10);
			LK.getSound('enemyHit').play();
			// 20% chance to drop weapon pickup
			if (Math.random() < 0.2) {
				spawnPickup(self.x, self.y);
			}
		}
	};
	return self;
});
var Pickup = Container.expand(function (type, x, y) {
	var self = Container.call(this);
	self.type = type; // 'gun' or 'melee'
	self.x = x;
	self.y = y;
	self.active = true;
	self.bobOffset = Math.random() * Math.PI * 2;
	self.startY = y;
	var pickupGraphics = self.attachAsset(type === 'gun' ? 'gunPickup' : 'meleePickup', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Determine what weapon this pickup contains
	if (type === 'gun') {
		var guns = ['pistol', 'rifle', 'shotgun'];
		self.weapon = guns[Math.floor(Math.random() * guns.length)];
	} else {
		var melees = ['sword', 'hammer'];
		self.weapon = melees[Math.floor(Math.random() * melees.length)];
	}
	self.update = function () {
		if (!self.active) return;
		// Bobbing animation
		self.y = self.startY + Math.sin(LK.ticks * 0.1 + self.bobOffset) * 5;
		// Check pickup collision with player
		if (self.intersects(player)) {
			self.active = false;
			if (self.type === 'gun') {
				player.switchGun(self.weapon);
			} else {
				player.switchMelee(self.weapon);
			}
			LK.getSound('pickup').play();
			LK.setScore(LK.getScore() + 5);
			self.destroy();
		}
	};
	return self;
});
var Player = Container.expand(function () {
	var self = Container.call(this);
	var playerGraphics = self.attachAsset('player', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Gun display
	var gunGraphics = self.attachAsset('pistol', {
		anchorX: 0,
		anchorY: 0.5,
		x: 20,
		y: 0
	});
	// Melee weapon display
	var meleeGraphics = self.attachAsset('sword', {
		anchorX: 0.5,
		anchorY: 1,
		x: -15,
		y: -10
	});
	self.health = 3;
	self.maxHealth = 3;
	self.speed = 5;
	self.shootCooldown = 0;
	self.parryCooldown = 0;
	self.parryWindow = 0;
	// Weapon systems
	self.currentGun = 'pistol';
	self.currentMelee = 'sword';
	// Gun properties
	self.gunStats = {
		pistol: {
			cooldown: 12,
			spread: 0
		},
		rifle: {
			cooldown: 8,
			spread: 0.1
		},
		shotgun: {
			cooldown: 30,
			spread: 0.3,
			pellets: 3
		}
	};
	// Melee properties
	self.meleeStats = {
		sword: {
			parryWindow: 8,
			cooldown: 25,
			effect: 'reflect',
			color: 0x1abc9c
		},
		hammer: {
			parryWindow: 15,
			cooldown: 45,
			effect: 'shockwave',
			color: 0xe74c3c
		}
	};
	self.shoot = function (targetX, targetY) {
		if (self.shootCooldown > 0) return;
		var gunStat = self.gunStats[self.currentGun];
		var baseAngle = Math.atan2(targetY - self.y, targetX - self.x);
		if (self.currentGun === 'shotgun') {
			// Shotgun fires multiple pellets
			for (var i = 0; i < gunStat.pellets; i++) {
				var bullet = new Bullet(true, self.currentGun);
				bullet.direction = baseAngle + (Math.random() - 0.5) * gunStat.spread;
				bullet.x = self.x;
				bullet.y = self.y;
				playerBullets.push(bullet);
				game.addChild(bullet);
			}
		} else {
			var bullet = new Bullet(true, self.currentGun);
			bullet.direction = baseAngle + (Math.random() - 0.5) * gunStat.spread;
			bullet.x = self.x;
			bullet.y = self.y;
			playerBullets.push(bullet);
			game.addChild(bullet);
		}
		LK.getSound('shoot').play();
		self.shootCooldown = gunStat.cooldown;
	};
	self.parry = function () {
		if (self.parryCooldown > 0) return;
		var meleeStat = self.meleeStats[self.currentMelee];
		self.parryWindow = meleeStat.parryWindow;
		self.parryCooldown = meleeStat.cooldown;
		// Visual feedback
		var parryFX = game.attachAsset('parryEffect', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: self.x,
			y: self.y,
			alpha: 0.8,
			tint: meleeStat.color
		});
		tween(parryFX, {
			alpha: 0,
			scaleX: 2,
			scaleY: 2
		}, {
			duration: meleeStat.parryWindow * 16.67,
			onFinish: function onFinish() {
				parryFX.destroy();
			}
		});
		LK.getSound('parry').play();
	};
	self.switchGun = function (newGun) {
		if (newGun && self.gunStats[newGun]) {
			self.currentGun = newGun;
			gunGraphics.destroy();
			gunGraphics = self.attachAsset(newGun, {
				anchorX: 0,
				anchorY: 0.5,
				x: 20,
				y: 0
			});
		}
	};
	self.switchMelee = function (newMelee) {
		if (newMelee && self.meleeStats[newMelee]) {
			self.currentMelee = newMelee;
			meleeGraphics.destroy();
			meleeGraphics = self.attachAsset(newMelee, {
				anchorX: 0.5,
				anchorY: 1,
				x: -15,
				y: -10
			});
		}
	};
	self.takeDamage = function () {
		self.health--;
		LK.effects.flashObject(self, 0xFF0000, 500);
		LK.getSound('playerHit').play();
		if (self.health <= 0) {
			LK.showGameOver();
		}
	};
	self.heal = function (amount) {
		self.health = Math.min(self.health + amount, self.maxHealth);
	};
	self.update = function () {
		if (self.shootCooldown > 0) self.shootCooldown--;
		if (self.parryCooldown > 0) self.parryCooldown--;
		if (self.parryWindow > 0) self.parryWindow--;
	};
	return self;
});
var Room = Container.expand(function (level) {
	var self = Container.call(this);
	self.level = level || 1;
	self.enemies = [];
	self.pickups = [];
	self.cleared = false;
	self.door = null;
	self.generateRoom = function () {
		// Create border walls
		var wallSize = 60;
		var roomWidth = 2048;
		var roomHeight = 2732;
		var wallsX = Math.floor(roomWidth / wallSize);
		var wallsY = Math.floor(roomHeight / wallSize);
		// Top and bottom walls
		for (var i = 0; i < wallsX; i++) {
			var topWall = self.attachAsset('wall', {
				x: i * wallSize,
				y: 0
			});
			var bottomWall = self.attachAsset('wall', {
				x: i * wallSize,
				y: roomHeight - wallSize
			});
		}
		// Left and right walls
		for (var j = 1; j < wallsY - 1; j++) {
			var leftWall = self.attachAsset('wall', {
				x: 0,
				y: j * wallSize
			});
			var rightWall = self.attachAsset('wall', {
				x: roomWidth - wallSize,
				y: j * wallSize
			});
		}
		// Generate enemies
		var enemyCount = Math.min(2 + self.level, 8);
		for (var k = 0; k < enemyCount; k++) {
			var enemy = new Enemy(self.level);
			enemy.x = 200 + Math.random() * (roomWidth - 400);
			enemy.y = 200 + Math.random() * (roomHeight - 400);
			self.enemies.push(enemy);
			self.addChild(enemy);
		}
		// Create exit door (initially locked)
		self.door = self.attachAsset('door', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: roomWidth / 2,
			y: wallSize / 2,
			tint: 0xc0392b
		});
	};
	self.checkCleared = function () {
		var activeEnemies = 0;
		for (var i = 0; i < self.enemies.length; i++) {
			if (self.enemies[i].active) {
				activeEnemies++;
			}
		}
		if (activeEnemies === 0 && !self.cleared) {
			self.cleared = true;
			// Unlock door
			if (self.door) {
				tween(self.door, {
					tint: 0x27ae60
				}, {
					duration: 500
				});
			}
		}
		return self.cleared;
	};
	return self;
});

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

/**** 
* Game Code
****/ 
var player;
var currentRoom;
var playerBullets = [];
var enemyBullets = [];
var pickups = [];
var roomLevel = 1;
var dragStartX = 0;
var dragStartY = 0;
var isDragging = false;
// UI Elements
var scoreText = new Text2('Score: 0', {
	size: 40,
	fill: '#ffffff'
});
scoreText.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreText);
var healthText = new Text2('Health: 3/3', {
	size: 35,
	fill: '#e74c3c'
});
healthText.anchor.set(1, 0);
LK.gui.topRight.addChild(healthText);
var roomText = new Text2('Room: 1', {
	size: 30,
	fill: '#3498db'
});
roomText.anchor.set(0, 0);
roomText.x = 120;
LK.gui.topLeft.addChild(roomText);
var gunText = new Text2('Gun: Pistol', {
	size: 28,
	fill: '#f39c12'
});
gunText.anchor.set(0, 1);
LK.gui.bottomLeft.addChild(gunText);
var meleeText = new Text2('Melee: Sword', {
	size: 28,
	fill: '#9b59b6'
});
meleeText.anchor.set(1, 1);
LK.gui.bottomRight.addChild(meleeText);
function updateUI() {
	scoreText.setText('Score: ' + LK.getScore());
	healthText.setText('Health: ' + player.health + '/' + player.maxHealth);
	roomText.setText('Room: ' + roomLevel);
	gunText.setText('Gun: ' + player.currentGun.charAt(0).toUpperCase() + player.currentGun.slice(1));
	meleeText.setText('Melee: ' + player.currentMelee.charAt(0).toUpperCase() + player.currentMelee.slice(1));
}
function spawnPickup(x, y) {
	var pickupType = Math.random() < 0.6 ? 'gun' : 'melee';
	var pickup = new Pickup(pickupType, x, y);
	pickups.push(pickup);
	game.addChild(pickup);
}
function generateNewRoom() {
	// Clear current room
	if (currentRoom) {
		currentRoom.destroy();
	}
	// Clear bullets and pickups
	for (var i = 0; i < playerBullets.length; i++) {
		playerBullets[i].destroy();
	}
	for (var j = 0; j < enemyBullets.length; j++) {
		enemyBullets[j].destroy();
	}
	for (var k = 0; k < pickups.length; k++) {
		pickups[k].destroy();
	}
	playerBullets = [];
	enemyBullets = [];
	pickups = [];
	// Create new room
	roomLevel++;
	currentRoom = new Room(roomLevel);
	currentRoom.generateRoom();
	game.addChild(currentRoom);
	// Reset player position
	player.x = 1024;
	player.y = 2400;
	game.addChild(player);
	updateUI();
}
// Initialize game
currentRoom = new Room(roomLevel);
currentRoom.generateRoom();
game.addChild(currentRoom);
player = new Player();
player.x = 1024;
player.y = 2400;
game.addChild(player);
updateUI();
// Touch controls
game.down = function (x, y, obj) {
	isDragging = true;
	dragStartX = x;
	dragStartY = y;
};
game.move = function (x, y, obj) {
	if (isDragging) {
		var dx = x - dragStartX;
		var dy = y - dragStartY;
		var distance = Math.sqrt(dx * dx + dy * dy);
		// Move player based on drag
		if (distance > 20) {
			var moveSpeed = player.speed;
			var newX = player.x + dx / distance * moveSpeed;
			var newY = player.y + dy / distance * moveSpeed;
			// Keep player in bounds
			player.x = Math.max(80, Math.min(1968, newX));
			player.y = Math.max(80, Math.min(2652, newY));
		}
	}
};
game.up = function (x, y, obj) {
	if (isDragging) {
		var dx = x - dragStartX;
		var dy = y - dragStartY;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance < 30) {
			// Check if this is a potential parry (tap in bottom area of screen)
			if (y > 2200) {
				// Tap in bottom area - parry
				player.parry();
			} else {
				// Tap elsewhere - shoot
				player.shoot(x, y);
			}
		}
	}
	isDragging = false;
};
// Double click variables for movement system
var lastClickTime = 0;
var doubleClickThreshold = 300; // milliseconds
var rightClickDetected = false;
// Function to handle double click movement
function handleDoubleClick(x, y) {
	// Move player to clicked position with smooth movement
	var targetX = Math.max(80, Math.min(1968, x));
	var targetY = Math.max(80, Math.min(2652, y));
	// Use tween for smooth movement
	tween(player, {
		x: targetX,
		y: targetY
	}, {
		duration: 500
	});
}
// Override the existing down handler to detect double clicks and right clicks
game.down = function (x, y, obj) {
	var currentTime = Date.now();
	// Check for right click (simulate with long press or specific gesture)
	// For now, we'll use a simple distance-based detection for right click
	rightClickDetected = false;
	if (currentTime - lastClickTime < doubleClickThreshold) {
		// Double click detected
		handleDoubleClick(x, y);
		lastClickTime = 0; // Reset to prevent triple click
	} else {
		// Single click - start drag
		isDragging = true;
		dragStartX = x;
		dragStartY = y;
		lastClickTime = currentTime;
	}
};
// Main game loop
game.update = function () {
	if (!player || !currentRoom) return;
	// Update player
	player.update();
	// Update player bullets
	for (var i = playerBullets.length - 1; i >= 0; i--) {
		var bullet = playerBullets[i];
		bullet.update();
		if (!bullet.active) {
			bullet.destroy();
			playerBullets.splice(i, 1);
			continue;
		}
		// Check collision with enemies
		for (var j = 0; j < currentRoom.enemies.length; j++) {
			var enemy = currentRoom.enemies[j];
			if (enemy.active && bullet.intersects(enemy)) {
				enemy.takeDamage(bullet.damage);
				bullet.active = false;
				bullet.destroy();
				playerBullets.splice(i, 1);
				break;
			}
		}
	}
	// Update enemy bullets
	for (var k = enemyBullets.length - 1; k >= 0; k--) {
		var enemyBullet = enemyBullets[k];
		enemyBullet.update();
		if (!enemyBullet.active) {
			enemyBullet.destroy();
			enemyBullets.splice(k, 1);
			continue;
		}
		// Check collision with player
		if (enemyBullet.intersects(player)) {
			if (player.parryWindow > 0) {
				// Successful parry
				var meleeStat = player.meleeStats[player.currentMelee];
				if (meleeStat.effect === 'reflect') {
					// Reflect bullet back
					var reflectedBullet = new Bullet(true, 'pistol');
					reflectedBullet.x = enemyBullet.x;
					reflectedBullet.y = enemyBullet.y;
					reflectedBullet.direction = enemyBullet.direction + Math.PI;
					reflectedBullet.speed = 15;
					playerBullets.push(reflectedBullet);
					game.addChild(reflectedBullet);
				} else if (meleeStat.effect === 'shockwave') {
					// Damage nearby enemies
					for (var l = 0; l < currentRoom.enemies.length; l++) {
						var nearbyEnemy = currentRoom.enemies[l];
						var dx = nearbyEnemy.x - player.x;
						var dy = nearbyEnemy.y - player.y;
						var distance = Math.sqrt(dx * dx + dy * dy);
						if (distance < 150 && nearbyEnemy.active) {
							nearbyEnemy.takeDamage(2);
						}
					}
				}
				LK.effects.flashObject(player, meleeStat.color, 300);
				LK.setScore(LK.getScore() + 3);
			} else {
				// Player takes damage
				player.takeDamage();
			}
			enemyBullet.active = false;
			enemyBullet.destroy();
			enemyBullets.splice(k, 1);
		}
	}
	// Update enemies
	for (var m = 0; m < currentRoom.enemies.length; m++) {
		var enemy = currentRoom.enemies[m];
		if (enemy.active) {
			enemy.update();
		}
	}
	// Update pickups
	for (var n = pickups.length - 1; n >= 0; n--) {
		var pickup = pickups[n];
		pickup.update();
		if (!pickup.active) {
			pickups.splice(n, 1);
		}
	}
	// Check room completion
	if (currentRoom.checkCleared()) {
		// Check if player reaches door
		if (currentRoom.door && player.intersects(currentRoom.door)) {
			generateNewRoom();
		}
	}
	// Update UI periodically
	if (LK.ticks % 30 === 0) {
		updateUI();
	}
};

===================================================================
--- original.js
+++ change.js
@@ -529,10 +529,9 @@
 	tween(player, {
 		x: targetX,
 		y: targetY
 	}, {
-		duration: 500,
-		easing: 'easeOutQuad'
+		duration: 500
 	});
 }
 // Override the existing down handler to detect double clicks and right clicks
 game.down = function (x, y, obj) {