/**** 
* 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;
	self.isPoisoned = false;
	self.poisonTimer = 0;
	self.poisonOverlay = null;
	self.poisonHeadOverlay = null;
	self.isMoving = true;
	self.stopTimer = 0;
	self.throwTimer = 0;
	self.throwCooldown = 0;
	// 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, projectileType) {
		if (self.hitRecently) return;
		var actualDamage;
		if (projectileType === 'poisonstone') {
			actualDamage = isHeadshot ? 10 : 3;
			// Apply poison effect
			if (!self.isPoisoned) {
				self.isPoisoned = true;
				self.poisonTimer = 0;
				// Create green poison overlay for body
				self.poisonOverlay = self.attachAsset(bodyType, {
					anchorX: 0.5,
					anchorY: 0.5,
					x: 0,
					y: 0
				});
				self.poisonOverlay.tint = 0x00FF00;
				self.poisonOverlay.alpha = 0.9;
				self.poisonOverlay.scale.set(1.2);
				// Animate poison overlay
				tween(self.poisonOverlay, {
					alpha: 0,
					scaleX: 1.4,
					scaleY: 1.4
				}, {
					duration: 1000,
					onFinish: function onFinish() {
						if (self.poisonOverlay && self.poisonOverlay.parent) {
							self.removeChild(self.poisonOverlay);
							self.poisonOverlay = null;
						}
					}
				});
				// Create green poison overlay for head
				self.poisonHeadOverlay = self.attachAsset(headType, {
					anchorX: 0.5,
					anchorY: 0.5,
					x: 0,
					y: -105
				});
				self.poisonHeadOverlay.tint = 0x00FF00;
				self.poisonHeadOverlay.alpha = 0.9;
				self.poisonHeadOverlay.scale.set(1.2);
				// Animate poison head overlay
				tween(self.poisonHeadOverlay, {
					alpha: 0,
					scaleX: 1.4,
					scaleY: 1.4
				}, {
					duration: 1000,
					onFinish: function onFinish() {
						if (self.poisonHeadOverlay && self.poisonHeadOverlay.parent) {
							self.removeChild(self.poisonHeadOverlay);
							self.poisonHeadOverlay = null;
						}
					}
				});
			}
		} else {
			actualDamage = isHeadshot ? 12 : 10;
		}
		self.health -= actualDamage;
		self.hitRecently = true;
		// Flash effect
		var flashColor = projectileType === 'poisonstone' ? 0x8B4513 : 0xFF0000;
		LK.effects.flashObject(self, flashColor, 200);
		LK.setTimeout(function () {
			self.hitRecently = false;
		}, 300);
		if (self.health <= 0) {
			// Don't add score here, wave completion will handle it
			return true; // Enemy died
		}
		return false;
	};
	self.update = function () {
		// Enemy movement - stop after entering screen by 180 + random(-50 to +50) pixels
		if (self.isMoving) {
			self.x -= self.speed;
			self.stopTimer++;
			// Check if we've moved far enough into the screen
			var targetStopDistance = 180 + (Math.random() - 0.5) * 100; // 180 + random(-50 to +50)
			if (self.x <= 2048 - targetStopDistance) {
				self.isMoving = false;
				self.stopTimer = 0;
			}
		}
		// Throwing logic when stationary
		if (!self.isMoving) {
			self.throwCooldown++;
			// Random chance to throw every 4-8 seconds (reduced frequency)
			if (self.throwCooldown >= 240 + Math.random() * 240) {
				self.throwCooldown = 0;
				self.throwProjectile();
			}
		}
		// Handle poison effect
		if (self.isPoisoned) {
			self.poisonTimer++;
			if (self.poisonTimer >= 180) {
				// 3 seconds at 60 FPS
				self.poisonTimer = 0;
				self.health -= 1;
				// Green flash for poison damage
				LK.effects.flashObject(self, 0x00FF00, 100);
				// Create periodic poison visual effect for body
				var poisonEffect = self.attachAsset(bodyType, {
					anchorX: 0.5,
					anchorY: 0.5,
					x: 0,
					y: 0
				});
				poisonEffect.tint = 0x00FF00;
				poisonEffect.alpha = 0.9;
				poisonEffect.scale.set(1.0);
				// Animate poison effect - grow and fade
				tween(poisonEffect, {
					alpha: 0,
					scaleX: 1.5,
					scaleY: 1.5
				}, {
					duration: 800,
					onFinish: function onFinish() {
						if (poisonEffect && poisonEffect.parent) {
							self.removeChild(poisonEffect);
						}
					}
				});
				// Create periodic poison visual effect for head
				var poisonHeadEffect = self.attachAsset(headType, {
					anchorX: 0.5,
					anchorY: 0.5,
					x: 0,
					y: -105
				});
				poisonHeadEffect.tint = 0x00FF00;
				poisonHeadEffect.alpha = 0.9;
				poisonHeadEffect.scale.set(1.0);
				// Animate poison head effect - grow and fade
				tween(poisonHeadEffect, {
					alpha: 0,
					scaleX: 1.5,
					scaleY: 1.5
				}, {
					duration: 800,
					onFinish: function onFinish() {
						if (poisonHeadEffect && poisonHeadEffect.parent) {
							self.removeChild(poisonHeadEffect);
						}
					}
				});
				if (self.health <= 0) {
					// Don't add score here, wave completion will handle it
					// Mark for removal in main game loop
					self.isDead = true;
					return;
				}
			}
		}
		// 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
		});
	};
	self.throwProjectile = function () {
		// Calculate direction to player with low accuracy
		var targetX = player.x + (Math.random() - 0.5) * 400; // Add inaccuracy
		var targetY = player.y + (Math.random() - 0.5) * 200 - 300; // Aim higher up
		var deltaX = targetX - self.x;
		var deltaY = targetY - self.y;
		var distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
		// Create enemy projectile
		var projectile = new Projectile('stone');
		projectile.x = self.x;
		projectile.y = self.y;
		projectile.isEnemyProjectile = true;
		// Calculate velocity with low accuracy and higher arc
		var speed = 8 + Math.random() * 4; // Slightly higher speed for arc
		var angle = Math.atan2(deltaY, deltaX);
		projectile.velocityX = Math.cos(angle) * speed;
		projectile.velocityY = Math.sin(angle) * speed;
		enemyProjectiles.push(projectile);
		game.addChild(projectile);
	};
	return self;
});
var InventorySlot = Container.expand(function (itemType, count) {
	var self = Container.call(this);
	self.itemType = itemType || 'empty';
	self.count = count || 0;
	self.maxCount = 99;
	self.selectionBorder = self.attachAsset('inventorySlot', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.selectionBorder.tint = 0xFFFF00;
	self.selectionBorder.scale.set(1.1);
	self.selectionBorder.visible = false;
	var slotBg = self.attachAsset('inventorySlot', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.itemSprite = null;
	if (self.itemType !== 'empty') {
		self.itemSprite = self.attachAsset(self.itemType, {
			anchorX: 0.5,
			anchorY: 0.5
		});
		var scale = Math.min(slotBg.width / self.itemSprite.width, slotBg.height / self.itemSprite.height) * 0.9;
		self.itemSprite.scale.set(scale);
	}
	self.countText = new Text2(self.count.toString(), {
		size: 25,
		fill: '#FFFFFF',
		stroke: '#000000',
		strokeThickness: 5
	});
	self.countText.anchor.set(0, 1);
	self.countText.x = -slotBg.width / 2 + 5;
	self.countText.y = slotBg.height / 2 - 5;
	self.addChild(self.countText);
	self.updateCount = function () {
		self.countText.setText(self.count.toString());
		if (self.count <= 1 || self.itemType === 'empty') {
			self.countText.visible = false;
		} else {
			self.countText.visible = true;
		}
		if (self.itemSprite) {
			if (self.count <= 0 || self.itemType === 'empty') {
				self.itemSprite.visible = false;
			} else {
				self.itemSprite.visible = true;
			}
		}
	};
	self.updateCount();
	self.canUse = function () {
		return self.count > 0 && self.itemType !== 'empty';
	};
	self.use = function () {
		if (self.canUse()) {
			self.count--;
			self.updateCount();
			return true;
		}
		return false;
	};
	self.select = function () {
		self.selectionBorder.visible = true;
	};
	self.deselect = function () {
		self.selectionBorder.visible = false;
	};
	self.down = function (x, y, obj) {
		if (self.canUse() && selectedSlot !== self) {
			if (selectedSlot) {
				selectedSlot.deselect();
			}
			selectedItem = self.itemType;
			selectedSlot = self;
			self.select();
			updateItemInfo(self.itemType);
		}
	};
	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 projectileAsset = 'projectile';
	if (self.type === 'stone') {
		projectileAsset = 'stone';
	} else if (self.type === 'poisonstone') {
		projectileAsset = 'poisonstone';
	}
	var graphics = self.attachAsset(projectileAsset, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	if (self.type === 'stone') {
		graphics.scale.set(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 enemyProjectiles = [];
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;
// Wave system variables
var currentWave = 1;
var maxWaves = 5;
var enemiesPerWave = 2;
var enemiesSpawnedInWave = 0;
var waveCompleted = false;
// 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);
}
// Add texture1 to the bottom-right corner, flush with the edges
var texture1 = game.addChild(LK.getAsset('texture1', {
	anchorX: 1,
	anchorY: 1,
	x: 2048,
	y: 2732
}));
// Item Info Display
var itemInfoDisplay = game.addChild(new Container());
itemInfoDisplay.x = 2048 - 422 / 2;
itemInfoDisplay.y = 2732 - 876 + 250;
var infoItemSprite = null;
var infoHeadDamageTextShadow = new Text2('', {
	size: 50,
	fill: '#000000',
	align: 'center'
});
infoHeadDamageTextShadow.anchor.set(0.5, 0);
infoHeadDamageTextShadow.y = 150 + 2;
infoHeadDamageTextShadow.x = 2;
itemInfoDisplay.addChild(infoHeadDamageTextShadow);
var infoHeadDamageText = new Text2('', {
	size: 50,
	fill: '#FFFFFF',
	align: 'center'
});
infoHeadDamageText.anchor.set(0.5, 0);
infoHeadDamageText.y = 150;
itemInfoDisplay.addChild(infoHeadDamageText);
var infoBodyDamageTextShadow = new Text2('', {
	size: 50,
	fill: '#000000',
	align: 'center'
});
infoBodyDamageTextShadow.anchor.set(0.5, 0);
infoBodyDamageTextShadow.y = 212 + 2;
infoBodyDamageTextShadow.x = 2;
itemInfoDisplay.addChild(infoBodyDamageTextShadow);
var infoBodyDamageText = new Text2('', {
	size: 50,
	fill: '#FFFFFF',
	align: 'center'
});
infoBodyDamageText.anchor.set(0.5, 0);
infoBodyDamageText.y = 212;
itemInfoDisplay.addChild(infoBodyDamageText);
var infoEffectTextShadow = new Text2('', {
	size: 50,
	fill: '#000000',
	align: 'center'
});
infoEffectTextShadow.anchor.set(0.5, 0);
infoEffectTextShadow.y = 275 + 2;
infoEffectTextShadow.x = 2;
itemInfoDisplay.addChild(infoEffectTextShadow);
var infoEffectText = new Text2('', {
	size: 50,
	fill: '#FFFFFF',
	align: 'center'
});
infoEffectText.anchor.set(0.5, 0);
infoEffectText.y = 275;
itemInfoDisplay.addChild(infoEffectText);
function updateItemInfo(itemType) {
	if (infoItemSprite) {
		infoItemSprite.destroy();
		infoItemSprite = null;
	}
	if (!itemType || itemType === 'empty') {
		infoHeadDamageText.setText('');
		infoBodyDamageText.setText('');
		infoEffectText.setText('');
		infoHeadDamageTextShadow.setText('');
		infoBodyDamageTextShadow.setText('');
		infoEffectTextShadow.setText('');
		return;
	}
	infoItemSprite = itemInfoDisplay.attachAsset(itemType, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	infoItemSprite.scale.set(2.5);
	itemInfoDisplay.setChildIndex(infoItemSprite, 0);
	if (itemType === 'poisonstone') {
		infoHeadDamageText.setText('Head: 10');
		infoHeadDamageTextShadow.setText('Head: 10');
		infoBodyDamageText.setText('Body: 3');
		infoBodyDamageTextShadow.setText('Body: 3');
		infoEffectText.setText('poison effect');
		infoEffectTextShadow.setText('poison effect');
	} else {
		infoHeadDamageText.setText('Head: 12');
		infoHeadDamageTextShadow.setText('Head: 12');
		infoBodyDamageText.setText('Body: 10');
		infoBodyDamageTextShadow.setText('Body: 10');
		infoEffectText.setText('no extra effect');
		infoEffectTextShadow.setText('no extra effect');
	}
}
// Add inventory texture to the bottom-left corner, flush with the edges
var inventoryTexture = game.addChild(LK.getAsset('inventory', {
	anchorX: 0,
	anchorY: 1,
	x: 0,
	y: 2732
}));
// Create a 9x5 inventory grid on top of the inventory texture
// Inventory Grid Configuration
var inventoryConfig = {
	textureWidth: 1624,
	textureHeight: 876,
	gridColumns: 9,
	gridRows: 5,
	marginTop: 10,
	marginBottom: 18,
	marginLeft: 60,
	marginRight: 60,
	horizontalSpacing: 10,
	verticalSpacing: 8
};
// Calculate usable area within the inventory texture
var usableWidth = inventoryConfig.textureWidth - inventoryConfig.marginLeft - inventoryConfig.marginRight;
var usableHeight = inventoryConfig.textureHeight - inventoryConfig.marginTop - inventoryConfig.marginBottom;
// Calculate total spacing between slots
var totalHorizontalSpacing = (inventoryConfig.gridColumns - 1) * inventoryConfig.horizontalSpacing;
var totalVerticalSpacing = (inventoryConfig.gridRows - 1) * inventoryConfig.verticalSpacing;
// Calculate the dimensions for a single slot
var slotWidth = (usableWidth - totalHorizontalSpacing) / inventoryConfig.gridColumns;
var slotHeight = (usableHeight - totalVerticalSpacing) / inventoryConfig.gridRows;
// Position of the inventory texture is at the bottom-left of the screen
var inventoryTextureX = 0;
var inventoryTextureY = 2732;
// Calculate the top-left coordinate of the grid area inside the texture
var gridStartX = inventoryTextureX + inventoryConfig.marginLeft;
var gridStartY = inventoryTextureY - inventoryConfig.textureHeight + inventoryConfig.marginTop;
// Define the initial inventory items
var slotIndex = 0;
// Create and position the inventory slots in a grid
for (var row = 0; row < inventoryConfig.gridRows; row++) {
	for (var col = 0; col < inventoryConfig.gridColumns; col++) {
		var itemType = 'empty';
		var itemCount = 0;
		// The first slot gets 20 stones, second gets 10 poison stones
		if (slotIndex === 0) {
			itemType = 'stone';
			itemCount = 20;
		} else if (slotIndex === 1) {
			itemType = 'poisonstone';
			itemCount = 10;
		}
		var slot = new InventorySlot(itemType, itemCount);
		// Calculate the center position for the current slot
		var slotX = gridStartX + col * (slotWidth + inventoryConfig.horizontalSpacing) + slotWidth / 2;
		var slotY = gridStartY + row * (slotHeight + inventoryConfig.verticalSpacing) + slotHeight / 2;
		slot.x = slotX;
		slot.y = slotY;
		// Scale the slot container to match the calculated dimensions (base asset is 100x100)
		slot.scale.set(slotWidth / 100, slotHeight / 100);
		inventorySlots.push(slot);
		game.addChild(slot);
		slotIndex++;
	}
}
// 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 = 440;
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 available item and display its info
if (inventorySlots.length > 0) {
	var firstSlot = inventorySlots[0];
	if (firstSlot && firstSlot.canUse()) {
		selectedItem = firstSlot.itemType;
		selectedSlot = firstSlot;
		firstSlot.select();
		updateItemInfo(firstSlot.itemType);
	}
}
// Wave display
var scoreTextShadow = new Text2('Wave: 1', {
	size: 60,
	fill: '#000000'
});
scoreTextShadow.anchor.set(0.5, 0);
scoreTextShadow.x = 3;
scoreTextShadow.y = 3;
LK.gui.top.addChild(scoreTextShadow);
var scoreText = new Text2('Wave: 1', {
	size: 60,
	fill: '#00FF00'
});
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();
	// If the slot is now empty, deselect it.
	if (!selectedSlot.canUse()) {
		selectedSlot.deselect();
		selectedSlot = null;
		selectedItem = null;
		updateItemInfo(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 wave display
	scoreText.setText('Wave: ' + currentWave);
	scoreTextShadow.setText('Wave: ' + currentWave);
	// Wave-based enemy spawning
	if (currentWave <= maxWaves && enemiesSpawnedInWave < enemiesPerWave) {
		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);
			enemiesSpawnedInWave++;
		}
	}
	// 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);
		} else if (enemy.isDead) {
			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, projectile.type);
				LK.getSound('hit').play();
				if (died) {
					enemy.destroy();
					enemies.splice(j, 1);
				}
				if (projectile.type !== 'piercing') {
					projectile.destroy();
					projectiles.splice(i, 1);
					break;
				}
			}
		}
		// Update enemy projectiles
		for (var i = enemyProjectiles.length - 1; i >= 0; i--) {
			var enemyProjectile = enemyProjectiles[i];
			if (enemyProjectile.x > 2200 || enemyProjectile.y > 2800 || enemyProjectile.x < -100) {
				enemyProjectile.destroy();
				enemyProjectiles.splice(i, 1);
				continue;
			}
			// Check collision with player
			var distanceToPlayer = Math.sqrt((enemyProjectile.x - player.x) * (enemyProjectile.x - player.x) + (enemyProjectile.y - player.y) * (enemyProjectile.y - player.y));
			if (distanceToPlayer < 80) {
				// Player hit - flash red and show game over
				LK.effects.flashScreen(0xff0000, 1000);
				LK.showGameOver();
			}
		}
		// Check wave completion
		if (enemies.length === 0 && enemiesSpawnedInWave >= enemiesPerWave && currentWave <= maxWaves) {
			// Wave completed
			LK.setScore(currentWave); // Set score to current wave number
			currentWave++;
			enemiesSpawnedInWave = 0;
			enemySpawnTimer = 0;
			if (currentWave > maxWaves) {
				// All waves completed - show victory
				LK.showYouWin();
			}
		}
	}
	// 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();
			}
		}
	}
};

===================================================================
--- original.js
+++ change.js
@@ -157,22 +157,23 @@
 		}
 		return false;
 	};
 	self.update = function () {
-		// Enemy movement - stop after entering screen
+		// Enemy movement - stop after entering screen by 180 + random(-50 to +50) pixels
 		if (self.isMoving) {
 			self.x -= self.speed;
 			self.stopTimer++;
-			// Stop after 2 seconds (120 frames at 60 FPS)
-			if (self.stopTimer >= 120) {
+			// Check if we've moved far enough into the screen
+			var targetStopDistance = 180 + (Math.random() - 0.5) * 100; // 180 + random(-50 to +50)
+			if (self.x <= 2048 - targetStopDistance) {
 				self.isMoving = false;
 				self.stopTimer = 0;
 			}
 		}
 		// Throwing logic when stationary
 		if (!self.isMoving) {
 			self.throwCooldown++;
-			// Random chance to throw every 4-8 seconds (slower)
+			// Random chance to throw every 4-8 seconds (reduced frequency)
 			if (self.throwCooldown >= 240 + Math.random() * 240) {
 				self.throwCooldown = 0;
 				self.throwProjectile();
 			}
@@ -258,22 +259,22 @@
 	};
 	self.throwProjectile = function () {
 		// Calculate direction to player with low accuracy
 		var targetX = player.x + (Math.random() - 0.5) * 400; // Add inaccuracy
-		var targetY = player.y + (Math.random() - 0.5) * 200; // Add inaccuracy
+		var targetY = player.y + (Math.random() - 0.5) * 200 - 300; // Aim higher up
 		var deltaX = targetX - self.x;
 		var deltaY = targetY - self.y;
 		var distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
 		// Create enemy projectile
 		var projectile = new Projectile('stone');
 		projectile.x = self.x;
 		projectile.y = self.y;
 		projectile.isEnemyProjectile = true;
-		// Calculate velocity with higher arc and lower speed
-		var speed = 4 + Math.random() * 2; // Slower speed
+		// Calculate velocity with low accuracy and higher arc
+		var speed = 8 + Math.random() * 4; // Slightly higher speed for arc
 		var angle = Math.atan2(deltaY, deltaX);
 		projectile.velocityX = Math.cos(angle) * speed;
-		projectile.velocityY = Math.sin(angle) * speed - 8; // Throw higher with negative Y velocity
+		projectile.velocityY = Math.sin(angle) * speed;
 		enemyProjectiles.push(projectile);
 		game.addChild(projectile);
 	};
 	return self;
@@ -756,11 +757,9 @@
 		if (enemySpawnTimer > 180) {
 			enemySpawnTimer = 0;
 			var enemy = new Enemy();
 			enemy.x = 2200;
-			// Position enemies symmetrically relative to player
-			var offsetFromPlayer = (enemiesSpawnedInWave - (enemiesPerWave - 1) / 2) * 300;
-			enemy.y = player.y + offsetFromPlayer;
+			enemy.y = player.y - 40 + Math.random() * 80;
 			enemies.push(enemy);
 			game.addChild(enemy);
 			enemiesSpawnedInWave++;
 		}