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

/**** 
* Classes
****/ 
var Platform = Container.expand(function () {
	var self = Container.call(this);
	var graphics = self.attachAsset('platform', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	return self;
});
var Projectile = Container.expand(function () {
	var self = Container.call(this);
	var graphics = self.attachAsset('projectile', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.velocityX = 0;
	self.velocityY = 0;
	self.lifetime = 180; // 3 seconds at 60fps
	self.update = function () {
		self.x += self.velocityX;
		self.y += self.velocityY;
		self.lifetime--;
		// Remove if lifetime expired or off screen
		if (self.lifetime <= 0 || self.x < -50 || self.x > 2098 || self.y > 2800) {
			self.destroy();
		}
	};
	return self;
});
var Stickman = Container.expand(function () {
	var self = Container.call(this);
	// Create detailed warrior with body parts for enhanced animations
	var warriorBody = self.attachAsset('warrior', {
		anchorX: 0.5,
		anchorY: 1.0,
		x: 0,
		y: 0
	});
	// Create separate limbs for detailed animation
	var leftArm = self.attachAsset('enemy_limb', {
		anchorX: 0.5,
		anchorY: 0,
		x: -15,
		y: -80,
		tint: 0x8B4513
	});
	var rightArm = self.attachAsset('enemy_limb', {
		anchorX: 0.5,
		anchorY: 0,
		x: 15,
		y: -80,
		tint: 0x8B4513
	});
	var leftLeg = self.attachAsset('enemy_limb', {
		anchorX: 0.5,
		anchorY: 0,
		x: -8,
		y: -40,
		height: 40,
		tint: 0x654321
	});
	var rightLeg = self.attachAsset('enemy_limb', {
		anchorX: 0.5,
		anchorY: 0,
		x: 8,
		y: -40,
		height: 40,
		tint: 0x654321
	});
	// No sword - warrior fights with hands
	// Movement properties
	self.velocityX = 0;
	self.velocityY = 0;
	self.onGround = false;
	self.speed = 8;
	self.jumpPower = -18;
	self.health = 100;
	self.maxHealth = 100;
	self.facingRight = true;
	// Combat properties
	self.canAttack = true;
	self.attackCooldown = 0;
	self.lastAttackTime = 0;
	// Animation properties
	self.animationTick = 0;
	self.isAttacking = false;
	self.isJumping = false;
	self.wasOnGround = true;
	self.update = function () {
		// Apply gravity
		if (!self.onGround) {
			self.velocityY += 0.8;
		}
		// Apply velocity
		self.x += self.velocityX;
		self.y += self.velocityY;
		// Apply friction
		self.velocityX *= 0.85;
		// Reset ground detection
		self.onGround = false;
		// Reset double jump when touching ground later in collision detection
		// Update attack cooldown
		if (self.attackCooldown > 0) {
			self.attackCooldown--;
		}
		// Animation updates
		self.animationTick++;
		// Check if jumping state changed
		if (!self.onGround && self.wasOnGround) {
			self.isJumping = true;
		}
		if (self.onGround && !self.wasOnGround) {
			self.isJumping = false;
		}
		self.wasOnGround = self.onGround;
		// Handle enhanced animations with detailed warrior body parts and sword movements
		if (self.isAttacking) {
			// Attack animation is handled in attack method - keep sword position
		} else if (self.isJumping || !self.onGround) {
			// Enhanced jump animation with dynamic rotation and detailed limb movement
			var jumpPhase = self.velocityY < 0 ? 0 : 1; // 0 for going up, 1 for falling
			if (jumpPhase === 0) {
				// Going up - dynamic backward tilt based on jump velocity
				var tiltAmount = Math.min(Math.abs(self.velocityY) * 0.02, 0.4);
				warriorBody.rotation = -tiltAmount;
				// Slight scale animation for jump power
				warriorBody.scaleY = 1.1 - Math.abs(self.velocityY) * 0.005;
				// Detailed leg positioning during upward jump - legs bent for power
				leftLeg.rotation = -0.3;
				rightLeg.rotation = -0.2;
				leftLeg.y = -35;
				rightLeg.y = -35;
				// Arm positioning during jump - spread for balance
				leftArm.rotation = -0.4;
				rightArm.rotation = 0.2;
				// No sword - hands positioned during jump for balance
			} else {
				// Falling down - forward tilt increases with fall speed
				var fallTilt = Math.min(self.velocityY * 0.01, 0.3);
				warriorBody.rotation = fallTilt;
				// Slight stretch when falling fast
				warriorBody.scaleY = 1 + self.velocityY * 0.002;
				// Detailed leg positioning during fall - preparing for landing
				leftLeg.rotation = 0.2;
				rightLeg.rotation = 0.1;
				leftLeg.y = -38;
				rightLeg.y = -38;
				// Arm positioning for landing preparation
				leftArm.rotation = -0.2;
				rightArm.rotation = 0.3;
				// No sword - hands positioned for landing
				// Add landing preparation animation when close to ground
				if (self.velocityY > 8) {
					tween(warriorBody, {
						scaleY: 0.95
					}, {
						duration: 100,
						easing: tween.easeOut
					});
					tween(leftLeg, {
						rotation: 0.4,
						y: -42
					}, {
						duration: 100,
						easing: tween.easeOut
					});
					tween(rightLeg, {
						rotation: 0.3,
						y: -42
					}, {
						duration: 100,
						easing: tween.easeOut
					});
				}
			}
		} else if (Math.abs(self.velocityX) > 0.1) {
			// Enhanced walking/running animation with detailed warrior body parts and realistic limb movement
			var walkSpeed = Math.abs(self.velocityX) > 4 ? 0.4 : 0.3; // Faster animation for running
			var walkCycle = Math.sin(self.animationTick * walkSpeed);
			var walkCycleDouble = Math.sin(self.animationTick * walkSpeed * 2);
			var walkCycleOffset = Math.sin(self.animationTick * walkSpeed + Math.PI);
			// Dynamic rotation based on movement speed
			var speedFactor = Math.min(Math.abs(self.velocityX) / self.speed, 1);
			var isRunning = Math.abs(self.velocityX) > 4;
			warriorBody.rotation = walkCycle * (isRunning ? 0.12 : 0.08) * speedFactor;
			// Vertical bob with speed-based intensity - more pronounced when running
			warriorBody.y = Math.abs(walkCycleDouble) * (isRunning ? 6 : 4) * speedFactor;
			// Subtle scale animation for dynamic feel
			warriorBody.scaleY = 1 - Math.abs(walkCycleDouble) * (isRunning ? 0.03 : 0.02) * speedFactor;
			// Slight horizontal sway
			warriorBody.x = walkCycle * (isRunning ? 3 : 2) * speedFactor;
			// Detailed leg animation - alternating steps with realistic movement
			var leftLegCycle = Math.sin(self.animationTick * walkSpeed);
			var rightLegCycle = Math.sin(self.animationTick * walkSpeed + Math.PI);
			// Left leg movement
			leftLeg.rotation = leftLegCycle * (isRunning ? 0.6 : 0.4);
			leftLeg.y = -40 + Math.abs(leftLegCycle) * (isRunning ? 8 : 5);
			// Right leg movement (opposite phase)
			rightLeg.rotation = rightLegCycle * (isRunning ? 0.6 : 0.4);
			rightLeg.y = -40 + Math.abs(rightLegCycle) * (isRunning ? 8 : 5);
			// Detailed arm animation - natural swinging motion opposite to legs
			leftArm.rotation = rightLegCycle * (isRunning ? 0.5 : 0.3);
			leftArm.y = -80 + Math.abs(rightLegCycle) * (isRunning ? 4 : 2);
			rightArm.rotation = leftLegCycle * (isRunning ? 0.3 : 0.2); // Right arm holds sword, less movement
			rightArm.y = -80 + Math.abs(leftLegCycle) * (isRunning ? 3 : 1);
			// Both arms swing naturally during movement
			// Add realistic stride animation using tween for smoother transitions
			if (Math.floor(self.animationTick * walkSpeed) !== Math.floor((self.animationTick - 1) * walkSpeed)) {
				// Trigger on each step cycle for enhanced leg animation
				var stepDirection = leftLegCycle > 0 ? 1 : -1;
				tween(warriorBody, {
					scaleY: isRunning ? 0.96 : 0.98
				}, {
					duration: isRunning ? 80 : 100,
					easing: tween.easeOut,
					onFinish: function onFinish() {
						tween(warriorBody, {
							scaleY: isRunning ? 1.04 : 1.02
						}, {
							duration: isRunning ? 80 : 100,
							easing: tween.easeIn
						});
					}
				});
			}
			// Add slight lean forward when walking/running
			var leanDirection = self.facingRight ? 1 : -1;
			warriorBody.rotation += leanDirection * speedFactor * (isRunning ? 0.08 : 0.05);
		} else {
			// Enhanced idle animation with breathing effect and detailed body part movement
			var breathCycle = Math.sin(self.animationTick * 0.05);
			var idleCycle = Math.sin(self.animationTick * 0.03);
			var weightShiftCycle = Math.sin(self.animationTick * 0.02);
			warriorBody.rotation = breathCycle * 0.01;
			warriorBody.y = breathCycle * 1;
			warriorBody.scaleY = 1 + breathCycle * 0.01;
			warriorBody.x = 0;
			// Detailed idle leg positioning with subtle weight shifting
			leftLeg.rotation = weightShiftCycle * 0.08;
			rightLeg.rotation = -weightShiftCycle * 0.06;
			leftLeg.y = -40 + Math.abs(idleCycle) * 1;
			rightLeg.y = -40 + Math.abs(weightShiftCycle) * 1;
			// Detailed idle arm positioning with breathing
			leftArm.rotation = breathCycle * 0.03;
			leftArm.y = -80 + breathCycle * 0.5;
			rightArm.rotation = breathCycle * 0.02; // Right arm holds sword
			rightArm.y = -80 + breathCycle * 0.3;
			// Arms in natural idle position with breathing
			// Add periodic subtle repositioning animation
			if (self.animationTick % 180 === 0) {
				// Every 3 seconds - subtle weight shift
				var shiftDirection = Math.random() > 0.5 ? 1 : -1;
				tween(leftLeg, {
					rotation: shiftDirection * 0.1
				}, {
					duration: 300,
					easing: tween.easeInOut
				});
				tween(rightLeg, {
					rotation: -shiftDirection * 0.08
				}, {
					duration: 300,
					easing: tween.easeInOut,
					onFinish: function onFinish() {
						tween(leftLeg, {
							rotation: 0
						}, {
							duration: 500,
							easing: tween.easeOut
						});
						tween(rightLeg, {
							rotation: 0
						}, {
							duration: 500,
							easing: tween.easeOut
						});
					}
				});
			}
		}
		// Face direction with smooth transition for all body parts
		if (self.facingRight) {
			warriorBody.scaleX = 1;
			leftArm.scaleX = 1;
			rightArm.scaleX = 1;
			leftLeg.scaleX = 1;
			rightLeg.scaleX = 1;
		} else {
			warriorBody.scaleX = -1;
			leftArm.scaleX = -1;
			rightArm.scaleX = -1;
			leftLeg.scaleX = -1;
			rightLeg.scaleX = -1;
		}
		// Keep player in bounds
		if (self.x < 30) self.x = 30;
		if (self.x > 2018) self.x = 2018;
		// Reset skew if character is not moving or attacking
		if (Math.abs(self.velocityX) < 0.1 && !self.isAttacking && !self.isJumping) {
			// Smoothly reset skew values
			if (Math.abs(warriorBody.skewX) > 0.001) {
				warriorBody.skewX *= 0.9;
			}
			if (Math.abs(warriorBody.skewY) > 0.001) {
				warriorBody.skewY *= 0.9;
			}
		}
	};
	self.moveLeft = function () {
		self.velocityX = -self.speed;
		if (self.facingRight) {
			// Add quick turn animation when changing direction
			self.facingRight = false;
			tween(warriorBody, {
				scaleX: -1.2,
				skewX: 0.1
			}, {
				duration: 100,
				onFinish: function onFinish() {
					tween(warriorBody, {
						scaleX: -1,
						skewX: 0
					}, {
						duration: 100
					});
				}
			});
			// No sword position changes needed
		} else {
			self.facingRight = false;
		}
		// Add quick leg push animation for movement start
		tween(warriorBody, {
			skewY: -0.05
		}, {
			duration: 50,
			onFinish: function onFinish() {
				tween(warriorBody, {
					skewY: 0
				}, {
					duration: 100
				});
			}
		});
	};
	self.moveRight = function () {
		self.velocityX = self.speed;
		if (!self.facingRight) {
			// Add quick turn animation when changing direction
			self.facingRight = true;
			tween(warriorBody, {
				scaleX: 1.2,
				skewX: -0.1
			}, {
				duration: 100,
				onFinish: function onFinish() {
					tween(warriorBody, {
						scaleX: 1,
						skewX: 0
					}, {
						duration: 100
					});
				}
			});
			// No sword position changes needed
		} else {
			self.facingRight = true;
		}
		// Add quick leg push animation for movement start
		tween(warriorBody, {
			skewY: 0.05
		}, {
			duration: 50,
			onFinish: function onFinish() {
				tween(warriorBody, {
					skewY: 0
				}, {
					duration: 100
				});
			}
		});
	};
	self.jump = function () {
		console.log("Jump called! onGround:", self.onGround, "velocityY:", self.velocityY);
		if (self.onGround || Math.abs(self.velocityY) < 2) {
			// First jump with squash animation
			self.velocityY = self.jumpPower;
			self.onGround = false;
			LK.getSound('jump').play();
			// Enhanced squash and stretch animation for jump with sword movement
			tween(warriorBody, {
				scaleY: 0.7,
				scaleX: self.facingRight ? 1.3 : -1.3
			}, {
				duration: 100,
				onFinish: function onFinish() {
					tween(warriorBody, {
						scaleY: 1.2,
						scaleX: self.facingRight ? 0.9 : -0.9
					}, {
						duration: 150,
						onFinish: function onFinish() {
							tween(warriorBody, {
								scaleY: 1,
								scaleX: self.facingRight ? 1 : -1
							}, {
								duration: 200
							});
						}
					});
				}
			});
			// Arms raised during jump for balance
			tween(leftArm, {
				y: -85,
				rotation: -0.4
			}, {
				duration: 100,
				onFinish: function onFinish() {
					tween(leftArm, {
						y: -80,
						rotation: 0
					}, {
						duration: 300
					});
				}
			});
			console.log("Jump executed! New velocityY:", self.velocityY);
		} else if (self.canDoubleJump && !self.hasUsedDoubleJump) {
			// Double jump with spin animation
			self.velocityY = self.jumpPower * 0.8;
			self.hasUsedDoubleJump = true;
			self.canDoubleJump = false;
			LK.getSound('jump').play();
			// Enhanced spin animation for double jump with sword trail effect
			var startRotation = warriorBody.rotation;
			tween(warriorBody, {
				rotation: startRotation + (self.facingRight ? Math.PI * 2 : -Math.PI * 2)
			}, {
				duration: 400,
				onFinish: function onFinish() {
					warriorBody.rotation = 0;
				}
			});
			// Arms spinning during double jump
			tween(leftArm, {
				rotation: leftArm.rotation + (self.facingRight ? Math.PI * 2 : -Math.PI * 2)
			}, {
				duration: 400,
				onFinish: function onFinish() {
					leftArm.rotation = 0;
				}
			});
			tween(rightArm, {
				rotation: rightArm.rotation + (self.facingRight ? Math.PI * 2 : -Math.PI * 2)
			}, {
				duration: 400,
				onFinish: function onFinish() {
					rightArm.rotation = 0;
				}
			});
			console.log("Double jump executed!");
		} else {
			console.log("Cannot jump - not on ground and no double jump available");
		}
	};
	self.attack = function () {
		if (self.attackCooldown <= 0) {
			self.attackCooldown = 30;
			self.isAttacking = true;
			LK.getSound('attack').play();
			// Hand-to-hand combat - punch animation
			var originalWarriorRotation = warriorBody.rotation;
			// Wind up phase - pull right arm back for powerful punch
			tween(rightArm, {
				rotation: -0.8,
				x: self.facingRight ? 5 : -5,
				y: -75
			}, {
				duration: 150,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					// Powerful punch forward
					tween(rightArm, {
						rotation: 0.6,
						x: self.facingRight ? 25 : -25,
						y: -80
					}, {
						duration: 200,
						easing: tween.easeIn,
						onFinish: function onFinish() {
							// Recovery - return arm to normal position
							tween(rightArm, {
								rotation: 0,
								x: self.facingRight ? 15 : -15,
								y: -80
							}, {
								duration: 250,
								easing: tween.easeInOut,
								onFinish: function onFinish() {
									self.isAttacking = false;
								}
							});
						}
					});
					// Warrior body movement during punch
					tween(warriorBody, {
						rotation: originalWarriorRotation + (self.facingRight ? 0.2 : -0.2),
						skewY: self.facingRight ? 0.1 : -0.1
					}, {
						duration: 150,
						onFinish: function onFinish() {
							tween(warriorBody, {
								rotation: originalWarriorRotation - (self.facingRight ? 0.1 : -0.1),
								skewY: self.facingRight ? -0.05 : 0.05
							}, {
								duration: 200,
								onFinish: function onFinish() {
									tween(warriorBody, {
										rotation: originalWarriorRotation,
										skewY: 0
									}, {
										duration: 250
									});
								}
							});
						}
					});
				}
			});
			// Add warrior body lean and step forward during punch
			LK.setTimeout(function () {
				// Dynamic body movement during attack
				tween(warriorBody, {
					scaleX: self.facingRight ? 1.1 : -1.1,
					x: self.facingRight ? 8 : -8
				}, {
					duration: 100,
					onFinish: function onFinish() {
						tween(warriorBody, {
							scaleX: self.facingRight ? 1 : -1,
							x: 0
						}, {
							duration: 150
						});
					}
				});
			}, 150);
			// Check for enemy hits during forward punch
			LK.setTimeout(function () {
				for (var i = enemies.length - 1; i >= 0; i--) {
					var enemy = enemies[i];
					// Calculate punch position based on warrior's facing direction and arm extension
					var punchReach = 80; // Increased reach for better hit detection
					var punchX = self.x + (self.facingRight ? punchReach : -punchReach);
					var punchY = self.y - 60; // Adjusted height to match enemy center
					// Calculate distance from punch position to enemy
					var distanceToEnemy = Math.abs(punchX - enemy.x);
					var verticalDistance = Math.abs(punchY - enemy.y);
					// Improved hit-box - larger rectangular area in front of warrior
					var hitBoxWidth = 70; // Increased width of punch hit area
					var hitBoxHeight = 80; // Increased height of punch hit area
					if (distanceToEnemy < hitBoxWidth && verticalDistance < hitBoxHeight) {
						// Additional check: enemy must be in front of warrior
						var enemyInFront = self.facingRight ? enemy.x > self.x : enemy.x < self.x;
						if (enemyInFront) {
							if (enemy.takeDamage(25)) {
								// Enemy damaged - check if destroyed
								enemies.splice(i, 1);
								LK.setScore(LK.getScore() + 100);
								scoreText.setText('Score: ' + LK.getScore());
							}
							// Enhanced knockback effect based on punch direction
							var knockbackDirection = self.facingRight ? 1 : -1;
							enemy.velocityX += knockbackDirection * 10;
							enemy.velocityY = -4; // Slightly stronger upward knockback
						}
					}
				}
			}, 120);
		}
	};
	self.takeDamage = function (damage) {
		self.health -= damage;
		LK.getSound('hit').play();
		// Enhanced damage flash effect on warrior and sword
		tween(warriorBody, {
			tint: 0xFF0066
		}, {
			duration: 150,
			onFinish: function onFinish() {
				tween(warriorBody, {
					tint: 0xFFFFFF
				}, {
					duration: 150
				});
			}
		});
		// Flash arms as well
		tween(leftArm, {
			tint: 0xFF0066
		}, {
			duration: 150,
			onFinish: function onFinish() {
				tween(leftArm, {
					tint: 0x8B4513
				}, {
					duration: 150
				});
			}
		});
		tween(rightArm, {
			tint: 0xFF0066
		}, {
			duration: 150,
			onFinish: function onFinish() {
				tween(rightArm, {
					tint: 0x8B4513
				}, {
					duration: 150
				});
			}
		});
		if (self.health <= 0) {
			LK.showGameOver();
		}
	};
	return self;
});
var StickmanEnemy = Container.expand(function () {
	var self = Container.call(this);
	// Create stickman body parts
	var head = self.attachAsset('enemy_head', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 0,
		y: -65
	});
	var body = self.attachAsset('enemy_body', {
		anchorX: 0.5,
		anchorY: 0,
		x: 0,
		y: -50
	});
	var leftArm = self.attachAsset('enemy_limb', {
		anchorX: 0.5,
		anchorY: 0,
		x: -10,
		y: -40
	});
	var rightArm = self.attachAsset('enemy_limb', {
		anchorX: 0.5,
		anchorY: 0,
		x: 10,
		y: -40
	});
	var leftLeg = self.attachAsset('enemy_limb', {
		anchorX: 0.5,
		anchorY: 0,
		x: -5,
		y: -20
	});
	var rightLeg = self.attachAsset('enemy_limb', {
		anchorX: 0.5,
		anchorY: 0,
		x: 5,
		y: -20
	});
	var sword = self.attachAsset('enemy_sword', {
		anchorX: 0.5,
		anchorY: 1,
		x: 15,
		y: -30
	});
	self.velocityX = 0;
	self.velocityY = 0;
	self.health = 50;
	self.maxHealth = 50;
	// Create health bar background
	var healthBarBg = self.attachAsset('platform', {
		width: 60,
		height: 8,
		anchorX: 0.5,
		anchorY: 0.5,
		x: 0,
		y: -90,
		tint: 0x000000
	});
	// Create health bar fill
	var healthBarFill = self.attachAsset('platform', {
		width: 56,
		height: 6,
		anchorX: 0.5,
		anchorY: 0.5,
		x: 0,
		y: -90,
		tint: 0x00FF00
	});
	self.speed = 1.5;
	self.direction = 1;
	self.onGround = false;
	self.attackRange = 80;
	self.attackCooldown = 0;
	self.animationTick = 0;
	self.isAttacking = false;
	self.lastPlayerDistance = 999;
	self.update = function () {
		// Apply gravity
		if (!self.onGround) {
			self.velocityY += 0.8;
		}
		// AI behavior - chase player if close enough
		var distanceToPlayer = Math.abs(self.x - player.x);
		var verticalDistance = Math.abs(self.y - player.y);
		if (distanceToPlayer < 200 && verticalDistance < 100) {
			// Chase player
			if (player.x > self.x) {
				self.direction = 1;
				self.velocityX = self.speed;
			} else {
				self.direction = -1;
				self.velocityX = -self.speed;
			}
			// Attack if in range
			if (distanceToPlayer < self.attackRange && self.attackCooldown <= 0) {
				self.attackPlayer();
			}
		} else {
			// Simple patrol movement
			self.velocityX = self.speed * self.direction;
		}
		// Apply velocity
		self.x += self.velocityX;
		self.y += self.velocityY;
		// Reset ground detection
		self.onGround = false;
		// Reverse direction at edges
		if (self.x < 50 || self.x > 1998) {
			self.direction *= -1;
		}
		// Update attack cooldown
		if (self.attackCooldown > 0) {
			self.attackCooldown--;
		}
		// Animation
		self.animationTick++;
		if (!self.isAttacking) {
			// Walking animation with more realistic movement
			var walkSpeed = Math.abs(self.velocityX) > 0.1 ? 0.25 : 0.1;
			var walkCycle = Math.sin(self.animationTick * walkSpeed);
			var walkCycleOffset = Math.sin(self.animationTick * walkSpeed + Math.PI);
			// Leg animation - alternate walking
			leftLeg.rotation = walkCycle * 0.4;
			rightLeg.rotation = walkCycleOffset * 0.4;
			// Arm animation - opposite to legs (natural walking)
			leftArm.rotation = walkCycleOffset * 0.3;
			rightArm.rotation = walkCycle * 0.3;
			// Body bob animation when walking
			if (Math.abs(self.velocityX) > 0.1) {
				body.y = -50 + Math.abs(Math.sin(self.animationTick * walkSpeed * 2)) * 2;
				head.y = -65 + Math.abs(Math.sin(self.animationTick * walkSpeed * 2)) * 2;
			} else {
				// Return to normal position when not walking
				body.y = -50;
				head.y = -65;
			}
		}
		// Face direction
		if (self.direction > 0) {
			head.scaleX = 1;
			body.scaleX = 1;
			leftArm.scaleX = 1;
			rightArm.scaleX = 1;
			leftLeg.scaleX = 1;
			rightLeg.scaleX = 1;
			sword.scaleX = 1;
			sword.x = 15;
		} else {
			head.scaleX = -1;
			body.scaleX = -1;
			leftArm.scaleX = -1;
			rightArm.scaleX = -1;
			leftLeg.scaleX = -1;
			rightLeg.scaleX = -1;
			sword.scaleX = -1;
			sword.x = -15;
		}
		self.lastPlayerDistance = distanceToPlayer;
	};
	self.attackPlayer = function () {
		if (self.attackCooldown <= 0) {
			self.attackCooldown = 120; // 2 seconds at 60fps
			self.isAttacking = true;
			// Sword attack animation - swing from back to front
			tween(sword, {
				rotation: -1.8
			}, {
				duration: 150,
				onFinish: function onFinish() {
					// Swing forward
					tween(sword, {
						rotation: 0.8
					}, {
						duration: 200,
						onFinish: function onFinish() {
							// Return to normal position
							tween(sword, {
								rotation: 0
							}, {
								duration: 250,
								onFinish: function onFinish() {
									self.isAttacking = false;
								}
							});
						}
					});
					// Check if player is hit during forward swing (after 150ms delay)
					LK.setTimeout(function () {
						var distanceToPlayer = Math.abs(self.x - player.x);
						if (distanceToPlayer < self.attackRange) {
							player.takeDamage(10);
							// Knockback effect
							var knockbackDirection = player.x > self.x ? 1 : -1;
							player.velocityX += knockbackDirection * 8;
						}
					}, 150);
				}
			});
		}
	};
	self.takeDamage = function (damage) {
		self.health -= damage;
		// Update health bar
		var healthPercent = Math.max(0, self.health / self.maxHealth);
		healthBarFill.width = 56 * healthPercent;
		// Change health bar color based on health
		if (healthPercent > 0.6) {
			healthBarFill.tint = 0x00FF00; // Green
		} else if (healthPercent > 0.3) {
			healthBarFill.tint = 0xFFFF00; // Yellow
		} else {
			healthBarFill.tint = 0xFF0000; // Red
		}
		// Damage flash effect on all body parts
		var bodyParts = [head, body, leftArm, rightArm, leftLeg, rightLeg];
		for (var i = 0; i < bodyParts.length; i++) {
			var part = bodyParts[i];
			tween(part, {
				tint: 0xFFFFFF
			}, {
				duration: 100,
				onFinish: function onFinish() {
					tween(part, {
						tint: 0xFF0000
					}, {
						duration: 100
					});
				}
			});
		}
		if (self.health <= 0) {
			self.destroy();
			return true;
		}
		return false;
	};
	return self;
});

