/**** 
* Plugins
****/ 
var tween = LK.import("@upit/tween.v1");
var storage = LK.import("@upit/storage.v1", {
	highScore: 0
});

/**** 
* Classes
****/ 
var Coin = Container.expand(function () {
	var self = Container.call(this);
	var coinGraphics = self.attachAsset('coin', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.width = coinGraphics.width;
	self.height = coinGraphics.height;
	self.collected = false;
	// Add light pulsing effect to make the coin shine
	function startPulseEffect() {
		tween(coinGraphics, {
			scaleX: 1.2,
			scaleY: 1.2,
			rotation: Math.PI * 0.25,
			alpha: 1.0
		}, {
			duration: 600,
			easing: tween.easeInOut,
			onFinish: function onFinish() {
				tween(coinGraphics, {
					scaleX: 0.9,
					scaleY: 0.9,
					rotation: -Math.PI * 0.25,
					alpha: 0.8
				}, {
					duration: 600,
					easing: tween.easeInOut,
					onFinish: startPulseEffect
				});
			}
		});
	}
	self.setup = function (lane) {
		self.y = GROUND_Y - self.height / 2; // Position coins on the ground
		self.lane = lane;
		self.speed = gameSpeed;
		// Add spinning animation for coin
		tween(coinGraphics, {
			rotation: Math.PI * 2
		}, {
			duration: 1500,
			easing: tween.linear,
			onFinish: function onFinish() {
				coinGraphics.rotation = 0;
				if (self.parent) {
					// Only restart if still in scene
					self.setup(lane);
				}
			}
		});
		// Start the pulsing shine effect
		startPulseEffect();
	};
	self.collect = function () {
		if (self.collected) return;
		self.collected = true;
		LK.getSound('collect').play();
		// Scale up and fade out effect with sparkle
		tween.stop(coinGraphics); // Stop any ongoing tweens
		// First make it flash bright
		tween(coinGraphics, {
			tint: 0xFFFFFF,
			scaleX: 1.5,
			scaleY: 1.5,
			rotation: Math.PI
		}, {
			duration: 200,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				// Then zoom up and fade out
				tween(self, {
					scaleX: 2.5,
					scaleY: 2.5,
					alpha: 0,
					y: self.y - 100
				}, {
					duration: 300,
					easing: tween.bounceOut,
					onFinish: function onFinish() {
						self.destroy();
					}
				});
			}
		});
	};
	self.update = function () {
		if (self.collected) return true;
		// No need to manually update x as it's handled by tween
		// Check if coin is off screen
		if (self.x < -self.width) {
			self.destroy();
			return true; // Return true if destroyed
		}
		return false; // Not destroyed
	};
	return self;
});
var Obstacle = Container.expand(function () {
	var self = Container.call(this);
	var type = "high"; // Default type
	var graphicsAsset;
	// Add subtle rotation animation to make obstacles more dynamic
	function addObstacleEffect() {
		// For high obstacles, add a more interesting wobble effect
		if (type === "high") {
			tween(graphicsAsset, {
				rotation: 0.08,
				scaleX: 1.03,
				alpha: 0.95
			}, {
				duration: 800,
				easing: tween.easeInOut,
				onFinish: function onFinish() {
					tween(graphicsAsset, {
						rotation: -0.08,
						scaleX: 0.97,
						alpha: 1.0
					}, {
						duration: 800,
						easing: tween.easeInOut,
						onFinish: addObstacleEffect
					});
				}
			});
		}
		// For low obstacles, add a more dynamic bounce effect
		else if (type === "low") {
			tween(graphicsAsset, {
				scaleY: 1.08,
				scaleX: 0.95,
				y: graphicsAsset.y - 5
			}, {
				duration: 400,
				easing: tween.easeInOut,
				onFinish: function onFinish() {
					tween(graphicsAsset, {
						scaleY: 0.97,
						scaleX: 1.03,
						y: graphicsAsset.y + 5
					}, {
						duration: 400,
						easing: tween.easeInOut,
						onFinish: addObstacleEffect
					});
				}
			});
		}
	}
	self.setup = function (obstacleType, lane) {
		type = obstacleType;
		if (self.children.length > 0) {
			self.removeChildren();
		}
		if (type === "high") {
			graphicsAsset = self.attachAsset('obstacle', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		} else if (type === "low") {
			graphicsAsset = self.attachAsset('lowObstacle', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		}
		self.width = graphicsAsset.width;
		self.height = graphicsAsset.height;
		// Calculate correct Y position based on type and lane - position all on ground
		if (type === "high") {
			self.y = GROUND_Y - self.height / 2; // High obstacles on the ground
		} else if (type === "low") {
			self.y = GROUND_Y - self.height / 2; // Low obstacles on the ground
		}
		self.lane = lane;
		self.type = type;
		self.speed = gameSpeed;
		// Add appear animation when obstacle is created
		graphicsAsset.scaleX = 0.1;
		graphicsAsset.scaleY = 0.1;
		graphicsAsset.alpha = 0.5;
		graphicsAsset.rotation = Math.PI * 0.25;
		tween(graphicsAsset, {
			scaleX: 1.1,
			scaleY: 1.1,
			alpha: 1.0,
			rotation: 0
		}, {
			duration: 300,
			easing: tween.elasticOut,
			onFinish: function onFinish() {
				// Add slight bounce back
				tween(graphicsAsset, {
					scaleX: 1.0,
					scaleY: 1.0
				}, {
					duration: 150,
					easing: tween.easeOut,
					onFinish: addObstacleEffect
				});
			}
		});
	};
	self.update = function () {
		// No need to manually update x as it's handled by tween
		// Check if obstacle is off screen
		if (self.x < -self.width) {
			tween.stop(graphicsAsset); // Stop any ongoing animations
			self.destroy();
			return true; // Return true if destroyed
		}
		return false; // Not destroyed
	};
	return self;
});
var Player = Container.expand(function () {
	var self = Container.call(this);
	var playerGraphics = self.attachAsset('player', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var playerJumpGraphics = LK.getAsset('playerJump', {
		anchorX: 0.5,
		anchorY: 0.5,
		visible: false
	});
	var playerSlideGraphics = LK.getAsset('playerSlide', {
		anchorX: 0.5,
		anchorY: 0.5,
		visible: false
	});
	self.addChild(playerJumpGraphics);
	self.addChild(playerSlideGraphics);
	self.width = playerGraphics.width;
	self.height = playerGraphics.height;
	self.lane = 1; // 0: top, 1: middle, 2: bottom
	self.isJumping = false;
	self.isSliding = false;
	self.isDead = false;
	self.jump = function () {
		if (self.isJumping || self.isDead) return;
		self.isJumping = true;
		LK.getSound('jump').play();
		// Show jump sprite, hide others
		playerGraphics.visible = false;
		playerSlideGraphics.visible = false;
		playerJumpGraphics.visible = true;
		// Add a small rotation effect for more dynamic jump
		playerJumpGraphics.rotation = -0.2;
		var startY = self.y;
		var jumpHeight = 250;
		// First stretch vertically to prepare for jump
		tween(playerJumpGraphics, {
			scaleY: 0.8,
			scaleX: 1.2
		}, {
			duration: 100,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				// Then perform the actual jump
				tween(self, {
					y: startY - jumpHeight,
					rotation: 0.2
				}, {
					duration: 350,
					easing: tween.easeOut,
					onFinish: function onFinish() {
						tween(self, {
							y: startY,
							rotation: 0
						}, {
							duration: 350,
							easing: tween.easeIn,
							onFinish: function onFinish() {
								self.isJumping = false;
								// Show normal sprite, hide others
								playerGraphics.visible = true;
								playerJumpGraphics.visible = false;
								playerSlideGraphics.visible = false;
								// Reset any scale changes
								playerJumpGraphics.scaleX = 1;
								playerJumpGraphics.scaleY = 1;
								playerJumpGraphics.rotation = 0;
							}
						});
					}
				});
			}
		});
	};
	self.slide = function () {
		if (self.isSliding || self.isDead) return;
		self.isSliding = true;
		// Show slide sprite, hide others
		playerGraphics.visible = false;
		playerJumpGraphics.visible = false;
		playerSlideGraphics.visible = true;
		// Add slide animation - stretch horizontally
		tween(playerSlideGraphics, {
			scaleX: 1.3,
			scaleY: 0.7
		}, {
			duration: 200,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				// Hold slide position
				tween(playerSlideGraphics, {
					scaleX: 1.2,
					scaleY: 0.8
				}, {
					duration: 200,
					easing: tween.linear
				});
			}
		});
		LK.setTimeout(function () {
			// End slide with slight bounce back to normal
			tween(playerSlideGraphics, {
				scaleX: 1.0,
				scaleY: 1.0
			}, {
				duration: 150,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					self.isSliding = false;
					// Show normal sprite, hide others
					playerGraphics.visible = true;
					playerJumpGraphics.visible = false;
					playerSlideGraphics.visible = false;
				}
			});
		}, 600);
	};
	self.changeLane = function (direction) {
		if (self.isDead) return;
		// Direction: -1 for up, 1 for down
		var newLane = self.lane + direction;
		if (newLane < 0 || newLane > 2) return;
		self.lane = newLane;
		var targetY = lanePositions[self.lane];
		tween(self, {
			y: targetY
		}, {
			duration: 200,
			easing: tween.easeOut
		});
	};
	self.die = function () {
		if (self.isDead) return;
		self.isDead = true;
		LK.getSound('hit').play();
		// Flash the player red
		LK.effects.flashObject(self, 0xff0000, 500);
		// Create dramatic death effect with multiple stages
		// First - impact effect
		tween(self, {
			scaleX: 1.3,
			scaleY: 0.7,
			rotation: 0.2
		}, {
			duration: 150,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				// Second - spin and fade
				tween(self, {
					rotation: Math.PI * 2,
					alpha: 0.6,
					scaleX: 0.7,
					scaleY: 0.7,
					y: self.y + 50
				}, {
					duration: 600,
					easing: tween.easeIn,
					onFinish: function onFinish() {
						// Final bounce
						tween(self, {
							y: self.y + 100,
							alpha: 0.3,
							rotation: Math.PI * 3,
							scaleX: 0.5,
							scaleY: 0.5
						}, {
							duration: 250,
							easing: tween.bounceOut
						});
					}
				});
			}
		});
		// Screen flash and game over with slight delay
		LK.effects.flashScreen(0xff0000, 300);
		LK.setTimeout(function () {
			LK.showGameOver();
		}, 1000);
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Game constants
var GAME_WIDTH = 2048;
var GAME_HEIGHT = 2732;
var lanePositions = [GAME_HEIGHT * 0.35, GAME_HEIGHT * 0.5, GAME_HEIGHT * 0.65];
var GROUND_Y = GAME_HEIGHT * 0.8;
var gameSpeed = 10;
var gameSpeedIncrement = 0.1;
var obstacleFrequency = 100; // Frames between obstacle generation
var coinFrequency = 150; // Frames between coin generation
var score = 0;
var distance = 0;
var isGameRunning = false;
// Game elements
var player;
var obstacles = [];
var coins = [];
var ground;
var ceiling;
var lastObstacleFrame = 0;
var lastCoinFrame = 0;
// GUI elements
var scoreTxt;
var distanceTxt;
var highScoreTxt;
// Game setup
function setupGame() {
	// Add background first so it's behind everything
	var background = game.addChild(LK.getAsset('background', {
		anchorX: 0,
		anchorY: 0,
		x: 0,
		y: 0
	}));
	// Create ground
	ground = game.addChild(LK.getAsset('ground', {
		anchorX: 0,
		anchorY: 0,
		x: 0,
		y: GROUND_Y
	}));
	// Create ceiling
	ceiling = game.addChild(LK.getAsset('ceiling', {
		anchorX: 0,
		anchorY: 0,
		x: 0,
		y: 0
	}));
	// Create player
	player = new Player();
	player.x = GAME_WIDTH * 0.2;
	player.y = GROUND_Y - player.height / 2; // Position player on the ground
	game.addChild(player);
	// Setup score text with shadow effect
	scoreTxt = new Text2('Score: 0', {
		size: 80,
		fill: 0xFFFFFF,
		stroke: 0x000000,
		strokeThickness: 5
	});
	scoreTxt.anchor.set(0, 0);
	scoreTxt.x = 50;
	scoreTxt.y = 50;
	LK.gui.top.addChild(scoreTxt);
	// Setup distance text with shadow effect
	distanceTxt = new Text2('Distance: 0m', {
		size: 80,
		fill: 0xFFFFFF,
		stroke: 0x000000,
		strokeThickness: 5
	});
	distanceTxt.anchor.set(0, 0);
	distanceTxt.x = 50;
	distanceTxt.y = 150;
	LK.gui.top.addChild(distanceTxt);
	// Setup high score text with shadow effect
	highScoreTxt = new Text2('High Score: ' + storage.highScore, {
		size: 80,
		fill: 0xFFD700,
		stroke: 0x000000,
		strokeThickness: 5
	});
	highScoreTxt.anchor.set(1, 0);
	highScoreTxt.x = GAME_WIDTH - 50;
	highScoreTxt.y = 50;
	LK.gui.top.addChild(highScoreTxt);
	// Reset game state
	score = 0;
	distance = 0;
	gameSpeed = 10;
	isGameRunning = true;
	// Start background music
	LK.playMusic('gameMusic');
}
// Create a new obstacle
function createObstacle() {
	var obstacle = new Obstacle();
	var lane = Math.floor(Math.random() * 3); // Random lane
	var type = Math.random() > 0.5 ? "high" : "low"; // Random type
	obstacle.setup(type, lane);
	obstacle.x = GAME_WIDTH + obstacle.width;
	game.addChild(obstacle);
	// Animate the obstacle coming towards the player
	var targetX = -obstacle.width; // Final position off the left side of the screen
	var duration = (GAME_WIDTH + obstacle.width * 2) / gameSpeed * 1000 / 60; // Duration based on game speed
	tween(obstacle, {
		x: targetX
	}, {
		duration: duration,
		easing: tween.linear
	});
	obstacles.push(obstacle);
	lastObstacleFrame = LK.ticks;
}
// Create a new coin
function createCoin() {
	var coin = new Coin();
	var lane = 0; // Lane doesn't matter as coins are on ground now, but we keep the parameter for consistency
	coin.setup(lane);
	coin.x = GAME_WIDTH + coin.width;
	game.addChild(coin);
	// Animate the coin coming towards the player
	var targetX = -coin.width; // Final position off the left side of the screen
	var duration = (GAME_WIDTH + coin.width * 2) / gameSpeed * 1000 / 60; // Duration based on game speed
	tween(coin, {
		x: targetX
	}, {
		duration: duration,
		easing: tween.linear
	});
	coins.push(coin);
	lastCoinFrame = LK.ticks;
}
// Check for collisions
function checkCollisions() {
	// Check obstacle collisions
	for (var i = 0; i < obstacles.length; i++) {
		var obstacle = obstacles[i];
		if (player.intersects(obstacle)) {
			// Check if player can pass:
			// - If jumping over high obstacle
			// - If sliding under low obstacle
			var canPass = false;
			if (obstacle.type === "high" && player.isJumping) {
				canPass = true;
			} else if (obstacle.type === "low" && player.isSliding) {
				canPass = true;
			} else if (player.lane !== obstacle.lane && obstacle.lane !== 0) {
				// Only consider lane difference if obstacle is not on ground level
				canPass = true;
			}
			if (!canPass) {
				player.die();
				isGameRunning = false;
				// Update high score
				if (score > storage.highScore) {
					storage.highScore = score;
					highScoreTxt.setText('High Score: ' + storage.highScore);
				}
			}
		}
	}
	// Check coin collisions
	for (var j = 0; j < coins.length; j++) {
		var coin = coins[j];
		if (!coin.collected && player.intersects(coin)) {
			coin.collect();
			score += 10;
			scoreTxt.setText('Score: ' + score);
		}
	}
}
// Update game function
function updateGame() {
	if (!isGameRunning) return;
	// Update distance and increase difficulty
	distance += Math.floor(gameSpeed / 10);
	distanceTxt.setText('Distance: ' + distance + 'm');
	// Increase game speed
	var oldSpeed = gameSpeed;
	// Speed increases faster after 100m
	if (distance > 100) {
		gameSpeed += gameSpeedIncrement * 0.03;
	} else {
		gameSpeed += gameSpeedIncrement * 0.01;
	}
	// If game speed changed significantly, update existing tweens
	if (gameSpeed > oldSpeed * 1.1) {
		// Update obstacle speeds
		for (var i = 0; i < obstacles.length; i++) {
			var obstacle = obstacles[i];
			// Stop current tween
			tween.stop(obstacle, {
				x: true
			});
			// Create new tween with updated speed
			var remainingDistance = obstacle.x + obstacle.width;
			var duration = remainingDistance / gameSpeed * 1000 / 60;
			tween(obstacle, {
				x: -obstacle.width
			}, {
				duration: duration,
				easing: tween.linear
			});
		}
		// Update coin speeds
		for (var j = 0; j < coins.length; j++) {
			var coin = coins[j];
			if (!coin.collected) {
				// Stop current tween
				tween.stop(coin, {
					x: true
				});
				// Create new tween with updated speed
				var coinRemainingDistance = coin.x + coin.width;
				var coinDuration = coinRemainingDistance / gameSpeed * 1000 / 60;
				tween(coin, {
					x: -coin.width
				}, {
					duration: coinDuration,
					easing: tween.linear
				});
			}
		}
	}
	// Generate obstacles
	if (LK.ticks - lastObstacleFrame > obstacleFrequency) {
		createObstacle();
		// Obstacles appear more frequently as the game progresses
		// After 100m, obstacles come much faster
		if (distance > 100) {
			obstacleFrequency = Math.max(30, 60 - Math.floor(distance / 200));
		} else {
			obstacleFrequency = Math.max(50, 100 - Math.floor(distance / 500));
		}
	}
	// Generate coins
	if (LK.ticks - lastCoinFrame > coinFrequency) {
		createCoin();
	}
	// Update obstacles
	for (var i = obstacles.length - 1; i >= 0; i--) {
		if (obstacles[i].update()) {
			obstacles.splice(i, 1);
		}
	}
	// Update coins
	for (var j = coins.length - 1; j >= 0; j--) {
		if (coins[j].update()) {
			coins.splice(j, 1);
		}
	}
	// Check for collisions
	checkCollisions();
}
// Handle swipe gestures
var startX = 0;
var startY = 0;
var isDragging = false;
var swipeThreshold = 50; // Minimum distance for a swipe
function handleDown(x, y, obj) {
	startX = x;
	startY = y;
	isDragging = true;
}
function handleMove(x, y, obj) {
	if (!isDragging || !isGameRunning) return;
	var deltaX = x - startX;
	var deltaY = y - startY;
	var absX = Math.abs(deltaX);
	var absY = Math.abs(deltaY);
	// Only process significant movements
	if (absX < swipeThreshold && absY < swipeThreshold) return;
	// Determine swipe direction
	if (absY > absX) {
		// Vertical swipe
		if (deltaY < 0) {
			// Swipe up - jump
			player.jump();
		} else {
			// Swipe down - slide
			player.slide();
		}
	} else {
		// Horizontal swipe
		if (deltaY < -swipeThreshold) {
			// Swipe up left/right - change lane up
			player.changeLane(-1);
		} else if (deltaY > swipeThreshold) {
			// Swipe down left/right - change lane down
			player.changeLane(1);
		}
	}
	// Reset for next swipe
	startX = x;
	startY = y;
}
function handleUp(x, y, obj) {
	isDragging = false;
}
// Set up event handlers
game.down = handleDown;
game.move = handleMove;
game.up = handleUp;
// Game update function
game.update = function () {
	// Initialize game on first update
	if (!player) {
		setupGame();
	}
	// Update game state
	updateGame();
};

===================================================================
--- original.js
+++ change.js
@@ -20,19 +20,23 @@
 	self.collected = false;
 	// Add light pulsing effect to make the coin shine
 	function startPulseEffect() {
 		tween(coinGraphics, {
-			scaleX: 1.1,
-			scaleY: 1.1
+			scaleX: 1.2,
+			scaleY: 1.2,
+			rotation: Math.PI * 0.25,
+			alpha: 1.0
 		}, {
-			duration: 500,
+			duration: 600,
 			easing: tween.easeInOut,
 			onFinish: function onFinish() {
 				tween(coinGraphics, {
-					scaleX: 1.0,
-					scaleY: 1.0
+					scaleX: 0.9,
+					scaleY: 0.9,
+					rotation: -Math.PI * 0.25,
+					alpha: 0.8
 				}, {
-					duration: 500,
+					duration: 600,
 					easing: tween.easeInOut,
 					onFinish: startPulseEffect
 				});
 			}
@@ -64,17 +68,31 @@
 		self.collected = true;
 		LK.getSound('collect').play();
 		// Scale up and fade out effect with sparkle
 		tween.stop(coinGraphics); // Stop any ongoing tweens
-		tween(self, {
-			scaleX: 2.0,
-			scaleY: 2.0,
-			alpha: 0
+		// First make it flash bright
+		tween(coinGraphics, {
+			tint: 0xFFFFFF,
+			scaleX: 1.5,
+			scaleY: 1.5,
+			rotation: Math.PI
 		}, {
-			duration: 400,
+			duration: 200,
 			easing: tween.easeOut,
 			onFinish: function onFinish() {
-				self.destroy();
+				// Then zoom up and fade out
+				tween(self, {
+					scaleX: 2.5,
+					scaleY: 2.5,
+					alpha: 0,
+					y: self.y - 100
+				}, {
+					duration: 300,
+					easing: tween.bounceOut,
+					onFinish: function onFinish() {
+						self.destroy();
+					}
+				});
 			}
 		});
 	};
 	self.update = function () {
@@ -94,36 +112,44 @@
 	var type = "high"; // Default type
 	var graphicsAsset;
 	// Add subtle rotation animation to make obstacles more dynamic
 	function addObstacleEffect() {
-		// For high obstacles, add a slight wobble
+		// For high obstacles, add a more interesting wobble effect
 		if (type === "high") {
 			tween(graphicsAsset, {
-				rotation: 0.05
+				rotation: 0.08,
+				scaleX: 1.03,
+				alpha: 0.95
 			}, {
 				duration: 800,
 				easing: tween.easeInOut,
 				onFinish: function onFinish() {
 					tween(graphicsAsset, {
-						rotation: -0.05
+						rotation: -0.08,
+						scaleX: 0.97,
+						alpha: 1.0
 					}, {
 						duration: 800,
 						easing: tween.easeInOut,
 						onFinish: addObstacleEffect
 					});
 				}
 			});
 		}
-		// For low obstacles, add a slight bounce
+		// For low obstacles, add a more dynamic bounce effect
 		else if (type === "low") {
 			tween(graphicsAsset, {
-				scaleY: 1.05
+				scaleY: 1.08,
+				scaleX: 0.95,
+				y: graphicsAsset.y - 5
 			}, {
 				duration: 400,
 				easing: tween.easeInOut,
 				onFinish: function onFinish() {
 					tween(graphicsAsset, {
-						scaleY: 1.0
+						scaleY: 0.97,
+						scaleX: 1.03,
+						y: graphicsAsset.y + 5
 					}, {
 						duration: 400,
 						easing: tween.easeInOut,
 						onFinish: addObstacleEffect
@@ -161,15 +187,29 @@
 		self.speed = gameSpeed;
 		// Add appear animation when obstacle is created
 		graphicsAsset.scaleX = 0.1;
 		graphicsAsset.scaleY = 0.1;
+		graphicsAsset.alpha = 0.5;
+		graphicsAsset.rotation = Math.PI * 0.25;
 		tween(graphicsAsset, {
-			scaleX: 1.0,
-			scaleY: 1.0
+			scaleX: 1.1,
+			scaleY: 1.1,
+			alpha: 1.0,
+			rotation: 0
 		}, {
 			duration: 300,
-			easing: tween.easeOut,
-			onFinish: addObstacleEffect
+			easing: tween.elasticOut,
+			onFinish: function onFinish() {
+				// Add slight bounce back
+				tween(graphicsAsset, {
+					scaleX: 1.0,
+					scaleY: 1.0
+				}, {
+					duration: 150,
+					easing: tween.easeOut,
+					onFinish: addObstacleEffect
+				});
+			}
 		});
 	};
 	self.update = function () {
 		// No need to manually update x as it's handled by tween
@@ -214,27 +254,46 @@
 		// Show jump sprite, hide others
 		playerGraphics.visible = false;
 		playerSlideGraphics.visible = false;
 		playerJumpGraphics.visible = true;
+		// Add a small rotation effect for more dynamic jump
+		playerJumpGraphics.rotation = -0.2;
 		var startY = self.y;
 		var jumpHeight = 250;
-		tween(self, {
-			y: startY - jumpHeight
+		// First stretch vertically to prepare for jump
+		tween(playerJumpGraphics, {
+			scaleY: 0.8,
+			scaleX: 1.2
 		}, {
-			duration: 350,
+			duration: 100,
 			easing: tween.easeOut,
 			onFinish: function onFinish() {
+				// Then perform the actual jump
 				tween(self, {
-					y: startY
+					y: startY - jumpHeight,
+					rotation: 0.2
 				}, {
 					duration: 350,
-					easing: tween.easeIn,
+					easing: tween.easeOut,
 					onFinish: function onFinish() {
-						self.isJumping = false;
-						// Show normal sprite, hide others
-						playerGraphics.visible = true;
-						playerJumpGraphics.visible = false;
-						playerSlideGraphics.visible = false;
+						tween(self, {
+							y: startY,
+							rotation: 0
+						}, {
+							duration: 350,
+							easing: tween.easeIn,
+							onFinish: function onFinish() {
+								self.isJumping = false;
+								// Show normal sprite, hide others
+								playerGraphics.visible = true;
+								playerJumpGraphics.visible = false;
+								playerSlideGraphics.visible = false;
+								// Reset any scale changes
+								playerJumpGraphics.scaleX = 1;
+								playerJumpGraphics.scaleY = 1;
+								playerJumpGraphics.rotation = 0;
+							}
+						});
 					}
 				});
 			}
 		});
@@ -245,14 +304,42 @@
 		// Show slide sprite, hide others
 		playerGraphics.visible = false;
 		playerJumpGraphics.visible = false;
 		playerSlideGraphics.visible = true;
+		// Add slide animation - stretch horizontally
+		tween(playerSlideGraphics, {
+			scaleX: 1.3,
+			scaleY: 0.7
+		}, {
+			duration: 200,
+			easing: tween.easeOut,
+			onFinish: function onFinish() {
+				// Hold slide position
+				tween(playerSlideGraphics, {
+					scaleX: 1.2,
+					scaleY: 0.8
+				}, {
+					duration: 200,
+					easing: tween.linear
+				});
+			}
+		});
 		LK.setTimeout(function () {
-			self.isSliding = false;
-			// Show normal sprite, hide others
-			playerGraphics.visible = true;
-			playerJumpGraphics.visible = false;
-			playerSlideGraphics.visible = false;
+			// End slide with slight bounce back to normal
+			tween(playerSlideGraphics, {
+				scaleX: 1.0,
+				scaleY: 1.0
+			}, {
+				duration: 150,
+				easing: tween.easeOut,
+				onFinish: function onFinish() {
+					self.isSliding = false;
+					// Show normal sprite, hide others
+					playerGraphics.visible = true;
+					playerJumpGraphics.visible = false;
+					playerSlideGraphics.visible = false;
+				}
+			});
 		}, 600);
 	};
 	self.changeLane = function (direction) {
 		if (self.isDead) return;
@@ -271,19 +358,48 @@
 	self.die = function () {
 		if (self.isDead) return;
 		self.isDead = true;
 		LK.getSound('hit').play();
+		// Flash the player red
 		LK.effects.flashObject(self, 0xff0000, 500);
-		// Create dramatic death effect
+		// Create dramatic death effect with multiple stages
+		// First - impact effect
 		tween(self, {
-			rotation: Math.PI,
-			alpha: 0.5,
-			scaleX: 0.8,
-			scaleY: 0.8
+			scaleX: 1.3,
+			scaleY: 0.7,
+			rotation: 0.2
 		}, {
-			duration: 800,
-			easing: tween.easeIn
+			duration: 150,
+			easing: tween.easeOut,
+			onFinish: function onFinish() {
+				// Second - spin and fade
+				tween(self, {
+					rotation: Math.PI * 2,
+					alpha: 0.6,
+					scaleX: 0.7,
+					scaleY: 0.7,
+					y: self.y + 50
+				}, {
+					duration: 600,
+					easing: tween.easeIn,
+					onFinish: function onFinish() {
+						// Final bounce
+						tween(self, {
+							y: self.y + 100,
+							alpha: 0.3,
+							rotation: Math.PI * 3,
+							scaleX: 0.5,
+							scaleY: 0.5
+						}, {
+							duration: 250,
+							easing: tween.bounceOut
+						});
+					}
+				});
+			}
 		});
+		// Screen flash and game over with slight delay
+		LK.effects.flashScreen(0xff0000, 300);
 		LK.setTimeout(function () {
 			LK.showGameOver();
 		}, 1000);
 	};
@@ -293,9 +409,9 @@
 /**** 
 * Initialize Game
 ****/ 
 var game = new LK.Game({
-	backgroundColor: 0x87CEEB
+	backgroundColor: 0x000000
 });
 
 /**** 
 * Game Code
@@ -351,30 +467,36 @@
 	player = new Player();
 	player.x = GAME_WIDTH * 0.2;
 	player.y = GROUND_Y - player.height / 2; // Position player on the ground
 	game.addChild(player);
-	// Setup score text
+	// Setup score text with shadow effect
 	scoreTxt = new Text2('Score: 0', {
 		size: 80,
-		fill: 0xFFFFFF
+		fill: 0xFFFFFF,
+		stroke: 0x000000,
+		strokeThickness: 5
 	});
 	scoreTxt.anchor.set(0, 0);
 	scoreTxt.x = 50;
 	scoreTxt.y = 50;
 	LK.gui.top.addChild(scoreTxt);
-	// Setup distance text
+	// Setup distance text with shadow effect
 	distanceTxt = new Text2('Distance: 0m', {
 		size: 80,
-		fill: 0xFFFFFF
+		fill: 0xFFFFFF,
+		stroke: 0x000000,
+		strokeThickness: 5
 	});
 	distanceTxt.anchor.set(0, 0);
 	distanceTxt.x = 50;
 	distanceTxt.y = 150;
 	LK.gui.top.addChild(distanceTxt);
-	// Setup high score text
+	// Setup high score text with shadow effect
 	highScoreTxt = new Text2('High Score: ' + storage.highScore, {
 		size: 80,
-		fill: 0xFFFFFF
+		fill: 0xFFD700,
+		stroke: 0x000000,
+		strokeThickness: 5
 	});
 	highScoreTxt.anchor.set(1, 0);
 	highScoreTxt.x = GAME_WIDTH - 50;
 	highScoreTxt.y = 50;