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

/**** 
* Classes
****/ 
var Bus = Container.expand(function () {
	var self = Container.call(this);
	var busSprite = self.attachAsset('bus', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.width = busSprite.width;
	self.height = busSprite.height;
	self.speed = 1; // All buses have the same base speed
	self.lane = 0; // 0-3 for the four road lanes
	self.update = function () {
		self.lastX = self.x;
		// Move vertically from top to bottom
		self.y += gameSpeed * self.speed;
		if (self.y > 2732 + self.height) {
			self.resetPosition();
		}
	};
	self.resetPosition = function () {
		// Reset to top of screen
		self.y = -self.height - Math.random() * 300;
		// Randomly assign to a lane
		self.lane = Math.floor(Math.random() * 4);
		self.x = roadPositions[self.lane];
	};
	return self;
});
var Coin = Container.expand(function () {
	var self = Container.call(this);
	var coinSprite = self.attachAsset('coin', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.width = coinSprite.width;
	self.height = coinSprite.height;
	self.lane = 1;
	// Coin animation (rotate)
	LK.setInterval(function () {
		tween(coinSprite, {
			rotation: coinSprite.rotation + Math.PI * 2
		}, {
			duration: 1000
		});
	}, 1000);
	self.update = function () {
		self.y += gameSpeed;
		if (self.y > 2732 + self.height) {
			self.destroy();
		}
	};
	return self;
});
var CoinParticle = Container.expand(function () {
	var self = Container.call(this);
	var coinSprite = self.attachAsset('coin', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 0.8,
		scaleY: 0.8
	});
	self.startX = 0;
	self.startY = 0;
	self.targetX = 0;
	self.targetY = 0;
	self.init = function (startX, startY, targetX, targetY) {
		self.x = startX;
		self.y = startY;
		self.startX = startX;
		self.startY = startY;
		self.targetX = targetX;
		self.targetY = targetY;
		// Add rotation to make coin spin while flying
		var rotateInterval = LK.setInterval(function () {
			coinSprite.rotation += 0.2;
		}, 16);
		// Create coin flight path animation with arc
		var controlPointX = startX + (targetX - startX) * 0.5;
		var controlPointY = startY - 200; // Arc upward
		var steps = 20; // Number of steps for the arc
		var stepDuration = 800 / steps; // Duration for each step
		// Animate along bezier curve
		function animateStep(i) {
			if (i >= steps) {
				// Animation complete
				LK.clearInterval(rotateInterval);
				// Flash the coin counter when coin arrives
				tween(coinTxt, {
					scaleX: 1.2,
					scaleY: 1.2
				}, {
					duration: 100,
					onFinish: function onFinish() {
						tween(coinTxt, {
							scaleX: 1,
							scaleY: 1
						}, {
							duration: 100
						});
					}
				});
				self.destroy();
				return;
			}
			var t = i / steps;
			// Quadratic bezier curve calculation
			var newX = (1 - t) * (1 - t) * startX + 2 * (1 - t) * t * controlPointX + t * t * targetX;
			var newY = (1 - t) * (1 - t) * startY + 2 * (1 - t) * t * controlPointY + t * t * targetY;
			tween(self, {
				x: newX,
				y: newY,
				scaleX: 0.8 - 0.3 * t,
				scaleY: 0.8 - 0.3 * t
			}, {
				duration: stepDuration,
				onFinish: function onFinish() {
					animateStep(i + 1);
				}
			});
		}
		// Start the animation
		animateStep(0);
	};
	return self;
});
var Lifesaver = Container.expand(function () {
	var self = Container.call(this);
	var lifesaverSprite = self.attachAsset('powerup', {
		anchorX: 0.5,
		anchorY: 0.5,
		tint: 0xFF0000 // Red color for lifesaver
	});
	self.width = lifesaverSprite.width;
	self.height = lifesaverSprite.height;
	self.lane = 1;
	// Pulsate animation with higher visibility
	function pulsate() {
		tween(lifesaverSprite, {
			scaleX: 1.3,
			scaleY: 1.3
		}, {
			duration: 400,
			onFinish: function onFinish() {
				tween(lifesaverSprite, {
					scaleX: 1,
					scaleY: 1
				}, {
					duration: 400,
					onFinish: pulsate
				});
			}
		});
	}
	pulsate();
	self.update = function () {
		self.y += gameSpeed;
		if (self.y > 2732 + self.height) {
			self.destroy();
		}
	};
	return self;
});
var MiniBus = Container.expand(function () {
	var self = Container.call(this);
	// Replace bus sprite with jumpboard
	var busSprite = self.attachAsset('jumpboard', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 1.5,
		scaleY: 1
	});
	self.width = busSprite.width * 1.5;
	self.height = busSprite.height;
	self.speed = 1.2; // Slightly faster than regular buses
	self.lane = 0; // 0-3 for the four road lanes
	// No need for green tint as we're using the jumping board asset now
	self.update = function () {
		self.lastX = self.x;
		// Move vertically from top to bottom
		self.y += gameSpeed * self.speed;
		if (self.y > 2732 + self.height) {
			self.resetPosition();
		}
	};
	self.resetPosition = function () {
		// Reset to top of screen with more randomization
		self.y = -self.height - Math.random() * 1200; // Increased random variance from 800 to 1200
		// Randomly assign to a lane
		self.lane = Math.floor(Math.random() * 4);
		self.x = roadPositions[self.lane];
		// Check for other jumping boards in this lane and ensure spacing
		var jumpingBoardsInLane = [];
		for (var i = 0; i < buses.length; i++) {
			if (buses[i] instanceof MiniBus && buses[i] !== self && buses[i].lane === self.lane) {
				jumpingBoardsInLane.push(buses[i]);
			}
		}
		// Ensure minimum spacing with other jumping boards in the same lane - increased spacing requirement
		for (var i = 0; i < jumpingBoardsInLane.length; i++) {
			var otherBoard = jumpingBoardsInLane[i];
			if (otherBoard.y < 0 && Math.abs(self.y - otherBoard.y) < self.height * 12) {
				// If too close to another jumping board, move much further up
				self.y = otherBoard.y - (self.height * 12 + Math.random() * 600);
			}
		}
	};
	return self;
});
var Obstacle = Container.expand(function () {
	var self = Container.call(this);
	// Create container for obstacle parts
	var obstacleContainer = new Container();
	self.addChild(obstacleContainer);
	// Create red obstacle (full obstacle is dangerous)
	var redPart = self.attachAsset('obstacle', {
		anchorX: 0.5,
		anchorY: 0.5,
		tint: 0xff0000,
		// Make obstacle red
		scaleY: 1.0
	});
	self.redPart = redPart;
	self.width = redPart.width;
	self.height = redPart.height;
	self.lane = 1;
	self.type = "normal"; // normal, low, high
	self.canSlideUnder = true; // All obstacles can be slid under
	self.setType = function (newType) {
		self.type = newType;
		// Keep consistent size regardless of type
		if (newType === "low") {
			// Just adjust position, not size
			self.y += self.height * 0.2;
		} else if (newType === "high") {
			// Just adjust position, not size
			self.y -= self.height * 0.2;
		}
	};
	// Check if player is colliding with red part
	self.isCollidingWithRedPart = function (player) {
		var redPartBounds = {
			top: self.y - redPart.height * 0.5,
			bottom: self.y + redPart.height * 0.5,
			left: self.x - redPart.width * 0.5,
			right: self.x + redPart.width * 0.5
		};
		var playerBounds = {
			top: player.y - player.height * 0.5,
			bottom: player.y + player.height * 0.5,
			left: player.x - player.width * 0.5,
			right: player.x + player.width * 0.5
		};
		return !(redPartBounds.right < playerBounds.left || redPartBounds.left > playerBounds.right || redPartBounds.bottom < playerBounds.top || redPartBounds.top > playerBounds.bottom);
	};
	self.update = function () {
		self.y += gameSpeed;
		if (self.y > 2732 + self.height) {
			self.destroy();
		}
	};
	return self;
});
var Player = Container.expand(function () {
	var self = Container.call(this);
	var playerSprite = self.attachAsset('player', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.width = playerSprite.width;
	self.height = playerSprite.height;
	self.lane = 1; // 0=left, 1=center, 2=right
	self.isJumping = false;
	self.isSliding = false;
	self.hasShield = false;
	self.jump = function () {
		if (!self.isJumping) {
			self.isJumping = true;
			var startY = self.y;
			LK.getSound('jump').play();
			tween(self, {
				y: startY - 300
			}, {
				duration: 550,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					tween(self, {
						y: startY
					}, {
						duration: 550,
						easing: tween.easeIn,
						onFinish: function onFinish() {
							self.isJumping = false;
						}
					});
				}
			});
		}
	};
	self.slide = function () {
		if (!self.isSliding && !self.isJumping) {
			self.isSliding = true;
			var originalHeight = playerSprite.height;
			tween(playerSprite, {
				scaleY: 0.5
			}, {
				duration: 250,
				onFinish: function onFinish() {
					LK.setTimeout(function () {
						tween(playerSprite, {
							scaleY: 1
						}, {
							duration: 250,
							onFinish: function onFinish() {
								self.isSliding = false;
							}
						});
					}, 600);
				}
			});
		}
	};
	self.moveLane = function (targetLane) {
		if (targetLane >= 0 && targetLane <= 3) {
			self.lane = targetLane;
			tween(self, {
				x: roadPositions[targetLane]
			}, {
				duration: 100,
				easing: tween.easeOut
			});
		}
	};
	self.activateShield = function () {
		self.hasShield = true;
		playerSprite.tint = 0x00FFFF;
		LK.setTimeout(function () {
			self.hasShield = false;
			playerSprite.tint = 0xFFFFFF;
		}, 5000);
	};
	self.update = function () {
		// Player logic updated in game update
	};
	return self;
});
var PlayerParticle = Container.expand(function () {
	var self = Container.call(this);
	var particleSprite = self.attachAsset('player', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 0.2 + Math.random() * 0.2,
		scaleY: 0.2 + Math.random() * 0.2
	});
	self.vx = 0;
	self.vy = 0;
	self.gravity = 0.2;
	self.friction = 0.98;
	self.lifespan = 1000;
	self.birthTime = Date.now();
	self.update = function () {
		// Apply physics
		self.vy += self.gravity;
		self.vx *= self.friction;
		self.vy *= self.friction;
		self.x += self.vx;
		self.y += self.vy;
		// Fade out based on lifespan
		var age = Date.now() - self.birthTime;
		var lifePercent = 1 - age / self.lifespan;
		if (lifePercent <= 0) {
			self.destroy();
			return;
		}
		particleSprite.alpha = lifePercent;
	};
	return self;
});
var PowerUp = Container.expand(function () {
	var self = Container.call(this);
	var powerupSprite = self.attachAsset('powerup', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.width = powerupSprite.width;
	self.height = powerupSprite.height;
	self.lane = 1;
	self.type = "shield"; // shield, magnet, slowdown
	// Pulsate animation
	function pulsate() {
		tween(powerupSprite, {
			scaleX: 1.2,
			scaleY: 1.2
		}, {
			duration: 500,
			onFinish: function onFinish() {
				tween(powerupSprite, {
					scaleX: 1,
					scaleY: 1
				}, {
					duration: 500,
					onFinish: pulsate
				});
			}
		});
	}
	pulsate();
	self.setType = function (newType) {
		self.type = newType;
		if (newType === "shield") {
			powerupSprite.tint = 0x00FFFF; // Blue color
			// Position shield powerups higher on the screen
			self.y -= 400; // Increased from 200 to 400 to position higher
		} else if (newType === "magnet") {
			powerupSprite.tint = 0xFF00FF;
		} else if (newType === "slowdown") {
			powerupSprite.tint = 0x00FF00;
		}
	};
	self.update = function () {
		self.y += gameSpeed;
		if (self.y > 2732 + self.height) {
			self.destroy();
		}
	};
	return self;
});
var RoadLine = Container.expand(function () {
	var self = Container.call(this);
	var lineSprite = self.attachAsset('road_line', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.width = lineSprite.width;
	self.height = lineSprite.height;
	self.lane = 0; // 0-3 for the four road lanes
	self.update = function () {
		// Road lines remain stationary
	};
	self.resetPosition = function () {
		// No reset needed as lines are now stationary
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Game variables
var player;
var obstacles = [];
var coins = [];
var powerups = [];
var buses = [];
var roadLines = [];
var lifesavers = [];
var ground;
var gameSpeed = 5;
var initialGameSpeed = 5;
var maxGameSpeed = 15;
var speedIncreaseInterval;
var gameStarted = false;
var distanceTraveled = 0;
var score = 0;
var coinValue = 10;
var highScore = storage.highScore || 0;
var hasMagnet = false;
var magnetRange = 200;
var hasLifesaver = false;
var lifesaverSpawnInterval;
// Define the 4 road positions (vertical lanes)
var roadWidth = 2048 / 4;
var roadPositions = [roadWidth * 0.5, roadWidth * 1.5, roadWidth * 2.5, roadWidth * 3.5];
// Lane positions for player, obstacles and collectibles
var laneX = [roadPositions[0], roadPositions[1], roadPositions[2], roadPositions[3]];
// UI elements
var coinCount = storage.coinCount || 0;
var coinTxt = new Text2('COINS: 0', {
	size: 60,
	fill: 0xFFD700 // Gold color for coins
});
coinTxt.anchor.set(0, 0);
LK.gui.topRight.addChild(coinTxt);
coinTxt.x = -coinTxt.width - 20;
coinTxt.y = 20;
// Leaderboard display
var leaderboardTitle = new Text2('TOP PLAYERS', {
	size: 50,
	fill: 0xFFFFFF
});
leaderboardTitle.anchor.set(0, 0);
LK.gui.topLeft.addChild(leaderboardTitle);
leaderboardTitle.x = 120; // Leave space for platform menu icon
leaderboardTitle.y = 20;
// Create text elements for each leaderboard entry
var leaderboardEntries = [];
for (var i = 0; i < 3; i++) {
	var entryText = new Text2(i + 1 + '. ---: 0', {
		size: 40,
		fill: 0xFFFFFF
	});
	entryText.anchor.set(0, 0);
	LK.gui.topLeft.addChild(entryText);
	entryText.x = 120; // Leave space for platform menu icon
	entryText.y = 80 + i * 50;
	leaderboardEntries.push(entryText);
}
// Initialize leaderboard
updateLeaderboard();
var scoreTxt = new Text2('SCORE: 0', {
	size: 60,
	fill: 0xFFFFFF
});
scoreTxt.anchor.set(0, 0);
LK.gui.topRight.addChild(scoreTxt);
scoreTxt.x = -scoreTxt.width - 20;
scoreTxt.y = 90; // Move down to make room for coin counter
var distanceTxt = new Text2('DISTANCE: 0m', {
	size: 60,
	fill: 0xFFFFFF
});
distanceTxt.anchor.set(0, 0);
LK.gui.topRight.addChild(distanceTxt);
distanceTxt.x = -distanceTxt.width - 20;
distanceTxt.y = 160; // Adjusted to make room for coin and score
var highScoreTxt = new Text2('BEST: ' + highScore, {
	size: 50,
	fill: 0xFFFFFF
});
highScoreTxt.anchor.set(0, 0);
LK.gui.topRight.addChild(highScoreTxt);
highScoreTxt.x = -highScoreTxt.width - 20;
highScoreTxt.y = 230; // Adjusted to make room for coin and score
var startTxt = new Text2('SWIPE TO START', {
	size: 100,
	fill: 0xFFFFFF
});
startTxt.anchor.set(0.5, 0.5);
LK.gui.center.addChild(startTxt);
// Game initialization functions
function initializeGame() {
	// Create gray ground/background
	game.setBackgroundColor(0x777777);
	ground = game.addChild(LK.getAsset('ground', {
		anchorX: 0.5,
		anchorY: 0.5
	}));
	ground.x = 2048 / 2;
	ground.y = 2732 / 2;
	// Create 4 vertical roads with no gaps between them
	var roadWidth = 2048 / 4; // Divide screen width into 4 equal parts
	for (var i = 0; i < 4; i++) {
		var road = game.addChild(LK.getAsset('road', {
			anchorX: 0.5,
			anchorY: 0.5,
			width: roadWidth,
			// Set width to exactly 1/4 of screen
			height: 2732 // Full screen height
		}));
		road.x = roadWidth * i + roadWidth / 2; // Position roads side by side with no gaps
		road.y = 2732 / 2;
	}
	// Create road lines as vertical marks down the roads
	var roadWidth = 2048 / 4; // Width of each road
	for (var i = 0; i < 4; i++) {
		for (var j = 0; j < 15; j++) {
			var roadLine = new RoadLine();
			roadLine.lane = i;
			roadLine.x = roadWidth * i + roadWidth / 2; // Center in each road
			roadLine.y = j * 200; // Distribute lines vertically
			roadLines.push(roadLine);
			game.addChild(roadLine);
		}
	}
	// Create player
	player = game.addChild(new Player());
	player.lane = 1; // Start in second lane
	player.x = roadPositions[player.lane]; // Position player horizontally on the road
	player.y = 2732 - 500; // Position player higher on the screen
	// Create regular buses
	for (var i = 0; i < 6; i++) {
		var bus = new Bus();
		bus.lane = Math.floor(Math.random() * 4);
		bus.x = roadPositions[bus.lane];
		// Position buses with enough space between them vertically
		var offset = i * (bus.height + 300);
		bus.y = -offset - bus.height;
		// Make sure buses in the same lane don't overlap
		for (var j = 0; j < buses.length; j++) {
			if (bus.lane === buses[j].lane && Math.abs(bus.y - buses[j].y) < bus.height + buses[j].height) {
				// Move this bus further up to avoid overlap
				bus.y = buses[j].y - (bus.height + 300);
			}
		}
		buses.push(bus);
		game.addChild(bus);
	}
	// Create jumping boards (previously mini buses)
	var miniBuses = [];
	for (var i = 0; i < 4; i++) {
		var miniBus = new MiniBus();
		miniBus.lane = Math.floor(Math.random() * 4);
		miniBus.x = roadPositions[miniBus.lane];
		// Position jumping boards with significantly more space between them
		var offset = i * (miniBus.height + 800); // Increased vertical spacing between boards from 400 to 800
		miniBus.y = -offset - miniBus.height - 500;
		// Make sure jumping boards don't overlap with regular buses
		for (var j = 0; j < buses.length; j++) {
			if (miniBus.lane === buses[j].lane && Math.abs(miniBus.y - buses[j].y) < miniBus.height + buses[j].height) {
				miniBus.y = buses[j].y - (miniBus.height + 600); // Increased separation from 400 to 600
			}
		}
		// Check spacing with other jumping boards that were already created
		for (var j = 0; j < miniBuses.length; j++) {
			if (miniBus.lane === miniBuses[j].lane && Math.abs(miniBus.y - miniBuses[j].y) < miniBus.height * 6) {
				// If too close to another jumping board in the same lane, move it further up
				miniBus.y = miniBuses[j].y - miniBus.height * 6;
			}
		}
		miniBuses.push(miniBus);
		buses.push(miniBus); // Add to main buses array for updates
		game.addChild(miniBus);
	}
	// Initialize variables
	obstacles = []; // Keep empty as we don't use obstacles at all
	coins = [];
	powerups = [];
	gameSpeed = initialGameSpeed;
	distanceTraveled = 0;
	score = 0;
	// Don't reset coinCount here to preserve coins between game sessions
	updateUI();
	// No reset coins button - removed as requested
}
function startGame() {
	gameStarted = true;
	LK.setScore(0);
	// Load persistent coin count from storage
	coinCount = storage.coinCount || coinCount;
	startTxt.visible = false;
	// Start increasing game speed over time
	speedIncreaseInterval = LK.setInterval(function () {
		if (gameSpeed < maxGameSpeed) {
			gameSpeed += 0.5;
			// Update all buses to have the same speed when game speed changes
			for (var i = 0; i < buses.length; i++) {
				buses[i].speed = 1; // Keep all buses at same speed when the game speeds up
			}
		}
	}, 10000);
	// Start spawning only coins and powerups (no obstacles)
	spawnCoins();
	spawnPowerups();
	// Reset lifesaver state
	hasLifesaver = false;
	lifesavers = [];
	// Play background music
	LK.playMusic('bgmusic');
}
function updateUI() {
	coinTxt.setText('COINS: ' + coinCount);
	coinTxt.x = -coinTxt.width - 20;
	scoreTxt.setText('SCORE: ' + score);
	scoreTxt.x = -scoreTxt.width - 20;
	var distance = Math.floor(distanceTraveled / 10);
	distanceTxt.setText('DISTANCE: ' + distance + 'm');
	distanceTxt.x = -distanceTxt.width - 20;
	highScoreTxt.setText('BEST: ' + highScore);
	highScoreTxt.x = -highScoreTxt.width - 20;
	// Save coin count to storage when UI is updated to persist between sessions
	storage.coinCount = coinCount;
}
function updateLeaderboard() {
	// Get leaderboard from storage or create empty array if none exists
	var leaderboard = storage.leaderboard || [];
	// Update entries in UI
	for (var i = 0; i < 3; i++) {
		if (i < leaderboard.length) {
			var entry = leaderboard[i];
			var parts = entry.split(":");
			var playerName = parts[0];
			var score = parts[1];
			leaderboardEntries[i].setText(i + 1 + '. ' + playerName + ': ' + score);
		} else {
			leaderboardEntries[i].setText(i + 1 + '. ---: 0');
		}
	}
}
function addToLeaderboard(newScore) {
	// Get leaderboard from storage or create empty array if none exists
	var leaderboard = storage.leaderboard || [];
	// Generate a player name (could be replaced with actual player names in a real game)
	var playerName = "Player" + Math.floor(Math.random() * 100);
	// Add new score - store as separate entries to avoid nesting objects
	leaderboard.push(playerName + ":" + newScore);
	// Sort leaderboard by score (descending) - parse scores from string format
	leaderboard.sort(function (a, b) {
		var scoreA = parseInt(a.split(":")[1]);
		var scoreB = parseInt(b.split(":")[1]);
		return scoreB - scoreA;
	});
	// Keep only top entries
	if (leaderboard.length > 10) {
		leaderboard = leaderboard.slice(0, 10);
	}
	// Save back to storage
	storage.leaderboard = leaderboard;
	// Update UI
	updateLeaderboard();
}
// Object spawning functions
function spawnObstacles() {
	// Function is empty because we don't want to spawn any obstacles
	// Only jumping boards (MiniBus objects) will be used as obstacles
}
function spawnCoins() {
	var coinTimer = LK.setInterval(function () {
		if (!gameStarted) return;
		// Random coin pattern
		var pattern = Math.floor(Math.random() * 4);
		if (pattern === 0) {
			// Single coin
			var lane = Math.floor(Math.random() * 4);
			spawnCoin(lane);
		} else if (pattern === 1) {
			// Vertical line of coins
			var lane = Math.floor(Math.random() * 4);
			for (var i = 0; i < 3; i++) {
				var coin = new Coin();
				coin.lane = lane;
				coin.x = roadPositions[lane];
				coin.y = -coin.height - i * 120;
				coins.push(coin);
				game.addChild(coin);
			}
		} else if (pattern === 2) {
			// Horizontal line of coins
			for (var i = 0; i < 4; i++) {
				spawnCoin(i);
			}
		} else {
			// Diagonal line of coins
			for (var i = 0; i < 4; i++) {
				var coin = new Coin();
				coin.lane = i;
				coin.x = roadPositions[i];
				coin.y = -coin.height - i * 120;
				coins.push(coin);
				game.addChild(coin);
			}
		}
	}, 3000);
}
function spawnCoin(lane) {
	var coin = new Coin();
	coin.lane = lane;
	coin.x = roadPositions[lane];
	coin.y = -coin.height;
	// Check if there are buses in this lane near spawn point
	var busInLane = false;
	for (var i = 0; i < buses.length; i++) {
		if (buses[i].lane === lane && buses[i].y < 0 && buses[i].y > -300) {
			busInLane = true;
			break;
		}
	}
	// Only spawn coins if there's no bus in this lane
	if (!busInLane) {
		// Increased chance to spawn additional coins if in lane 1 (correct lane)
		if (lane === 1 && Math.random() < 0.9) {
			// Increased probability from 0.7 to 0.9
			// Add extra coins in a vertical line in the correct lane
			for (var i = 1; i < 6; i++) {
				// Increased from 4 to 6 coins in a row
				var extraCoin = new Coin();
				extraCoin.lane = lane;
				extraCoin.x = roadPositions[lane];
				extraCoin.y = -coin.height - i * 100; // Reduced spacing for more coins
				coins.push(extraCoin);
				game.addChild(extraCoin);
			}
		}
		coins.push(coin);
		game.addChild(coin);
	}
}
function spawnPowerups() {
	var powerupTimer = LK.setInterval(function () {
		if (!gameStarted) return;
		var powerup = new PowerUp();
		powerup.lane = Math.floor(Math.random() * 4);
		// Check if there's already an obstacle or powerup in this lane near spawn point
		var canSpawn = true;
		for (var i = 0; i < obstacles.length; i++) {
			if (obstacles[i].lane === powerup.lane && obstacles[i].y < 0) {
				canSpawn = false;
				break;
			}
		}
		for (var i = 0; i < powerups.length; i++) {
			if (powerups[i].lane === powerup.lane && powerups[i].y < 0) {
				canSpawn = false;
				break;
			}
		}
		if (!canSpawn) return;
		powerup.x = roadPositions[powerup.lane];
		powerup.y = -powerup.height;
		// Randomize powerup type
		var types = ["shield", "magnet", "slowdown"];
		var randomType = types[Math.floor(Math.random() * types.length)];
		powerup.setType(randomType);
		powerups.push(powerup);
		game.addChild(powerup);
	}, 15000); // Powerups appear less frequently
	// Start lifesaver spawning
	lifesaverSpawnInterval = LK.setInterval(function () {
		if (!gameStarted) return;
		// Only spawn if player doesn't already have a lifesaver
		if (!hasLifesaver) {
			var lifesaver = new Lifesaver();
			lifesaver.lane = Math.floor(Math.random() * 4);
			// Use a lane that has less obstacles if possible
			var laneCounts = [0, 0, 0, 0];
			for (var i = 0; i < buses.length; i++) {
				if (buses[i].y < 0) {
					laneCounts[buses[i].lane]++;
				}
			}
			// Find lane with fewest obstacles
			var minCount = 999;
			var bestLane = lifesaver.lane;
			for (var i = 0; i < 4; i++) {
				if (laneCounts[i] < minCount) {
					minCount = laneCounts[i];
					bestLane = i;
				}
			}
			// 70% chance to use the best lane
			if (Math.random() < 0.7) {
				lifesaver.lane = bestLane;
			}
			lifesaver.x = roadPositions[lifesaver.lane];
			lifesaver.y = -lifesaver.height;
			lifesavers.push(lifesaver);
			game.addChild(lifesaver);
		}
	}, 20000); // Lifesavers appear less frequently than regular powerups
}
// Function to reset all coins in the game (only visual coins, not the count)
function resetCoins() {
	// Remove all existing coins on screen
	for (var i = coins.length - 1; i >= 0; i--) {
		coins[i].destroy();
	}
	coins = [];
	// Ensure we're keeping the coin count persistent
	storage.coinCount = coinCount;
	updateUI();
}
// Game mechanics functions
function checkCollisions() {
	// No obstacle collisions to check since we're not spawning obstacles anymore
	// Only jumping boards (MiniBus objects) are used as obstacles
	// Check bus collisions
	for (var i = buses.length - 1; i >= 0; i--) {
		var bus = buses[i];
		// Check for bus-to-bus collisions
		for (var j = 0; j < buses.length; j++) {
			if (i !== j && bus.lane === buses[j].lane && Math.abs(bus.y - buses[j].y) < (bus.height + buses[j].height) * 0.8) {
				// Prevent overlap by repositioning this bus
				bus.y = buses[j].y - (bus.height + buses[j].height);
				if (bus.y > 2732 + bus.height) {
					bus.resetPosition();
				}
			}
		}
		// Check for bus-to-obstacle collisions
		for (var j = 0; j < obstacles.length; j++) {
			if (bus.lane === obstacles[j].lane && Math.abs(bus.y - obstacles[j].y) < (bus.height + obstacles[j].height) * 0.8) {
				// Prevent overlap by repositioning this bus
				bus.y = obstacles[j].y - (bus.height + obstacles[j].height);
				if (bus.y > 2732 + bus.height) {
					bus.resetPosition();
				}
			}
		}
		// Ensure at least one free lane is available at all times
		// First count how many lanes have buses in the player's vicinity
		var busesNearPlayer = [0, 0, 0, 0]; // Count of buses in each lane
		for (var j = 0; j < buses.length; j++) {
			var nearBus = buses[j];
			// Only count buses that are close to the player vertically
			if (Math.abs(nearBus.y - player.y) < 600) {
				busesNearPlayer[nearBus.lane]++;
			}
		}
		// If all lanes have buses near the player, move one bus to ensure a free lane
		var totalBlockedLanes = (busesNearPlayer[0] > 0 ? 1 : 0) + (busesNearPlayer[1] > 0 ? 1 : 0) + (busesNearPlayer[2] > 0 ? 1 : 0) + (busesNearPlayer[3] > 0 ? 1 : 0);
		if (totalBlockedLanes >= 3) {
			// More aggressive clearing - if 3 or more lanes are blocked
			// Find a lane that's different from player's current lane to free up
			var laneToFree = (player.lane + 2) % 4; // Pick lane opposite to player
			// Make sure this lane is completely clear by moving ALL buses in this lane
			for (var j = 0; j < buses.length; j++) {
				if (buses[j].lane === laneToFree && Math.abs(buses[j].y - player.y) < 800) {
					// Increased range
					buses[j].resetPosition(); // Move this bus away
					// Add additional space to ensure safety
					buses[j].y -= Math.random() * 500;
				}
			}
		}
		// Check player collision with bus
		if (player.lane === bus.lane && Math.abs(player.y - bus.y) < (player.height + bus.height) / 2) {
			// Check if it's a jumping board that can be jumped over
			if (bus instanceof MiniBus && player.isJumping) {
				continue; // Player successfully jumped over the jumping board
			}
			// Check if player can jump over the jumping board
			if (bus instanceof MiniBus) {
				// Track jumping boards approaching player
				if (bus.y < player.y && bus.y > player.y - 400) {
					// No highlighting needed
				}
			}
			// Check if player has shield
			if (player.hasShield) {
				player.hasShield = false;
				player.tint = 0xFFFFFF;
				continue;
			}
			// Flash warning when player is about to collide with a bus
			if (!player.warningShown && bus.y < player.y && bus.y > player.y - 300) {
				player.warningShown = true;
				// Flash the player to warn of incoming danger
				var flashCount = 0;
				var warningInterval = LK.setInterval(function () {
					player.alpha = player.alpha === 1 ? 0.5 : 1;
					flashCount++;
					if (flashCount >= 6) {
						LK.clearInterval(warningInterval);
						player.alpha = 1;
						// Reset warning after a delay
						LK.setTimeout(function () {
							player.warningShown = false;
						}, 1000);
					}
				}, 100);
			}
			// Collision occurred
			createPlayerParticles();
			gameOver();
			break;
		}
	}
	// Check coin collections
	for (var i = coins.length - 1; i >= 0; i--) {
		var coin = coins[i];
		// Track the last position of the coin relative to player
		if (coin.lastRelativeY === undefined) {
			coin.lastRelativeY = coin.y - player.y;
		}
		var currentRelativeY = coin.y - player.y;
		// Regular collection - Only collect when coin passes directly over player
		if (player.lane === coin.lane && coin.lastRelativeY < 0 && currentRelativeY >= 0 && Math.abs(player.x - coin.x) < (player.width + coin.width) / 2) {
			// Coin just passed over the player (crossed from above to below)
			collectCoin(coin, i);
		}
		// Magnet effect collection
		else if (hasMagnet && Math.sqrt(Math.pow(player.x - coin.x, 2) + Math.pow(player.y - coin.y, 2)) < magnetRange) {
			tween(coin, {
				x: player.x,
				y: player.y
			}, {
				duration: 200,
				onFinish: function onFinish() {
					collectCoin(coin, i);
				}
			});
		}
		// Update last relative position
		coin.lastRelativeY = currentRelativeY;
	}
	// Check powerup collections
	for (var i = powerups.length - 1; i >= 0; i--) {
		var powerup = powerups[i];
		// No obstacles to check for overlap with powerups
		// Check if powerup is about to overlap with other powerups
		if (i >= 0 && powerups[i]) {
			for (var j = 0; j < powerups.length; j++) {
				if (i !== j && powerup.lane === powerups[j].lane && Math.abs(powerup.y - powerups[j].y) < (powerup.height + powerups[j].height) / 2) {
					// Remove this powerup to prevent overlap
					powerups.splice(i, 1);
					powerup.destroy();
					i--;
					break;
				}
			}
		}
		if (i < 0 || !powerups[i]) continue;
		powerup = powerups[i];
		if (player.lane === powerup.lane && Math.abs(player.x - powerup.x) < (player.width + powerup.width) / 2) {
			// Apply powerup effect
			if (powerup.type === "shield") {
				player.activateShield();
			} else if (powerup.type === "magnet") {
				activateMagnet();
			} else if (powerup.type === "slowdown") {
				slowDownGame();
			}
			LK.getSound('powerup_collect').play();
			score += 30;
			LK.setScore(score);
			updateUI();
			powerups.splice(i, 1);
			powerup.destroy();
		}
	}
	// Check lifesaver collections
	for (var i = lifesavers.length - 1; i >= 0; i--) {
		var lifesaver = lifesavers[i];
		// Check if player collects the lifesaver
		if (player.lane === lifesaver.lane && Math.abs(player.y - lifesaver.y) < (player.height + lifesaver.height) / 2) {
			// Apply lifesaver effect
			hasLifesaver = true;
			// Visual indicator that player has a lifesaver
			var indicator = new Text2("❤️", {
				size: 60,
				fill: 0xFF0000
			});
			indicator.anchor.set(0.5, 0.5);
			player.addChild(indicator);
			indicator.y = -player.height / 2 - 30;
			// Save the indicator for later removal
			player.lifesaverIndicator = indicator;
			LK.getSound('powerup_collect').play();
			score += 50;
			LK.setScore(score);
			updateUI();
			// Remove the collected lifesaver
			lifesavers.splice(i, 1);
			lifesaver.destroy();
		}
	}
}
function collectCoin(coin, index) {
	LK.getSound('coin_collect').play();
	score += coinValue;
	coinCount++;
	LK.setScore(score);
	// Get the global position of the coin
	var coinPos = {
		x: coin.x,
		y: coin.y
	};
	// Get the global position of the coin counter
	var counterPos = {
		x: LK.gui.topRight.x - coinTxt.width / 2,
		y: LK.gui.topRight.y + coinTxt.height / 2
	};
	// Adjust to make sure coins fly exactly to the counter
	counterPos.x -= 200;
	counterPos.y += 20;
	// Create flying coin animation with rotation
	var coinParticle = new CoinParticle();
	game.addChild(coinParticle);
	coinParticle.init(coinPos.x, coinPos.y, counterPos.x, counterPos.y);
	// Make sure the coin exists before trying to remove it
	if (index >= 0 && index < coins.length && coins[index]) {
		coins.splice(index, 1);
		coin.destroy();
	} else if (coin) {
		// If index is invalid but we have a coin reference, just destroy it
		// and remove it from the coins array if found
		coin.destroy();
		var coinIndex = coins.indexOf(coin);
		if (coinIndex >= 0) {
			coins.splice(coinIndex, 1);
		}
	}
	updateUI();
}
function activateMagnet() {
	hasMagnet = true;
	LK.setTimeout(function () {
		hasMagnet = false;
	}, 10000);
}
function slowDownGame() {
	var originalSpeed = gameSpeed;
	gameSpeed = gameSpeed / 2;
	LK.setTimeout(function () {
		gameSpeed = originalSpeed;
	}, 5000);
}
function createPlayerParticles() {
	// Create particle explosion effect at player position
	var particleCount = 20;
	var particles = [];
	for (var i = 0; i < particleCount; i++) {
		var particle = new PlayerParticle();
		game.addChild(particle);
		particle.x = player.x;
		particle.y = player.y;
		// Random direction
		var angle = Math.random() * Math.PI * 2;
		var speed = 2 + Math.random() * 5;
		particle.vx = Math.cos(angle) * speed;
		particle.vy = Math.sin(angle) * speed;
		// Random rotation and scale for variety
		particle.rotation = Math.random() * Math.PI * 2;
		// Set random lifespan
		particle.lifespan = 800 + Math.random() * 1200;
		particle.birthTime = Date.now();
		// Add to particles array for tracking
		particles.push(particle);
	}
	// Hide the original player
	player.visible = false;
}
function gameOver() {
	// Check if player has a lifesaver
	if (hasLifesaver) {
		// Use the lifesaver instead of ending the game
		hasLifesaver = false;
		// Play sound for using lifesaver
		LK.getSound('powerup_collect').play();
		// Remove indicator if it exists
		if (player.lifesaverIndicator) {
			player.lifesaverIndicator.destroy();
			player.lifesaverIndicator = null;
		}
		// Make player temporarily invincible
		player.hasShield = true;
		player.tint = 0x00FFFF;
		// Flash player to indicate invincibility
		var flashCount = 0;
		var flashInterval = LK.setInterval(function () {
			player.visible = !player.visible;
			flashCount++;
			if (flashCount >= 10) {
				LK.clearInterval(flashInterval);
				player.visible = true;
				player.hasShield = false;
				player.tint = 0xFFFFFF;
			}
		}, 100);
		// Move player to a safe lane
		var safeLane = findSafeLane();
		player.moveLane(safeLane);
		// Add bonus score for using lifesaver
		score += 100;
		LK.setScore(score);
		updateUI();
		return; // Don't trigger actual game over
	}
	LK.getSound('crash').play();
	// Update high score if needed
	if (score > highScore) {
		highScore = score;
		storage.highScore = highScore;
	}
	// Save final coin count to ensure it persists after game over
	storage.coinCount = coinCount;
	// Update leaderboard with current score
	addToLeaderboard(score);
	// Clear intervals
	LK.clearInterval(speedIncreaseInterval);
	// Make player visible again if it was hidden
	player.visible = true;
	// Create a character growth animation before game over
	// First, bring player to the center of screen
	tween(player, {
		x: 2048 / 2,
		y: 2732 / 2
	}, {
		duration: 500,
		easing: tween.easeOut,
		onFinish: function onFinish() {
			// Once centered, grow the character to fill the screen
			tween(player, {
				scaleX: 20,
				// Make even larger to completely fill screen
				scaleY: 20,
				// Make even larger to completely fill screen
				rotation: Math.PI * 2,
				alpha: 0.9 // More visible
			}, {
				duration: 2000,
				// Longer duration for more dramatic effect
				easing: tween.elasticOut,
				onFinish: function onFinish() {
					// Now show game over after animation completes
					LK.showGameOver();
				}
			});
		}
	});
}
// Helper function to find the safest lane
function findSafeLane() {
	// Count objects in each lane near the player
	var laneDanger = [0, 0, 0, 0];
	// Check buses in each lane
	for (var i = 0; i < buses.length; i++) {
		if (Math.abs(buses[i].y - player.y) < 500) {
			laneDanger[buses[i].lane] += 2;
		}
	}
	// Find the lane with minimum danger
	var minDanger = 999;
	var safestLane = player.lane;
	for (var i = 0; i < 4; i++) {
		if (laneDanger[i] < minDanger) {
			minDanger = laneDanger[i];
			safestLane = i;
		}
	}
	// ALWAYS ensure at least one lane is completely safe
	// If all lanes have danger, ensure at least one lane is safe
	var allLanesHaveDanger = true;
	for (var i = 0; i < 4; i++) {
		if (laneDanger[i] === 0) {
			allLanesHaveDanger = false;
			safestLane = i; // Immediately use first safe lane found
			break;
		}
	}
	// If all lanes have danger, force clear out a lane
	if (allLanesHaveDanger) {
		// Choose a lane different from player's current lane to free up
		var laneToFree = (player.lane + 2) % 4;
		// Clear ALL buses from this lane that are near the player
		for (var i = 0; i < buses.length; i++) {
			if (buses[i].lane === laneToFree) {
				// Move bus way above the screen to ensure it's far away
				buses[i].y = -buses[i].height - Math.random() * 2000;
			}
		}
		// Set this as safest lane
		safestLane = laneToFree;
	}
	return safestLane;
}
// Touch/swipe controls
var startY, startX;
var MIN_SWIPE_DISTANCE = 30;
game.down = function (x, y) {
	startX = x;
	startY = y;
};
game.up = function (x, y) {
	if (!startX || !startY) return;
	var deltaX = x - startX;
	var deltaY = y - startY;
	var absDeltaX = Math.abs(deltaX);
	var absDeltaY = Math.abs(deltaY);
	// Start game on any swipe if not started
	if (!gameStarted) {
		startGame();
		return;
	}
	// Lower the minimum swipe distance to make it more sensitive
	var MIN_SWIPE_DISTANCE = 30;
	// Detect swipe direction
	if (absDeltaX > MIN_SWIPE_DISTANCE || absDeltaY > MIN_SWIPE_DISTANCE) {
		// Horizontal swipe detection (left/right) - always move only to adjacent lane
		if (absDeltaX > absDeltaY) {
			if (deltaX > 0) {
				// Swipe right - move to adjacent right lane if possible
				var newLane = Math.min(player.lane + 1, 3);
				// Check if killTweensOf exists before calling it
				if (tween.killTweensOf) {
					tween.killTweensOf(player); // Kill any existing movement tweens
				}
				// Shorter duration for faster response
				tween(player, {
					x: roadPositions[newLane]
				}, {
					duration: 100,
					// Faster movement
					easing: tween.easeOut
				});
				player.lane = newLane; // Update player lane
			} else {
				// Swipe left - move to adjacent left lane if possible
				var newLane = Math.max(player.lane - 1, 0);
				// Check if killTweensOf exists before calling it
				if (tween.killTweensOf) {
					tween.killTweensOf(player);
				}
				// Shorter duration for faster response
				tween(player, {
					x: roadPositions[newLane]
				}, {
					duration: 100,
					// Faster movement
					easing: tween.easeOut
				});
				player.lane = newLane; // Update player lane
			}
		}
		// Vertical swipe detection (up/down)
		else {
			if (deltaY < 0) {
				// Swipe up (jump)
				player.jump();
			} else {
				// Swipe down (slide)
				player.slide();
			}
		}
	}
};
// Initialize the game
initializeGame();
// Game update loop
game.update = function () {
	if (!gameStarted) {
		// Don't do any movement when game hasn't started
		return;
	}
	// Update distance traveled
	distanceTraveled += gameSpeed;
	updateUI();
	// Check for collisions
	checkCollisions();
	// No obstacles to update since we don't spawn them anymore
	for (var i = coins.length - 1; i >= 0; i--) {
		if (coins[i]) coins[i].update();
	}
	for (var i = powerups.length - 1; i >= 0; i--) {
		if (powerups[i]) powerups[i].update();
	}
	// Ensure jumping boards (MiniBus objects) aren't too close to each other
	var jumpingBoards = buses.filter(function (bus) {
		return bus instanceof MiniBus;
	});
	// Check each jumping board against others in the same lane
	for (var i = 0; i < jumpingBoards.length; i++) {
		for (var j = i + 1; j < jumpingBoards.length; j++) {
			if (jumpingBoards[i].lane === jumpingBoards[j].lane) {
				var distance = Math.abs(jumpingBoards[i].y - jumpingBoards[j].y);
				// If boards are too close, reposition the one that's higher up
				if (distance < jumpingBoards[i].height * 10) {
					// Increased from 5x to 10x minimum spacing
					var higherBoard = jumpingBoards[i].y < jumpingBoards[j].y ? jumpingBoards[i] : jumpingBoards[j];
					// Reset position of the higher board to ensure adequate spacing
					higherBoard.resetPosition();
					// Move it even further up to ensure separation
					higherBoard.y -= higherBoard.height * 10 + Math.random() * 400; // Increased spacing
				}
			}
		}
	}
	for (var i = buses.length - 1; i >= 0; i--) {
		if (buses[i]) buses[i].update();
	}
	// Update lifesavers
	for (var i = lifesavers.length - 1; i >= 0; i--) {
		if (lifesavers[i]) lifesavers[i].update();
	}
	// Road lines are now stationary
	// Update all PlayerParticle instances that might be in the scene
	var particles = game.children.filter(function (child) {
		return child instanceof PlayerParticle;
	});
	for (var i = 0; i < particles.length; i++) {
		particles[i].update();
	}
};

===================================================================
--- original.js
+++ change.js
@@ -195,9 +195,9 @@
 		}
 	};
 	self.resetPosition = function () {
 		// Reset to top of screen with more randomization
-		self.y = -self.height - Math.random() * 800; // Increased random variance from 300 to 800
+		self.y = -self.height - Math.random() * 1200; // Increased random variance from 800 to 1200
 		// Randomly assign to a lane
 		self.lane = Math.floor(Math.random() * 4);
 		self.x = roadPositions[self.lane];
 		// Check for other jumping boards in this lane and ensure spacing
@@ -206,14 +206,14 @@
 			if (buses[i] instanceof MiniBus && buses[i] !== self && buses[i].lane === self.lane) {
 				jumpingBoardsInLane.push(buses[i]);
 			}
 		}
-		// Ensure minimum spacing with other jumping boards in the same lane
+		// Ensure minimum spacing with other jumping boards in the same lane - increased spacing requirement
 		for (var i = 0; i < jumpingBoardsInLane.length; i++) {
 			var otherBoard = jumpingBoardsInLane[i];
-			if (otherBoard.y < 0 && Math.abs(self.y - otherBoard.y) < self.height * 6) {
-				// If too close to another jumping board, move further up
-				self.y = otherBoard.y - (self.height * 6 + Math.random() * 400);
+			if (otherBoard.y < 0 && Math.abs(self.y - otherBoard.y) < self.height * 12) {
+				// If too close to another jumping board, move much further up
+				self.y = otherBoard.y - (self.height * 12 + Math.random() * 600);
 			}
 		}
 	};
 	return self;
@@ -639,9 +639,9 @@
 		buses.push(miniBus); // Add to main buses array for updates
 		game.addChild(miniBus);
 	}
 	// Initialize variables
-	obstacles = []; // Empty array since we don't spawn obstacles anymore
+	obstacles = []; // Keep empty as we don't use obstacles at all
 	coins = [];
 	powerups = [];
 	gameSpeed = initialGameSpeed;
 	distanceTraveled = 0;
@@ -665,10 +665,9 @@
 				buses[i].speed = 1; // Keep all buses at same speed when the game speeds up
 			}
 		}
 	}, 10000);
