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

/**** 
* Classes
****/ 
var Enemy = Container.expand(function () {
	var self = Container.call(this);
	var enemyBody = self.attachAsset('enemy', {
		anchorX: 0.5,
		anchorY: 1.0
	});
	self.speed = 2;
	self.direction = 1;
	self.startX = 0;
	self.patrolDistance = 300;
	self.update = function () {
		self.x += self.speed * self.direction;
		if (Math.abs(self.x - self.startX) > self.patrolDistance) {
			self.direction *= -1;
		}
		// Ground collision for enemies
		if (self.y >= groundLevel) {
			self.y = groundLevel;
		}
		// Platform collision for enemies
		for (var i = 0; i < platforms.length; i++) {
			var platform = platforms[i];
			// Check if enemy is on top of platform
			if (self.intersects(platform)) {
				var platformLeft = platform.x - 100; // platform width/2
				var platformRight = platform.x + 100; // platform width/2
				var platformTop = platform.y - 20; // platform height/2
				var enemyLeft = self.x - 30; // enemy width/2
				var enemyRight = self.x + 30; // enemy width/2
				var enemyBottom = self.y;
				// Landing on platform
				if (enemyBottom > platformTop && enemyBottom < platformTop + 50 && enemyRight > platformLeft && enemyLeft < platformRight) {
					self.y = platformTop;
				}
			}
		}
	};
	return self;
});
var JunkPile = Container.expand(function () {
	var self = Container.call(this);
	var junkBody = self.attachAsset('junkPile', {
		anchorX: 0.5,
		anchorY: 1.0
	});
	return self;
});
var Platform = Container.expand(function () {
	var self = Container.call(this);
	var platformBody = self.attachAsset('platform', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	return self;
});
var Player = Container.expand(function () {
	var self = Container.call(this);
	var playerBody = self.attachAsset('player', {
		anchorX: 0.5,
		anchorY: 1.0
	});
	var leftEye = self.attachAsset('playerEye', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: -20,
		y: -50
	});
	var rightEye = self.attachAsset('playerEye', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 20,
		y: -50
	});
	var leftPupil = self.attachAsset('playerPupil', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: -20,
		y: -50
	});
	var rightPupil = self.attachAsset('playerPupil', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 20,
		y: -50
	});
	self.velocityX = 0;
	self.velocityY = 0;
	self.onGround = false;
	self.jumpCount = 0;
	self.maxJumps = 2;
	self.jumpPower = -15;
	self.gravity = 0.8;
	self.maxSpeed = 8;
	self.friction = 0.85;
	self.dashPower = 20;
	self.dashDuration = 200;
	self.dashCooldown = 1000;
	self.isDashing = false;
	self.dashTimeRemaining = 0;
	self.lastDashTime = 0;
	self.isSprinting = false;
	self.sprintMultiplier = 1.8;
	self.normalMaxSpeed = 8;
	self.sprintMaxSpeed = 14;
	self.particles = [];
	self.particleTimer = 0;
	self.currentExpression = 'normal';
	self.expressionTimer = 0;
	self.leftPupil = leftPupil;
	self.rightPupil = rightPupil;
	self.leftEye = leftEye;
	self.rightEye = rightEye;
	self.update = function () {
		// Handle dash mechanics
		if (self.isDashing && self.dashTimeRemaining > 0) {
			self.dashTimeRemaining -= 16; // Assuming 60fps, ~16ms per frame
			if (self.dashTimeRemaining <= 0) {
				self.isDashing = false;
			}
		}
		// Apply gravity (reduced during dash)
		if (!self.isDashing) {
			self.velocityY += self.gravity;
		} else {
			self.velocityY += self.gravity * 0.3; // Reduced gravity during dash
		}
		// Apply friction
		self.velocityX *= self.friction;
		// Update position
		self.x += self.velocityX;
		self.y += self.velocityY;
		// Ground collision
		if (self.y >= groundLevel) {
			self.y = groundLevel;
			self.velocityY = 0;
			self.onGround = true;
			self.jumpCount = 0;
		} else {
			self.onGround = false;
		}
		// Platform collision
		for (var i = 0; i < platforms.length; i++) {
			var platform = platforms[i];
			// Check if player is intersecting with platform
			if (self.intersects(platform)) {
				// Calculate platform boundaries
				var platformLeft = platform.x - 100; // platform width/2
				var platformRight = platform.x + 100; // platform width/2
				var platformTop = platform.y - 20; // platform height/2
				var platformBottom = platform.y + 20; // platform height/2
				var playerLeft = self.x - 40; // player width/2
				var playerRight = self.x + 40; // player width/2
				var playerTop = self.y - 80; // player height
				var playerBottom = self.y;
				// Landing on top of platform
				if (self.velocityY > 0 && playerBottom > platformTop && playerTop < platformTop && playerRight > platformLeft && playerLeft < platformRight) {
					self.y = platformTop;
					self.velocityY = 0;
					self.onGround = true;
					self.jumpCount = 0;
				}
				// Hitting platform from below
				else if (self.velocityY < 0 && playerTop < platformBottom && playerBottom > platformBottom && playerRight > platformLeft && playerLeft < platformRight) {
					self.y = platformBottom + 80;
					self.velocityY = 0;
				}
				// Hitting platform from left
				else if (self.velocityX > 0 && playerRight > platformLeft && playerLeft < platformLeft && playerBottom > platformTop && playerTop < platformBottom) {
					self.x = platformLeft - 40;
					self.velocityX = 0;
				}
				// Hitting platform from right
				else if (self.velocityX < 0 && playerLeft < platformRight && playerRight > platformRight && playerBottom > platformTop && playerTop < platformBottom) {
					self.x = platformRight + 40;
					self.velocityX = 0;
				}
			}
		}
		// Boundary checking
		if (self.x < 40) {
			self.x = 40;
		}
		if (self.x > levelWidth - 40) {
			self.x = levelWidth - 40;
		}
		// Create particles when moving
		if (Math.abs(self.velocityX) > 1 || Math.abs(self.velocityY) > 1) {
			self.particleTimer++;
			var particleRate = self.isSprinting ? 3 : 5;
			if (self.particleTimer >= particleRate) {
				self.createParticle();
				self.particleTimer = 0;
			}
		}
		// Update particles
		for (var p = self.particles.length - 1; p >= 0; p--) {
			var particle = self.particles[p];
			particle.x += particle.velocityX;
			particle.y += particle.velocityY;
			particle.velocityY += 0.1; // Gravity effect on particles
			particle.life--;
			if (particle.life <= 0) {
				particle.destroy();
				self.particles.splice(p, 1);
			}
		}
		// Handle facial expressions based on player state
		self.updateExpression();
	};
	self.jump = function () {
		if (self.jumpCount < self.maxJumps) {
			self.velocityY = self.jumpPower;
			self.jumpCount++;
			self.onGround = false;
			LK.getSound('jump').play();
		}
	};
	self.moveLeft = function () {
		var currentMaxSpeed = self.isSprinting ? self.sprintMaxSpeed : self.normalMaxSpeed;
		var acceleration = self.isSprinting ? 2.2 : 1.5;
		self.velocityX = Math.max(self.velocityX - acceleration, -currentMaxSpeed);
	};
	self.moveRight = function () {
		var currentMaxSpeed = self.isSprinting ? self.sprintMaxSpeed : self.normalMaxSpeed;
		var acceleration = self.isSprinting ? 2.2 : 1.5;
		self.velocityX = Math.min(self.velocityX + acceleration, currentMaxSpeed);
	};
	self.dash = function (direction) {
		var currentTime = Date.now();
		if (currentTime - self.lastDashTime >= self.dashCooldown && !self.isDashing) {
			self.isDashing = true;
			self.dashTimeRemaining = self.dashDuration;
			self.lastDashTime = currentTime;
			// Apply dash velocity
			self.velocityX = self.dashPower * direction;
			// Visual dash effect with tween
			tween(self, {
				scaleX: 1.3,
				scaleY: 0.8
			}, {
				duration: 100,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					tween(self, {
						scaleX: 1,
						scaleY: 1
					}, {
						duration: 100,
						easing: tween.easeIn
					});
				}
			});
			// Flash effect during dash
			tween(self, {
				alpha: 0.7
			}, {
				duration: self.dashDuration / 2,
				easing: tween.easeInOut,
				onFinish: function onFinish() {
					tween(self, {
						alpha: 1
					}, {
						duration: self.dashDuration / 2,
						easing: tween.easeInOut
					});
				}
			});
		}
	};
	self.startSprint = function () {
		self.isSprinting = true;
		// Visual sprint effect with tween
		tween(self, {
			tint: 0x87CEEB
		}, {
			duration: 200,
			easing: tween.easeOut
		});
	};
	self.stopSprint = function () {
		self.isSprinting = false;
		// Remove sprint visual effect
		tween(self, {
			tint: 0xFFFFFF
		}, {
			duration: 200,
			easing: tween.easeOut
		});
	};
	self.createParticle = function () {
		var particle = LK.getAsset('particle', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: self.x + (Math.random() - 0.5) * 40,
			y: self.y - Math.random() * 20,
			alpha: 0.8
		});
		particle.velocityX = (Math.random() - 0.5) * 4;
		particle.velocityY = Math.random() * -2 - 1;
		particle.life = 30 + Math.random() * 20;
		particle.maxLife = particle.life;
		self.particles.push(particle);
		game.addChild(particle);
		// Animate particle with tween
		tween(particle, {
			alpha: 0,
			scaleX: 0.3,
			scaleY: 0.3
		}, {
			duration: particle.life * 16,
			easing: tween.easeOut
		});
	};
	self.updateExpression = function () {
		self.expressionTimer++;
		// Determine expression based on player state
		var newExpression = 'normal';
		if (self.isDashing) {
			newExpression = 'focused';
		} else if (self.isSprinting) {
			newExpression = 'excited';
		} else if (Math.abs(self.velocityY) > 5) {
			newExpression = 'surprised';
		} else if (Math.abs(self.velocityX) > 6) {
			newExpression = 'happy';
		} else if (self.expressionTimer > 300 && Math.random() < 0.1) {
			// Occasional blink
			newExpression = 'blink';
			self.expressionTimer = 0;
		}
		if (newExpression !== self.currentExpression) {
			self.setExpression(newExpression);
			self.currentExpression = newExpression;
		}
	};
	self.setExpression = function (expression) {
		// Stop any ongoing tweens on pupils and eyes
		tween.stop(self.leftPupil);
		tween.stop(self.rightPupil);
		tween.stop(self.leftEye);
		tween.stop(self.rightEye);
		switch (expression) {
			case 'happy':
				// Wide eyes with pupils moved up slightly
				tween(self.leftEye, {
					scaleY: 1.2
				}, {
					duration: 200,
					easing: tween.easeOut
				});
				tween(self.rightEye, {
					scaleY: 1.2
				}, {
					duration: 200,
					easing: tween.easeOut
				});
				tween(self.leftPupil, {
					y: -52,
					scaleX: 1.1,
					scaleY: 1.1
				}, {
					duration: 200,
					easing: tween.easeOut
				});
				tween(self.rightPupil, {
					y: -52,
					scaleX: 1.1,
					scaleY: 1.1
				}, {
					duration: 200,
					easing: tween.easeOut
				});
				break;
			case 'surprised':
				// Very wide eyes with large pupils
				tween(self.leftEye, {
					scaleX: 1.4,
					scaleY: 1.4
				}, {
					duration: 150,
					easing: tween.easeOut
				});
				tween(self.rightEye, {
					scaleX: 1.4,
					scaleY: 1.4
				}, {
					duration: 150,
					easing: tween.easeOut
				});
				tween(self.leftPupil, {
					scaleX: 1.3,
					scaleY: 1.3
				}, {
					duration: 150,
					easing: tween.easeOut
				});
				tween(self.rightPupil, {
					scaleX: 1.3,
					scaleY: 1.3
				}, {
					duration: 150,
					easing: tween.easeOut
				});
				break;
			case 'focused':
				// Narrowed eyes with pupils closer together
				tween(self.leftEye, {
					scaleY: 0.7
				}, {
					duration: 100,
					easing: tween.easeOut
				});
				tween(self.rightEye, {
					scaleY: 0.7
				}, {
					duration: 100,
					easing: tween.easeOut
				});
				tween(self.leftPupil, {
					x: -18,
					y: -50,
					scaleX: 0.9,
					scaleY: 0.9
				}, {
					duration: 100,
					easing: tween.easeOut
				});
				tween(self.rightPupil, {
					x: 18,
					y: -50,
					scaleX: 0.9,
					scaleY: 0.9
				}, {
					duration: 100,
					easing: tween.easeOut
				});
				break;
			case 'excited':
				// Bouncing pupils
				var bounceUp = function bounceUp() {
					tween(self.leftPupil, {
						y: -55
					}, {
						duration: 300,
						easing: tween.easeInOut,
						onFinish: bounceDown
					});
					tween(self.rightPupil, {
						y: -55
					}, {
						duration: 300,
						easing: tween.easeInOut
					});
				};
				var bounceDown = function bounceDown() {
					tween(self.leftPupil, {
						y: -45
					}, {
						duration: 300,
						easing: tween.easeInOut,
						onFinish: bounceUp
					});
					tween(self.rightPupil, {
						y: -45
					}, {
						duration: 300,
						easing: tween.easeInOut
					});
				};
				bounceUp();
				break;
			case 'blink':
				// Quick blink animation
				tween(self.leftEye, {
					scaleY: 0.1
				}, {
					duration: 100,
					easing: tween.easeOut,
					onFinish: function onFinish() {
						tween(self.leftEye, {
							scaleY: 1
						}, {
							duration: 100,
							easing: tween.easeOut
						});
					}
				});
				tween(self.rightEye, {
					scaleY: 0.1
				}, {
					duration: 100,
					easing: tween.easeOut,
					onFinish: function onFinish() {
						tween(self.rightEye, {
							scaleY: 1
						}, {
							duration: 100,
							easing: tween.easeOut
						});
					}
				});
				// Return to normal after blink
				LK.setTimeout(function () {
					self.setExpression('normal');
				}, 300);
				break;
			case 'normal':
			default:
				// Reset to default positions and scales
				tween(self.leftEye, {
					scaleX: 1,
					scaleY: 1
				}, {
					duration: 300,
					easing: tween.easeOut
				});
				tween(self.rightEye, {
					scaleX: 1,
					scaleY: 1
				}, {
					duration: 300,
					easing: tween.easeOut
				});
				tween(self.leftPupil, {
					x: -20,
					y: -50,
					scaleX: 1,
					scaleY: 1
				}, {
					duration: 300,
					easing: tween.easeOut
				});
				tween(self.rightPupil, {
					x: 20,
					y: -50,
					scaleX: 1,
					scaleY: 1
				}, {
					duration: 300,
					easing: tween.easeOut
				});
				break;
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
var player;
var enemies = [];
var platforms = [];
var junkPiles = [];
var goal;
var camera;
var groundLevel = 2600;
var levelWidth = 4000;
var gameWon = false;
// Create camera object for following player
camera = {
	x: 0,
	y: 0,
	targetX: 0,
	targetY: 0,
	smoothing: 0.1
};
// Create player
player = game.addChild(new Player());
player.x = 200;
player.y = groundLevel;
// Create platforms
var platformPositions = [{
	x: 500,
	y: 2400
}, {
	x: 800,
	y: 2200
}, {
	x: 1200,
	y: 2300
}, {
	x: 1600,
	y: 2100
}, {
	x: 2000,
	y: 2000
}, {
	x: 2400,
	y: 2200
}, {
	x: 2800,
	y: 2400
}, {
	x: 3200,
	y: 2300
}, {
	x: 3600,
	y: 2500
}];
for (var i = 0; i < platformPositions.length; i++) {
	var platform = game.addChild(new Platform());
	platform.x = platformPositions[i].x;
	platform.y = platformPositions[i].y;
	platforms.push(platform);
}
// Create enemies
var enemyPositions = [{
	x: 600,
	y: groundLevel
}, {
	x: 1000,
	y: 2200
}, {
	x: 1400,
	y: groundLevel
}, {
	x: 1800,
	y: 2000
}, {
	x: 2200,
	y: groundLevel
}, {
	x: 2600,
	y: 2200
}, {
	x: 3000,
	y: groundLevel
}, {
	x: 3400,
	y: 2300
}];
for (var i = 0; i < enemyPositions.length; i++) {
	var enemy = game.addChild(new Enemy());
	enemy.x = enemyPositions[i].x;
	enemy.y = enemyPositions[i].y;
	enemy.startX = enemy.x;
	enemies.push(enemy);
}
// Create junk piles for decoration
var junkPositions = [{
	x: 300,
	y: groundLevel
}, {
	x: 700,
	y: groundLevel
}, {
	x: 1100,
	y: groundLevel
}, {
	x: 1500,
	y: groundLevel
}, {
	x: 1900,
	y: groundLevel
}, {
	x: 2300,
	y: groundLevel
}, {
	x: 2700,
	y: groundLevel
}, {
	x: 3100,
	y: groundLevel
}, {
	x: 3500,
	y: groundLevel
}];
for (var i = 0; i < junkPositions.length; i++) {
	var junk = game.addChild(new JunkPile());
	junk.x = junkPositions[i].x;
	junk.y = junkPositions[i].y;
	junkPiles.push(junk);
}
// Create goal
goal = game.addChild(LK.getAsset('goal', {
	anchorX: 0.5,
	anchorY: 0.5
}));
goal.x = levelWidth - 200;
goal.y = groundLevel - 50;
// Touch controls
var touchStartX = 0;
var touchStartY = 0;
var isDragging = false;
game.down = function (x, y, obj) {
	touchStartX = x;
	touchStartY = y;
	isDragging = true;
	// Jump on tap
	player.jump();
};
game.move = function (x, y, obj) {
	if (isDragging) {
		var deltaX = x - touchStartX;
		var deltaY = Math.abs(y - touchStartY);
		// Check for dash gesture (fast horizontal swipe)
		if (Math.abs(deltaX) > 100 && deltaY < 50) {
			var dashDirection = deltaX > 0 ? 1 : -1;
			player.dash(dashDirection);
			isDragging = false; // End drag to prevent continuous movement
		}
		// Check for sprint gesture (long horizontal drag)
		else if (Math.abs(deltaX) > 50) {
			if (!player.isSprinting) {
				player.startSprint();
			}
			if (deltaX < -20) {
				player.moveLeft();
			} else if (deltaX > 20) {
				player.moveRight();
			}
		}
		// Regular movement for smaller gestures
		else if (deltaX < -20) {
			player.moveLeft();
		} else if (deltaX > 20) {
			player.moveRight();
		}
	}
};
game.up = function (x, y, obj) {
	isDragging = false;
	if (player.isSprinting) {
		player.stopSprint();
	}
};
// Game update loop
game.update = function () {
	if (gameWon) return;
	// Update camera to follow player
	camera.targetX = player.x - 1024;
	camera.targetY = player.y - 1366;
	camera.x += (camera.targetX - camera.x) * camera.smoothing;
	camera.y += (camera.targetY - camera.y) * camera.smoothing;
	// Keep camera within level bounds
	if (camera.x < 0) camera.x = 0;
	if (camera.x > levelWidth - 2048) camera.x = levelWidth - 2048;
	if (camera.y < -500) camera.y = -500;
	if (camera.y > 0) camera.y = 0;
	// Apply camera offset to game
	game.x = -camera.x;
	game.y = -camera.y;
	// Check collision with enemies
	for (var i = 0; i < enemies.length; i++) {
		var enemy = enemies[i];
		if (player.intersects(enemy)) {
			LK.getSound('hit').play();
			LK.effects.flashScreen(0xFF0000, 500);
			LK.setTimeout(function () {
				LK.showGameOver();
			}, 500);
			return;
		}
	}
	// Check if player reached goal
	if (player.intersects(goal)) {
		gameWon = true;
		LK.effects.flashScreen(0x00FF00, 1000);
		LK.setTimeout(function () {
			LK.showYouWin();
		}, 1000);
		return;
	}
	// Check if player fell off the level
	if (player.y > groundLevel + 500) {
		LK.effects.flashScreen(0xFF0000, 500);
		LK.setTimeout(function () {
			LK.showGameOver();
		}, 500);
		return;
	}
};

===================================================================
--- original.js
+++ change.js
@@ -507,9 +507,9 @@
 						});
 					}
 				});
 				// Return to normal after blink
-				setTimeout(function () {
+				LK.setTimeout(function () {
 					self.setExpression('normal');
 				}, 300);
 				break;
 			case 'normal':