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

/**** 
* Classes
****/ 
var Coin = Container.expand(function () {
	var self = Container.call(this);
	var coinGraphics = self.attachAsset('coin', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.collected = false;
	// Gentle floating animation
	self.floatOffset = 0;
	self.originalY = 0;
	self.update = function () {
		if (!self.collected) {
			self.floatOffset += 0.1;
			self.y = self.originalY + Math.sin(self.floatOffset) * 5;
		}
	};
	return self;
});
var Enemy = Container.expand(function () {
	var self = Container.call(this);
	var enemyGraphics = self.attachAsset('enemy', {
		anchorX: 0.5,
		anchorY: 1
	});
	self.speed = 1.5;
	self.direction = 1;
	self.verticalSpeed = 1;
	self.verticalDirection = 1;
	self.platformBounds = {
		left: 0,
		right: 500,
		top: 0,
		bottom: 0
	};
	self.assignedPlatform = 0;
	self.maxHealth = 50;
	self.health = 50;
	// Create health bar background
	self.healthBarBg = self.attachAsset('enemyHealthBarBg', {
		anchorX: 0.5,
		anchorY: 1
	});
	self.healthBarBg.x = 0;
	self.healthBarBg.y = -120;
	// Create health bar
	self.healthBar = self.attachAsset('enemyHealthBar', {
		anchorX: 0.5,
		anchorY: 1
	});
	self.healthBar.x = 0;
	self.healthBar.y = -120;
	self.updateHealthBar = function () {
		var healthPercent = self.health / self.maxHealth;
		self.healthBar.width = 60 * healthPercent;
		if (healthPercent > 0.6) {
			self.healthBar.tint = 0x00ff00;
		} else if (healthPercent > 0.3) {
			self.healthBar.tint = 0xffff00;
		} else {
			self.healthBar.tint = 0xff0000;
		}
	};
	self.update = function () {
		// Track last direction for flipping detection
		if (self.lastDirection === undefined) {
			self.lastDirection = self.direction;
		}
		// Horizontal movement
		self.x += self.speed * self.direction;
		// Bounce off platform edges horizontally
		if (self.x <= self.platformBounds.left || self.x >= self.platformBounds.right) {
			self.direction *= -1;
		}
		// Check if direction changed and flip enemy graphics accordingly
		if (self.direction !== self.lastDirection) {
			// Remove old graphics
			if (enemyGraphics) {
				self.removeChild(enemyGraphics);
			}
			// Create new graphics with proper flipping based on movement direction
			// If direction > 0 (moving right), don't flip (flipX: 0)
			// If direction < 0 (moving left), flip horizontally (flipX: 1)
			enemyGraphics = self.attachAsset('enemy', {
				anchorX: 0.5,
				anchorY: 1,
				flipX: self.direction < 0 ? 1 : 0
			});
			self.lastDirection = self.direction;
		}
		// Vertical movement within platform area
		self.y += self.verticalSpeed * self.verticalDirection;
		// Bounce off platform edges vertically
		if (self.y <= self.platformBounds.top || self.y >= self.platformBounds.bottom) {
			self.verticalDirection *= -1;
		}
	};
	return self;
});
var Ladder = Container.expand(function () {
	var self = Container.call(this);
	var ladderGraphics = self.attachAsset('ladder', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	return self;
});
var Platform = Container.expand(function () {
	var self = Container.call(this);
	var platformGraphics = self.attachAsset('platform', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	return self;
});
var Player = Container.expand(function () {
	var self = Container.call(this);
	var playerGraphics = self.attachAsset('player', {
		anchorX: 0.5,
		anchorY: 1
	});
	self.speed = 7;
	self.climbSpeed = 2;
	self.isClimbing = false;
	self.currentPlatform = null;
	self.targetY = 0;
	self.maxHealth = 100;
	self.health = 100;
	self.lastShot = 0;
	self.shootCooldown = 30; // 30 ticks = 0.5 seconds
	// Animation properties
	self.animationFrame = 0;
	self.animationSpeed = 8; // Change frame every 8 ticks
	self.isMoving = false;
	self.isShooting = false;
	self.facingLeft = false;
	self.lastX = self.x;
	// Animation frames for different states
	self.walkFrames = ['Ninja1', 'Ninja2', 'Ninja3', 'Ninja4'];
	self.climbFrames = ['Ninja01', 'Ninja02'];
	self.shootFrame = 'Ninjashooting';
	// Track animation state changes
	self.lastAsset = null;
	self.lastFlip = null;
	self.updateAnimation = function () {
		var currentAsset = '';
		var shouldFlip = self.facingLeft; // Always use facingLeft for flipping ninja frames
		if (self.isShooting) {
			currentAsset = self.shootFrame;
		} else if (self.isClimbing && self.isMoving) {
			// Only animate climbing when actually moving on ladder
			var climbFrameIndex = Math.floor(self.animationFrame / self.animationSpeed) % self.climbFrames.length;
			currentAsset = self.climbFrames[climbFrameIndex];
		} else if (self.isMoving && !self.isClimbing) {
			// Walking animation when moving horizontally
			var walkFrameIndex = Math.floor(self.animationFrame / self.animationSpeed) % self.walkFrames.length;
			currentAsset = self.walkFrames[walkFrameIndex];
		} else {
			// Default standing pose - show player asset when not moving
			currentAsset = 'player';
		}
		// Only update graphics if asset or flip state changed
		if (!self.lastAsset || self.lastAsset !== currentAsset || self.lastFlip !== shouldFlip) {
			// Remove old graphics if exists
			if (playerGraphics) {
				self.removeChild(playerGraphics);
			}
			// Create new graphics with proper flipping based on facing direction
			playerGraphics = self.attachAsset(currentAsset, {
				anchorX: 0.5,
				anchorY: 1,
				flipX: shouldFlip ? 1 : 0
			});
			// Store current state
			self.lastAsset = currentAsset;
			self.lastFlip = shouldFlip;
		}
	};
	self.update = function () {
		// Check if player is moving (horizontally or vertically)
		var horizontalMovement = Math.abs(self.x - self.lastX) > 0.1;
		var verticalMovement = Math.abs(self.y - (self.lastY || self.y)) > 0.1;
		if (horizontalMovement || verticalMovement && self.isClimbing) {
			self.isMoving = true;
			// Determine facing direction for any horizontal movement
			if (horizontalMovement) {
				if (self.x < self.lastX) {
					if (!self.facingLeft) {
						self.facingLeft = true;
						self.updateAnimation();
					}
				} else if (self.x > self.lastX) {
					if (self.facingLeft) {
						self.facingLeft = false;
						self.updateAnimation();
					}
				}
			}
		} else {
			self.isMoving = false;
		}
		// Update last positions
		self.lastX = self.x;
		self.lastY = self.y;
		// Check if player is shooting (cooldown active)
		self.isShooting = LK.ticks - self.lastShot < 15; // Show shooting animation for 15 ticks
		// Update animation frame counter only when moving or shooting
		if (self.isMoving || self.isShooting) {
			self.animationFrame++;
		}
		// Update animation
		self.updateAnimation();
		// Handle climbing movement
		if (self.isClimbing) {
			if (Math.abs(self.y - self.targetY) > 8) {
				// Increased from 8 to 20 for more climbing distance
				if (self.y > self.targetY) {
					self.y -= self.climbSpeed;
				} else {
					self.y += self.climbSpeed;
				}
				// Ensure player doesn't go beyond terrain boundaries while climbing
				self.y = Math.max(100, Math.min(2632, self.y));
			} else {
				// Snap exactly to target platform position
				self.y = self.targetY;
				self.isClimbing = false;
				// Clear any movement flags to prevent continued movement
				moveUp = false;
				moveDown = false;
			}
		} else {
			// Player can now climb ladders freely with hold-to-move controls
			// No automatic climbing logic needed here
		}
	};
	return self;
});
var Star = Container.expand(function () {
	var self = Container.call(this);
	var starGraphics = self.attachAsset('star', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 30;
	self.targetX = 0;
	self.targetY = 0;
	self.active = true;
	self.shootAt = function (targetX, targetY) {
		self.targetX = targetX;
		self.targetY = targetY;
		// Calculate distance for animation duration
		var distance = Math.sqrt(Math.pow(targetX - self.x, 2) + Math.pow(targetY - self.y, 2));
		var duration = distance * 3; // Adjust speed by changing multiplier
		// Use tween to animate star to target
		tween(self, {
			x: targetX,
			y: targetY,
			rotation: Math.PI * 4
		}, {
			duration: duration,
			easing: tween.linear,
			onFinish: function onFinish() {
				self.active = false;
			}
		});
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Game state variables
var currentLevel = 1;
var coinsCollected = 0;
var totalCoins = 5;
var platforms = [];
var ladders = [];
var coins = [];
var enemies = [];
var stars = [];
var player;
// Platform positions (central hub + 4 outer platforms in 2x2 grid)
var platformPositions = [{
	x: 1024,
	y: 1366
},
// Center platform
{
	x: 524,
	y: 922
},
// Top-left
{
	x: 1524,
	y: 922
},
// Top-right
{
	x: 524,
	y: 1800
},
// Bottom-left
{
	x: 1524,
	y: 1800
} // Bottom-right
];
// Add background
var background = game.attachAsset('background1', {
	anchorX: 0,
	anchorY: 0,
	x: 0,
	y: 0
});
// Create platforms
for (var i = 0; i < platformPositions.length; i++) {
	var platform = new Platform();
	platform.x = platformPositions[i].x;
	platform.y = platformPositions[i].y;
	platforms.push(platform);
	game.addChild(platform);
}
// Create ladders connecting platforms
var ladderConnections = [{
	from: 0,
	to: 1
},
// Center to top-left
{
	from: 0,
	to: 2
},
// Center to top-right
{
	from: 0,
	to: 3
},
// Center to bottom-left
{
	from: 0,
	to: 4
} // Center to bottom-right
];
for (var i = 0; i < ladderConnections.length; i++) {
	var connection = ladderConnections[i];
	var fromPlatform = platforms[connection.from];
	var toPlatform = platforms[connection.to];
	var ladder = new Ladder();
	ladder.x = (fromPlatform.x + toPlatform.x) / 2;
	ladder.y = (fromPlatform.y + toPlatform.y) / 2;
	ladders.push(ladder);
	game.addChild(ladder);
}
// Create coins on each platform
for (var i = 0; i < platforms.length; i++) {
	var coin = new Coin();
	coin.x = platforms[i].x;
	coin.y = platforms[i].y - 50;
	coin.originalY = coin.y;
	coins.push(coin);
	game.addChild(coin);
}
// Create player
player = new Player();
player.x = platforms[0].x; // Start on center platform
player.y = platforms[0].y;
player.currentPlatform = 0;
game.addChild(player);
// Create enemies based on level
function spawnEnemies() {
	// Clear existing enemies
	for (var i = 0; i < enemies.length; i++) {
		enemies[i].destroy();
	}
	enemies = [];
	// Spawn exactly 4 enemies, one on each outer platform (excluding center platform at index 0)
	for (var i = 1; i < platforms.length; i++) {
		var enemy = new Enemy();
		enemy.x = platforms[i].x;
		enemy.y = platforms[i].y;
		enemy.assignedPlatform = i;
		// Set platform boundaries to keep enemy confined to its platform
		enemy.platformBounds.left = platforms[i].x - 250;
		enemy.platformBounds.right = platforms[i].x + 250;
		enemy.platformBounds.top = platforms[i].y - 100;
		enemy.platformBounds.bottom = platforms[i].y + 50;
		enemies.push(enemy);
		game.addChild(enemy);
	}
}
// Initial enemy spawn
spawnEnemies();
// Player health bar
var playerHealthBarBg = LK.getAsset('healthBarBg', {
	anchorX: 0,
	anchorY: 0
});
playerHealthBarBg.x = 120;
playerHealthBarBg.y = 20;
LK.gui.topLeft.addChild(playerHealthBarBg);
var playerHealthBar = LK.getAsset('healthBar', {
	anchorX: 0,
	anchorY: 0
});
playerHealthBar.x = 120;
playerHealthBar.y = 20;
LK.gui.topLeft.addChild(playerHealthBar);
var healthText = new Text2('Health: 100/100', {
	size: 40,
	fill: 0xFFFFFF
});
healthText.anchor.set(0, 0);
healthText.x = 120;
healthText.y = 50;
LK.gui.topLeft.addChild(healthText);
// Score display
var scoreText = new Text2('Coins: 0/' + totalCoins, {
	size: 60,
	fill: 0xFFFFFF
});
scoreText.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreText);
// Level display
var levelText = new Text2('Level: ' + currentLevel, {
	size: 50,
	fill: 0xFFFFFF
});
levelText.anchor.set(1, 0);
LK.gui.topRight.addChild(levelText);
// Movement controls
var moveLeft = false;
var moveRight = false;
var moveUp = false;
var moveDown = false;
// Touch controls
game.down = function (x, y, obj) {
	// Use the x, y parameters directly as they are already in game coordinates
	var gamePos = {
		x: x,
		y: y
	};
	// Calculate distances for both horizontal and vertical movement
	var horizontalDistance = Math.abs(gamePos.x - player.x);
	var verticalDistance = Math.abs(gamePos.y - player.y);
	// Reset all movement flags first
	moveLeft = false;
	moveRight = false;
	moveUp = false;
	moveDown = false;
	// --- Flip Ninja animation images based on mouse hold left/right of player position ---
	if (gamePos.x < player.x) {
		// Clicked left of player - face left
		if (!player.facingLeft) {
			player.facingLeft = true;
			player.updateAnimation();
		}
	} else if (gamePos.x > player.x) {
		// Clicked right of player - face right
		if (player.facingLeft) {
			player.facingLeft = false;
			player.updateAnimation();
		}
	}
	// ---------------------------------------------------------------------------
	// Check for ladder climbing first - if near ladder, only allow vertical movement
	var nearLadder = false;
	for (var i = 0; i < ladders.length; i++) {
		var ladder = ladders[i];
		// Much tighter detection - player must be very close to ladder to climb
		if (Math.abs(gamePos.x - ladder.x) < 40 && Math.abs(gamePos.y - ladder.y) < 60) {
			nearLadder = true;
			// Only vertical movement when near ladder - based on clicked position relative to player
			if (gamePos.y < player.y) {
				moveUp = true;
			} else if (gamePos.y > player.y) {
				moveDown = true;
			}
			break;
		}
	}
	// If not near ladder, check for enemy shooting first, then movement
	if (!nearLadder) {
		// Check if tap is on an enemy
		var enemyClicked = false;
		for (var i = 0; i < enemies.length; i++) {
			var enemy = enemies[i];
			var enemyDistance = Math.sqrt(Math.pow(gamePos.x - enemy.x, 2) + Math.pow(gamePos.y - enemy.y, 2));
			if (enemyDistance < 80) {
				// Enemy click radius
				// Shoot at the clicked enemy if cooldown allows
				if (LK.ticks - player.lastShot > player.shootCooldown) {
					// Set facing direction based on enemy position
					var shouldFaceLeft = enemy.x < player.x;
					if (player.facingLeft !== shouldFaceLeft) {
						player.facingLeft = shouldFaceLeft;
						player.updateAnimation();
					}
					var star = new Star();
					star.x = player.x;
					star.y = player.y - 50; // Shoot from slightly above player
					star.shootAt(enemy.x, enemy.y);
					stars.push(star);
					game.addChild(star);
					player.lastShot = LK.ticks;
					LK.getSound('shoot').play();
				}
				enemyClicked = true;
				break;
			}
		}
		// If no enemy was clicked, handle movement
		if (!enemyClicked) {
			if (horizontalDistance > verticalDistance) {
				// Horizontal movement takes priority
				if (gamePos.x < player.x - 50) {
					moveLeft = true;
				} else if (gamePos.x > player.x + 50) {
					moveRight = true;
				}
			} else {
				// Vertical movement takes priority - based on clicked position relative to player
				if (gamePos.y < player.y) {
					moveUp = true;
				} else if (gamePos.y > player.y) {
					moveDown = true;
				}
			}
		}
	}
};
game.up = function (x, y, obj) {
	moveLeft = false;
	moveRight = false;
	moveUp = false;
	moveDown = false;
};
// Game update loop
game.update = function () {
	// Handle player movement
	if (!player.isClimbing) {
		if (moveLeft) {
			player.x -= player.speed;
			// Set facing direction for movement
			if (!player.facingLeft) {
				player.facingLeft = true;
				player.updateAnimation();
			}
			// Ensure player doesn't go beyond left boundary
			player.x = Math.max(20, player.x);
		}
		if (moveRight) {
			player.x += player.speed;
			// Set facing direction for movement
			if (player.facingLeft) {
				player.facingLeft = false;
				player.updateAnimation();
			}
			// Ensure player doesn't go beyond right boundary
			player.x = Math.min(2028, player.x);
		}
		// Update facing direction based on screen middle position during movement
		var screenMiddle = 1024; // Middle of 2048px wide screen
		if (moveLeft || moveRight || moveUp || moveDown) {
			if (player.x < screenMiddle) {
				if (!player.facingLeft) {
					player.facingLeft = true;
					player.updateAnimation();
				}
			} else if (player.x > screenMiddle) {
				if (player.facingLeft) {
					player.facingLeft = false;
					player.updateAnimation();
				}
			}
		}
		if (moveUp) {
			player.y -= player.speed;
			// Ensure player doesn't go beyond top boundary
			player.y = Math.max(100, player.y);
		}
		if (moveDown) {
			player.y += player.speed;
			// Ensure player doesn't go beyond bottom boundary
			player.y = Math.min(2632, player.y);
		}
		// Platform boundary checking - keep player on current platform unless using ladder
		if (player.currentPlatform !== null && !player.isClimbing) {
			var currentPlatform = platforms[player.currentPlatform];
			// Horizontal platform boundaries - reduced from 200 to 150 to allow ladder access
			var platformLeft = currentPlatform.x - 150;
			var platformRight = currentPlatform.x + 150;
			// Vertical platform boundaries - made much thinner
			var platformTop = currentPlatform.y - 30;
			var platformBottom = currentPlatform.y + 30;
			// Check if player is trying to move outside platform boundaries
			if (player.x < platformLeft || player.x > platformRight || player.y < platformTop || player.y > platformBottom) {
				// Only allow if player is near a ladder - increased detection range
				var nearLadder = false;
				for (var ladderIndex = 0; ladderIndex < ladders.length; ladderIndex++) {
					var ladder = ladders[ladderIndex];
					if (Math.abs(player.x - ladder.x) < 250 && Math.abs(player.y - ladder.y) < 300) {
						nearLadder = true;
						break;
					}
				}
				// If not near ladder, constrain to platform with thinner boundaries
				if (!nearLadder) {
					player.x = Math.max(platformLeft, Math.min(platformRight, player.x));
					player.y = Math.max(platformTop, Math.min(platformBottom, player.y));
				}
			}
		}
		// Allow player to move between platforms by updating current platform based on proximity
		if (player.currentPlatform !== null) {
			// Check if player is close to any platform to update current platform
			var closestPlatformIndex = 0;
			var closestDistance = Math.abs(player.y - platforms[0].y);
			for (var i = 1; i < platforms.length; i++) {
				var distance = Math.abs(player.y - platforms[i].y);
				if (distance < closestDistance && Math.abs(player.x - platforms[i].x) < 200) {
					closestDistance = distance;
					closestPlatformIndex = i;
				}
			}
			// Update current platform if player is close enough to a different platform - thinner detection
			if (Math.abs(player.x - platforms[closestPlatformIndex].x) < 200 && Math.abs(player.y - platforms[closestPlatformIndex].y) < 40) {
				player.currentPlatform = closestPlatformIndex;
			}
		}
		// Keep player within screen bounds
		player.x = Math.max(20, Math.min(2028, player.x));
		player.y = Math.max(100, Math.min(2632, player.y));
		// Additional check: if player is climbing and goes out of bounds, stop climbing
		if (player.isClimbing && (player.y <= 100 || player.y >= 2632)) {
			player.isClimbing = false;
			moveUp = false;
			moveDown = false;
			// Snap to nearest platform
			var nearestPlatform = platforms[0];
			var nearestDistance = Math.abs(player.y - nearestPlatform.y);
			for (var i = 1; i < platforms.length; i++) {
				var distance = Math.abs(player.y - platforms[i].y);
				if (distance < nearestDistance) {
					nearestDistance = distance;
					nearestPlatform = platforms[i];
					player.currentPlatform = i;
				}
			}
			player.y = nearestPlatform.y;
		}
		// Check for ladder climbing with hold-to-move
		if (moveUp || moveDown) {
			var _loop = function _loop() {
					ladder = ladders[i]; // Calculate ladder boundaries (top and bottom edges)
					ladderTop = ladder.y - 100; // Half of ladder height (200/2)
					ladderBottom = ladder.y + 100; // Half of ladder height (200/2)
					// Player must be very close to ladder horizontally AND within ladder vertical boundaries
					if (Math.abs(player.x - ladder.x) < 50 && player.y >= ladderTop - 20 && player.y <= ladderBottom + 20) {
						// Function to stop climbing completely
						var stopClimbing = function stopClimbing() {
							player.isClimbing = false;
							player.climbStartY = undefined;
							moveUp = false;
							moveDown = false;
						}; // Direct climbing movement based on held direction
						// Initialize climbing start position if not set
						if (player.climbStartY === undefined) {
							player.climbStartY = player.y;
						}
						// Set climbing state for animation
						player.isClimbing = true;
						// Snap to ladder horizontally
						player.x = ladder.x;
						if (moveUp) {
							// Check all stop conditions BEFORE moving
							climbedDistance = player.climbStartY - player.y;
							wouldExceed200px = climbedDistance >= 200;
							wouldExceedLadderTop = player.y - player.climbSpeed <= ladderTop;
							wouldExceedScreenTop = player.y - player.climbSpeed <= 100; // Stop if any boundary would be reached
							if (wouldExceed200px || wouldExceedLadderTop || wouldExceedScreenTop) {
								// Clamp to appropriate boundary
								if (wouldExceedScreenTop) {
									player.y = 100;
								} else if (wouldExceedLadderTop) {
									player.y = ladderTop;
								}
								stopClimbing();
							} else {
								// Safe to move up
								player.y -= player.climbSpeed;
							}
						} else if (moveDown) {
							// Check all stop conditions BEFORE moving
							climbedDistance = player.y - player.climbStartY;
							wouldExceed200px = climbedDistance >= 200;
							wouldExceedLadderBottom = player.y + player.climbSpeed >= ladderBottom;
							wouldExceedScreenBottom = player.y + player.climbSpeed >= 2632; // Stop if any boundary would be reached
							if (wouldExceed200px || wouldExceedLadderBottom || wouldExceedScreenBottom) {
								// Clamp to appropriate boundary
								if (wouldExceedScreenBottom) {
									player.y = 2632;
								} else if (wouldExceedLadderBottom) {
									player.y = ladderBottom;
								}
								stopClimbing();
							} else {
								// Safe to move down
								player.y += player.climbSpeed;
							}
						}
						// Update current platform based on proximity while climbing
						closestPlatformIndex = 0;
						closestDistance = Math.abs(player.y - platforms[0].y);
						for (j = 1; j < platforms.length; j++) {
							distance = Math.abs(player.y - platforms[j].y);
							if (distance < closestDistance && Math.abs(platforms[j].x - ladder.x) < 120) {
								closestDistance = distance;
								closestPlatformIndex = j;
							}
						}
						// Stop climbing and snap to platform if on platform level
						if (closestDistance < 40) {
							player.y = platforms[closestPlatformIndex].y;
							player.currentPlatform = closestPlatformIndex;
							stopClimbing();
						}
						return 1; // break
					} else if (player.isClimbing) {
						// Player has moved outside ladder boundaries while climbing, stop climbing
						player.isClimbing = false;
						player.climbStartY = undefined;
						moveUp = false;
						moveDown = false;
					}
				},
				ladder,
				ladderTop,
				ladderBottom,
				climbedDistance,
				wouldExceed200px,
				wouldExceedLadderTop,
				wouldExceedScreenTop,
				climbedDistance,
				wouldExceed200px,
				wouldExceedLadderBottom,
				wouldExceedScreenBottom,
				closestPlatformIndex,
				closestDistance,
				j,
				distance;
			for (var i = 0; i < ladders.length; i++) {
				if (_loop()) break;
			}
		} else {
			// Not climbing if not moving up or down
			player.isClimbing = false;
			player.climbStartY = undefined;
		}
	}
	// Check coin collection
	for (var i = 0; i < coins.length; i++) {
		var coin = coins[i];
		if (!coin.collected && player.intersects(coin)) {
			coin.collected = true;
			coin.alpha = 0;
			coinsCollected++;
			LK.setScore(coinsCollected);
			scoreText.setText('Coins: ' + coinsCollected + '/' + totalCoins);
			LK.getSound('coinCollect').play();
			// Check win condition
			if (coinsCollected >= totalCoins) {
				LK.showYouWin();
			}
		}
	}
	// Update player health bar
	function updatePlayerHealthBar() {
		var healthPercent = player.health / player.maxHealth;
		playerHealthBar.width = 200 * healthPercent;
		if (healthPercent > 0.6) {
			playerHealthBar.tint = 0x00ff00;
		} else if (healthPercent > 0.3) {
			playerHealthBar.tint = 0xffff00;
		} else {
			playerHealthBar.tint = 0xff0000;
		}
		healthText.setText('Health: ' + player.health + '/' + player.maxHealth);
	}
	// Update and check star collisions
	for (var i = stars.length - 1; i >= 0; i--) {
		var star = stars[i];
		// Check star-enemy collisions
		var hitEnemy = false;
		for (var j = 0; j < enemies.length; j++) {
			var enemy = enemies[j];
			if (star.active && star.intersects(enemy)) {
				// Damage enemy
				enemy.health -= 25;
				enemy.updateHealthBar();
				// Flash enemy red
				tween(enemy, {
					tint: 0xFF0000
				}, {
					duration: 200,
					onFinish: function onFinish() {
						tween(enemy, {
							tint: 0xFFFFFF
						}, {
							duration: 200
						});
					}
				});
				LK.getSound('enemyHit').play();
				hitEnemy = true;
				// Remove enemy if health <= 0
				if (enemy.health <= 0) {
					enemy.destroy();
					enemies.splice(j, 1);
					j--; // Adjust index after removal
				}
				break;
			}
		}
		// Remove star if hit enemy or inactive
		if (hitEnemy || !star.active) {
			tween.stop(star); // Stop any ongoing tween
			star.destroy();
			stars.splice(i, 1);
		}
	}
	// Check enemy collisions
	for (var i = 0; i < enemies.length; i++) {
		var enemy = enemies[i];
		if (player.intersects(enemy)) {
			// Initialize lastHit if not exists
			if (enemy.lastHit === undefined) {
				enemy.lastHit = 0;
			}
			// Only damage if enough time has passed (1 second = 60 ticks)
			if (LK.ticks - enemy.lastHit > 60) {
				player.health -= 10;
				enemy.lastHit = LK.ticks;
				updatePlayerHealthBar();
				LK.getSound('enemyHit').play();
				LK.effects.flashScreen(0xff0000, 500);
				if (player.health <= 0) {
					LK.showGameOver();
				}
			}
		}
		// Update enemy health bars
		enemy.updateHealthBar();
	}
	// Level progression (spawn more enemies every 30 seconds)
	if (LK.ticks % (60 * 30) === 0 && coinsCollected < totalCoins) {
		currentLevel++;
		levelText.setText('Level: ' + currentLevel);
		spawnEnemies();
	}
};

===================================================================
--- original.js
+++ change.js
@@ -462,16 +462,17 @@
 	moveLeft = false;
 	moveRight = false;
 	moveUp = false;
 	moveDown = false;
-	// --- Flip Ninja animation images based on mouse hold left/right of screen middle ---
-	var screenMiddle = 1024; // Middle of 2048px wide screen
-	if (gamePos.x < screenMiddle) {
+	// --- Flip Ninja animation images based on mouse hold left/right of player position ---
+	if (gamePos.x < player.x) {
+		// Clicked left of player - face left
 		if (!player.facingLeft) {
 			player.facingLeft = true;
 			player.updateAnimation();
 		}
-	} else if (gamePos.x > screenMiddle) {
+	} else if (gamePos.x > player.x) {
+		// Clicked right of player - face right
 		if (player.facingLeft) {
 			player.facingLeft = false;
 			player.updateAnimation();
 		}