-	// Start spawning obstacles, coins, and powerups
-	spawnObstacles();
+	// Start spawning only coins and powerups (no obstacles)
 	spawnCoins();
 	spawnPowerups();
 	// Reset lifesaver state
 	hasLifesaver = false;
@@ -774,24 +773,35 @@
 	var coin = new Coin();
 	coin.lane = lane;
 	coin.x = roadPositions[lane];
 	coin.y = -coin.height;
-	// Increased chance to spawn additional coins if in lane 1 (correct lane)
-	if (lane === 1 && Math.random() < 0.9) {
-		// Increased probability from 0.7 to 0.9
-		// Add extra coins in a vertical line in the correct lane
-		for (var i = 1; i < 6; i++) {
-			// Increased from 4 to 6 coins in a row
-			var extraCoin = new Coin();
-			extraCoin.lane = lane;
-			extraCoin.x = roadPositions[lane];
-			extraCoin.y = -coin.height - i * 100; // Reduced spacing for more coins
-			coins.push(extraCoin);
-			game.addChild(extraCoin);
+	// Check if there are buses in this lane near spawn point
+	var busInLane = false;
+	for (var i = 0; i < buses.length; i++) {
+		if (buses[i].lane === lane && buses[i].y < 0 && buses[i].y > -300) {
+			busInLane = true;
+			break;
 		}
 	}
-	coins.push(coin);
-	game.addChild(coin);
+	// Only spawn coins if there's no bus in this lane
+	if (!busInLane) {
+		// Increased chance to spawn additional coins if in lane 1 (correct lane)
+		if (lane === 1 && Math.random() < 0.9) {
+			// Increased probability from 0.7 to 0.9
+			// Add extra coins in a vertical line in the correct lane
+			for (var i = 1; i < 6; i++) {
+				// Increased from 4 to 6 coins in a row
+				var extraCoin = new Coin();
+				extraCoin.lane = lane;
+				extraCoin.x = roadPositions[lane];
+				extraCoin.y = -coin.height - i * 100; // Reduced spacing for more coins
+				coins.push(extraCoin);
+				game.addChild(extraCoin);
+			}
+		}
+		coins.push(coin);
+		game.addChild(coin);
+	}
 }
 function spawnPowerups() {
 	var powerupTimer = LK.setInterval(function () {
 		if (!gameStarted) return;
@@ -1187,14 +1197,17 @@
 		easing: tween.easeOut,
 		onFinish: function onFinish() {
 			// Once centered, grow the character to fill the screen
 			tween(player, {
-				scaleX: 15,
-				scaleY: 15,
+				scaleX: 20,
+				// Make even larger to completely fill screen
+				scaleY: 20,
+				// Make even larger to completely fill screen
 				rotation: Math.PI * 2,
-				alpha: 0.8
+				alpha: 0.9 // More visible
 			}, {
-				duration: 1500,
+				duration: 2000,
+				// Longer duration for more dramatic effect
 				easing: tween.elasticOut,
 				onFinish: function onFinish() {
 					// Now show game over after animation completes
 					LK.showGameOver();
@@ -1221,25 +1234,27 @@
 			minDanger = laneDanger[i];
 			safestLane = i;
 		}
 	}
+	// ALWAYS ensure at least one lane is completely safe
 	// If all lanes have danger, ensure at least one lane is safe
 	var allLanesHaveDanger = true;
 	for (var i = 0; i < 4; i++) {
 		if (laneDanger[i] === 0) {
 			allLanesHaveDanger = false;
+			safestLane = i; // Immediately use first safe lane found
 			break;
 		}
 	}
-	// If all lanes have danger, clear out a lane
+	// If all lanes have danger, force clear out a lane
 	if (allLanesHaveDanger) {
-		// Choose a lane different from player's current lane
+		// Choose a lane different from player's current lane to free up
 		var laneToFree = (player.lane + 2) % 4;
-		// Clear all buses from this lane that are near the player
+		// Clear ALL buses from this lane that are near the player
 		for (var i = 0; i < buses.length; i++) {
-			if (buses[i].lane === laneToFree && Math.abs(buses[i].y - player.y) < 500) {
+			if (buses[i].lane === laneToFree) {
 				// Move bus way above the screen to ensure it's far away
-				buses[i].y = -buses[i].height - Math.random() * 1000;
+				buses[i].y = -buses[i].height - Math.random() * 2000;
 			}
 		}
 		// Set this as safest lane
 		safestLane = laneToFree;
@@ -1345,14 +1360,15 @@
 		for (var j = i + 1; j < jumpingBoards.length; j++) {
 			if (jumpingBoards[i].lane === jumpingBoards[j].lane) {
 				var distance = Math.abs(jumpingBoards[i].y - jumpingBoards[j].y);
 				// If boards are too close, reposition the one that's higher up
-				if (distance < jumpingBoards[i].height * 5) {
+				if (distance < jumpingBoards[i].height * 10) {
+					// Increased from 5x to 10x minimum spacing
 					var higherBoard = jumpingBoards[i].y < jumpingBoards[j].y ? jumpingBoards[i] : jumpingBoards[j];
 					// Reset position of the higher board to ensure adequate spacing
 					higherBoard.resetPosition();
 					// Move it even further up to ensure separation
-					higherBoard.y -= higherBoard.height * 5 + Math.random() * 200;
+					higherBoard.y -= higherBoard.height * 10 + Math.random() * 400; // Increased spacing
 				}
 			}
 		}
 	}