/**** 
* Initialize Game
****/ 
var game = new LK.Game({
	backgroundColor: 0x001122 // Dark digital blue background
});

/**** 
* Game Code
****/ 
// Game arrays
// Initialize assets for Stickman Vs. Digital Warrior
var platforms = [];
var enemies = [];
var projectiles = [];
// Create ground
var ground = game.addChild(LK.getAsset('ground', {
	anchorX: 0.5,
	anchorY: 1.0,
	x: 1024,
	y: 2732
}));
// Create platforms
var platformData = [{
	x: 300,
	y: 2500
}, {
	x: 600,
	y: 2300
}, {
	x: 1000,
	y: 2400
}, {
	x: 1400,
	y: 2200
}, {
	x: 1700,
	y: 2500
}];
for (var i = 0; i < platformData.length; i++) {
	var platform = new Platform();
	platform.x = platformData[i].x;
	platform.y = platformData[i].y;
	platforms.push(platform);
	game.addChild(platform);
}
// Create player
var player = new Stickman();
player.x = 1024;
player.y = 2600;
player.canDoubleJump = true;
player.hasUsedDoubleJump = false;
game.addChild(player);
// Create double jump stamina bar
var staminaBarBackground = LK.getAsset('platform', {
	width: 120,
	height: 20,
	anchorX: 0.5,
	anchorY: 0.5,
	tint: 0x000000
});
game.addChild(staminaBarBackground);
var staminaBar = LK.getAsset('platform', {
	width: 110,
	height: 14,
	anchorX: 0.5,
	anchorY: 0.5,
	tint: 0xFFFFFF
});
game.addChild(staminaBar);
// Create enemies
var enemyData = [{
	x: 700,
	y: 2250
}, {
	x: 1200,
	y: 2350
}, {
	x: 1500,
	y: 2150
}];
for (var i = 0; i < enemyData.length; i++) {
	var enemy = new StickmanEnemy();
	enemy.x = enemyData[i].x;
	enemy.y = enemyData[i].y;
	enemies.push(enemy);
	game.addChild(enemy);
}
// UI Elements
var healthText = new Text2('Health: 100', {
	size: 40,
	fill: 0x00FF00
});
healthText.anchor.set(0, 0);
LK.gui.left.addChild(healthText);
healthText.y = 200; // Position below top-left menu area
var scoreText = new Text2('Score: 0', {
	size: 40,
	fill: 0xFFFFFF
});
scoreText.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreText);
// Mobile Controls UI - Improved for better ergonomics
var leftButton = LK.getAsset('platform', {
	width: 220,
	height: 220,
	anchorX: 0.5,
	anchorY: 0.5,
	alpha: 0.6,
	tint: 0x4444FF
});
leftButton.x = 140;
leftButton.y = LK.gui.bottom.y - 140;
leftButton.interactive = true;
leftButton.buttonMode = true;
LK.gui.addChild(leftButton);
// Left arrow icon (warrior moving left)
var leftIcon = LK.getAsset('warrior', {
	width: 60,
	height: 70,
	anchorX: 0.5,
	anchorY: 0.5,
	alpha: 0.8,
	scaleX: -1
});
leftIcon.x = leftButton.x;
leftIcon.y = leftButton.y;
LK.gui.addChild(leftIcon);
var rightButton = LK.getAsset('platform', {
	width: 220,
	height: 220,
	anchorX: 0.5,
	anchorY: 0.5,
	alpha: 0.6,
	tint: 0x4444FF
});
rightButton.x = 400;
rightButton.y = LK.gui.bottom.y - 140;
rightButton.interactive = true;
rightButton.buttonMode = true;
LK.gui.addChild(rightButton);
// Right arrow icon (warrior moving right)
var rightIcon = LK.getAsset('warrior', {
	width: 60,
	height: 70,
	anchorX: 0.5,
	anchorY: 0.5,
	alpha: 0.8
});
rightIcon.x = rightButton.x;
rightIcon.y = rightButton.y;
LK.gui.addChild(rightIcon);
var jumpButton = LK.getAsset('platform', {
	width: 240,
	height: 240,
	anchorX: 0.5,
	anchorY: 0.5,
	alpha: 0.6,
	tint: 0x44FF44
});
jumpButton.x = LK.gui.right.x - 140;
jumpButton.y = LK.gui.bottom.y - 140;
jumpButton.interactive = true;
jumpButton.buttonMode = true;
LK.gui.addChild(jumpButton);
// Jump icon (warrior jumping)
var jumpIcon = LK.getAsset('warrior', {
	width: 70,
	height: 80,
	anchorX: 0.5,
	anchorY: 0.5,
	alpha: 0.8,
	rotation: -0.3
});
jumpIcon.x = jumpButton.x;
jumpIcon.y = jumpButton.y - 10;
LK.gui.addChild(jumpIcon);
var attackButton = LK.getAsset('platform', {
	width: 220,
	height: 220,
	anchorX: 0.5,
	anchorY: 0.5,
	alpha: 0.6,
	tint: 0xFF4444
});
attackButton.x = LK.gui.right.x - 400;
attackButton.y = LK.gui.bottom.y - 140;
attackButton.interactive = true;
attackButton.buttonMode = true;
LK.gui.addChild(attackButton);
// Attack label (keeping text for attack button)
var attackLabel = new Text2('ATK', {
	size: 45,
	fill: 0xFFFFFF
});
attackLabel.anchor.set(0.5, 0.5);
attackLabel.x = attackButton.x;
attackLabel.y = attackButton.y;
LK.gui.addChild(attackLabel);
// Input handling
var leftPressed = false;
var rightPressed = false;
var currentTouchId = null;
// Button press detection
leftButton.down = function (x, y, obj) {
	leftPressed = true;
	currentTouchId = 'left';
	tween(leftButton, {
		alpha: 0.9
	}, {
		duration: 100
	});
};
leftButton.up = function (x, y, obj) {
	leftPressed = false;
	if (currentTouchId === 'left') currentTouchId = null;
	tween(leftButton, {
		alpha: 0.6
	}, {
		duration: 100
	});
};
rightButton.down = function (x, y, obj) {
	rightPressed = true;
	currentTouchId = 'right';
	tween(rightButton, {
		alpha: 0.9
	}, {
		duration: 100
	});
};
rightButton.up = function (x, y, obj) {
	rightPressed = false;
	if (currentTouchId === 'right') currentTouchId = null;
	tween(rightButton, {
		alpha: 0.6
	}, {
		duration: 100
	});
};
jumpButton.down = function (x, y, obj) {
	console.log("Jump button pressed!");
	player.jump();
	tween(jumpButton, {
		alpha: 0.9
	}, {
		duration: 100
	});
};
jumpButton.up = function (x, y, obj) {
	tween(jumpButton, {
		alpha: 0.6
	}, {
		duration: 100
	});
};
attackButton.down = function (x, y, obj) {
	player.attack();
	tween(attackButton, {
		alpha: 0.9
	}, {
		duration: 100
	});
};
attackButton.up = function (x, y, obj) {
	tween(attackButton, {
		alpha: 0.6
	}, {
		duration: 100
	});
};
game.down = function (x, y, obj) {
	// Fallback touch handling for areas outside buttons
};
game.up = function (x, y, obj) {
	// Fallback touch release handling
};
// Collision detection function
function checkCollisions(obj, platforms) {
	for (var i = 0; i < platforms.length; i++) {
		var platform = platforms[i];
		if (obj.intersects(platform)) {
			// Landing on top of platform
			if (obj.velocityY > 0 && obj.y - 40 < platform.y) {
				obj.y = platform.y - 40;
				obj.velocityY = 0;
				obj.onGround = true;
				// Reset double jump when landing
				if (obj === player) {
					obj.canDoubleJump = true;
					obj.hasUsedDoubleJump = false;
				}
			}
		}
	}
	// Ground collision
	if (obj.y > 2632) {
		obj.y = 2632;
		obj.velocityY = 0;
		obj.onGround = true;
		// Reset double jump when landing on ground
		if (obj === player) {
			obj.canDoubleJump = true;
			obj.hasUsedDoubleJump = false;
		}
	}
}
game.update = function () {
	// Handle input
	if (leftPressed) {
		player.moveLeft();
	}
	if (rightPressed) {
		player.moveRight();
	}
	// Check collisions for player
	checkCollisions(player, platforms);
	// Check collisions for enemies
	for (var i = 0; i < enemies.length; i++) {
		checkCollisions(enemies[i], platforms);
	}
	// Update projectiles and check enemy hits
	for (var i = projectiles.length - 1; i >= 0; i--) {
		var projectile = projectiles[i];
		// Check if projectile hits enemies
		for (var j = enemies.length - 1; j >= 0; j--) {
			var enemy = enemies[j];
			if (projectile.intersects(enemy)) {
				if (enemy.takeDamage(25)) {
					// Enemy destroyed
					enemies.splice(j, 1);
					LK.setScore(LK.getScore() + 100);
					scoreText.setText('Score: ' + LK.getScore());
				}
				// Remove projectile
				projectile.destroy();
				projectiles.splice(i, 1);
				break;
			}
		}
		// Remove destroyed projectiles
		if (projectile.parent === null) {
			projectiles.splice(i, 1);
		}
	}
	// Check player-enemy collisions
	for (var i = 0; i < enemies.length; i++) {
		var enemy = enemies[i];
		if (player.intersects(enemy)) {
			// Simple knockback and damage
			var dx = player.x - enemy.x;
			player.velocityX += dx > 0 ? 5 : -5;
			player.takeDamage(1);
			// Update health display
			healthText.setText('Health: ' + Math.max(0, player.health));
			healthText.tint = player.health < 30 ? 0xFF0000 : 0x00FF00;
		}
	}
	// Win condition - defeat all enemies
	if (enemies.length === 0) {
		LK.showYouWin();
	}
	// Update stamina bar position and appearance - moved higher up
	staminaBarBackground.x = player.x;
	staminaBarBackground.y = player.y - 130;
	staminaBar.x = player.x;
	staminaBar.y = player.y - 130;
	// Update stamina bar color based on double jump availability
	if (player.canDoubleJump && !player.hasUsedDoubleJump) {
		staminaBar.tint = 0x00FF00; // Bright green when available
	} else {
		staminaBar.tint = 0x444444; // Dark gray when used
	}
	// Camera follow player (simple)
	var targetY = Math.max(-1366, Math.min(0, -(player.y - 1366)));
	game.y += (targetY - game.y) * 0.1;
};

===================================================================
--- original.js
+++ change.js
@@ -557,17 +557,17 @@
 			LK.setTimeout(function () {
 				for (var i = enemies.length - 1; i >= 0; i--) {
 					var enemy = enemies[i];
 					// Calculate punch position based on warrior's facing direction and arm extension
-					var punchReach = 50; // How far the punch extends
+					var punchReach = 80; // Increased reach for better hit detection
 					var punchX = self.x + (self.facingRight ? punchReach : -punchReach);
-					var punchY = self.y - 80; // Height of the punch (shoulder level)
+					var punchY = self.y - 60; // Adjusted height to match enemy center
 					// Calculate distance from punch position to enemy
 					var distanceToEnemy = Math.abs(punchX - enemy.x);
 					var verticalDistance = Math.abs(punchY - enemy.y);
-					// More precise hit-box - rectangular area in front of warrior
-					var hitBoxWidth = 45; // Width of punch hit area
-					var hitBoxHeight = 60; // Height of punch hit area
+					// Improved hit-box - larger rectangular area in front of warrior
+					var hitBoxWidth = 70; // Increased width of punch hit area
+					var hitBoxHeight = 80; // Increased height of punch hit area
 					if (distanceToEnemy < hitBoxWidth && verticalDistance < hitBoxHeight) {
 						// Additional check: enemy must be in front of warrior
 						var enemyInFront = self.facingRight ? enemy.x > self.x : enemy.x < self.x;
 						if (enemyInFront) {
@@ -583,9 +583,9 @@
 							enemy.velocityY = -4; // Slightly stronger upward knockback
 						}
 					}
 				}
-			}, 150);
+			}, 120);
 		}
 	};
 	self.takeDamage = function (damage) {
 		self.health -= damage;