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

/**** 
* Classes
****/ 
// Bonus Item Class
var Bonus = Container.expand(function () {
	var self = Container.call(this);
	// Power-up types: "score" (default), "shield", "double"
	var types = [{
		id: 'bonus',
		type: 'score'
	}, {
		id: 'bonus',
		type: 'shield'
	}, {
		id: 'bonus',
		type: 'double'
	}];
	var chosen = types[Math.floor(Math.random() * types.length)];
	self.type = chosen.type;
	// Use different tints for power-ups
	var tint = 0xffffff;
	if (self.type === 'shield') tint = 0x42a5f5;
	if (self.type === 'double') tint = 0xffd600;
	var b = self.attachAsset(chosen.id, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	b.tint = tint;
	self.width = b.width;
	self.height = b.height;
	self.speed = 18 + Math.random() * 8; // Will be set by game
	self.lane = 0;
	self.update = function () {
		self.y += self.speed;
	};
	self.getBounds = function () {
		// Shrink hitbox for better gameplay feel
		var w = b.width * 0.7;
		var h = b.height * 0.7;
		return {
			x: self.x - w / 2,
			y: self.y - h / 2,
			width: w,
			height: h
		};
	};
	return self;
});
// Enemy Car Class
var EnemyCar = Container.expand(function () {
	var self = Container.call(this);
	// Randomly select one of the enemy car asset ids
	var enemyCarIds = ['enemyCar', 'enemyCar2', 'enemyCar3', 'enemyCar4'];
	var chosenId = enemyCarIds[Math.floor(Math.random() * enemyCarIds.length)];
	var car = self.attachAsset(chosenId, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.width = car.width;
	self.height = car.height;
	self.speed = 18 + Math.random() * 8; // Will be set by game
	self.lane = 0;
	self.update = function () {
		self.y += self.speed;
	};
	self.getBounds = function () {
		// Shrink hitbox for better gameplay feel
		var w = car.width * 0.7;
		var h = car.height * 0.7;
		return {
			x: self.x - w / 2,
			y: self.y - h / 2,
			width: w,
			height: h
		};
	};
	return self;
});
// Obstacle Class
var Obstacle = Container.expand(function () {
	var self = Container.call(this);
	var obs = self.attachAsset('obstacle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.width = obs.width;
	self.height = obs.height;
	self.speed = 18 + Math.random() * 8; // Will be set by game
	self.lane = 0;
	self.update = function () {
		self.y += self.speed;
	};
	self.getBounds = function () {
		// Shrink hitbox for better gameplay feel
		var w = obs.width * 0.7;
		var h = obs.height * 0.7;
		return {
			x: self.x - w / 2,
			y: self.y - h / 2,
			width: w,
			height: h
		};
	};
	return self;
});
// Player Car Class
var PlayerCar = Container.expand(function () {
	var self = Container.call(this);
	var car = self.attachAsset('playerCar', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 0.55,
		scaleY: 0.55
	});
	self.width = car.width * 0.55;
	self.height = car.height * 0.55;
	// For touch drag offset
	self.dragOffsetX = 0;
	self.dragOffsetY = 0;
	// For collision
	self.getBounds = function () {
		// Shrink hitbox for better gameplay feel
		var w = car.width * 0.55;
		var h = car.height * 0.55;
		return {
			x: self.x - w / 2,
			y: self.y - h / 2,
			width: w,
			height: h
		};
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Bonus item
// Road lane
// Obstacle (barrier)
// Enemy car
// Car (player)
// Road and lane setup
// Tree and plant assets for background
var roadWidth = 900;
var roadLeft = (2048 - roadWidth) / 2;
var roadRight = roadLeft + roadWidth;
var laneCount = 4;
var laneWidth = roadWidth / laneCount;
var laneCenters = [];
for (var i = 0; i < laneCount; i++) {
	laneCenters.push(roadLeft + laneWidth / 2 + i * laneWidth);
}
// --- Add colorful trees and plants to left and right sides of the road as background ---
var bgDecor = [];
var decorTypes = [{
	id: 'tree1',
	yOffset: 0
}, {
	id: 'tree2',
	yOffset: 40
}, {
	id: 'plant1',
	yOffset: 120
}, {
	id: 'plant2',
	yOffset: 180
}, {
	id: 'plant3',
	yOffset: 240
}, {
	id: 'plant3',
	yOffset: 240
}, {
	id: 'plant3',
	yOffset: 240
}, {
	id: 'plant3',
	yOffset: 240
}, {
	// extra plant3 for higher probability
	id: 'plant3',
	yOffset: 240
}, {
	id: 'plant3',
	yOffset: 240
}, {
	id: 'plant3',
	yOffset: 240
}];
// Place decorations in a staggered, repeating pattern, but less frequently
for (var side = 0; side < 2; side++) {
	// 0: left, 1: right
	for (var i = 0; i < 4; i++) {
		// Reduced from 8 to 4 for lower frequency
		var typeIdx = i % decorTypes.length;
		var decor = LK.getAsset(decorTypes[typeIdx].id, {
			anchorX: 0.5,
			anchorY: 0.5
		});
		// X position: left or right of road, with some random offset for natural look
		if (side === 0) {
			decor.x = roadLeft - 90 + Math.random() * 30;
		} else {
			decor.x = roadRight + 90 - Math.random() * 30;
		}
		// Y position: staggered vertically, with some random offset, spacing increased for less density
		decor.y = 300 + i * 640 + decorTypes[typeIdx].yOffset + Math.random() * 40;
		// Store for scrolling
		decor._baseY = decor.y;
		decor._side = side;
		decor._typeIdx = typeIdx;
		game.addChild(decor);
		bgDecor.push(decor);
	}
}
// Draw lane markers (scrolling effect)
var laneMarkers = [];
for (var i = 1; i < laneCount; i++) {
	for (var j = 0; j < 6; j++) {
		var marker = LK.getAsset('lane', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: roadLeft + i * laneWidth,
			y: j * 400
		});
		marker.laneIdx = i;
		marker.offsetIdx = j;
		game.addChild(marker);
		laneMarkers.push(marker);
	}
}
// Player car
var player = new PlayerCar();
player.x = laneCenters[1];
player.y = 2732 - 500;
game.addChild(player);
// Score
var score = 0;
var scoreTxt = new Text2('0', {
	size: 120,
	fill: "#fff"
});
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
// Bonus score
var bonusScore = 0;
var bonusTxt = new Text2('', {
	size: 70,
	fill: 0xFFFA00 // Bright yellow for high visibility
});
bonusTxt.anchor.set(0.5, 0);
// Move the bonus text further down (e.g. 180px from the top)
bonusTxt.y = 180;
LK.gui.top.addChild(bonusTxt);
// Game state
var enemyCars = [];
var obstacles = [];
var bonuses = [];
var gameSpeed = 18;
var ticksSinceStart = 0;
var lastSpawnTick = 0;
var lastBonusTick = 0;
var isDragging = false;
var dragStartX = 0;
var dragStartY = 0;
var playerStartX = 0;
var playerStartY = 0;
var lastCrash = false;
// Touch controls: tap a lane to move player car smoothly to that lane
var playerTargetLane = 1;
var playerMoveTween = null;
game.down = function (x, y, obj) {
	// Find which lane was tapped
	for (var i = 0; i < laneCount; i++) {
		var laneX = laneCenters[i];
		var laneLeftEdge = laneX - laneWidth / 2;
		var laneRightEdge = laneX + laneWidth / 2;
		if (x >= laneLeftEdge && x <= laneRightEdge) {
			playerTargetLane = i;
			// Tween player car to the center of the tapped lane
			if (playerMoveTween && playerMoveTween.cancel) playerMoveTween.cancel();
			var startX = player.x;
			var endX = laneCenters[i];
			var t = {
				val: startX
			};
			playerMoveTween = tween(t, {
				val: endX
			}, {
				duration: 180,
				easing: tween.easeInOutQuad,
				onUpdate: function onUpdate() {
					player.x = t.val;
				},
				onFinish: function onFinish() {
					player.x = endX;
				}
			});
			break;
		}
	}
};
game.move = function (x, y, obj) {
	// No drag, so nothing here
};
game.up = function (x, y, obj) {
	// No drag, so nothing here
};
// Helper: collision check (AABB)
function intersects(a, b) {
	var ab = a.getBounds();
	var bb = b.getBounds();
	return ab.x < bb.x + bb.width && ab.x + ab.width > bb.x && ab.y < bb.y + bb.height && ab.y + ab.height > bb.y;
}
// Main game loop
game.update = function () {
	ticksSinceStart++;
	// 3-stage difficulty progression: very easy, then medium, then hard
	// Very Easy: 0-3000 ticks (~50s), Medium: 3000-6000 ticks (~100s), Hard: 6000+ ticks
	if (!game._spawnInterval) game._spawnInterval = 40;
	if (ticksSinceStart < 3000) {
		// Very Easy: very slow ramp up
		if (ticksSinceStart % 600 == 0 && gameSpeed < 20) {
			gameSpeed += 1;
		}
		if (ticksSinceStart % 600 == 0 && game._spawnInterval > 32) {
			game._spawnInterval -= 1;
		}
	} else if (ticksSinceStart < 6000) {
		// Medium: moderate ramp up
		if (ticksSinceStart % 300 == 0 && gameSpeed < 28) {
			gameSpeed += 1;
		}
		if (ticksSinceStart % 300 == 0 && game._spawnInterval > 20) {
			game._spawnInterval -= 1;
		}
	} else {
		// Hard: faster ramp up, but cap
		if (ticksSinceStart % 120 == 0 && gameSpeed < 38) {
			gameSpeed += 1;
		}
		if (ticksSinceStart % 120 == 0 && game._spawnInterval > 14) {
			game._spawnInterval -= 1;
		}
	}
	// Move background trees and plants for scrolling effect
	for (var i = 0; i < bgDecor.length; i++) {
		var decor = bgDecor[i];
		decor.y += gameSpeed;
		// If decor goes off bottom, loop to top with new random offset for variety
		if (decor.y > 2732 + 120) {
			decor.y -= 8 * 320;
			decor.y += Math.random() * 40 - 20;
			// Optionally randomize X a bit for more natural look
			if (decor._side === 0) {
				decor.x = roadLeft - 90 + Math.random() * 30;
			} else {
				decor.x = roadRight + 90 - Math.random() * 30;
			}
		}
	}
	// Move lane markers for scrolling effect
	for (var i = 0; i < laneMarkers.length; i++) {
		var marker = laneMarkers[i];
		marker.y += gameSpeed;
		if (marker.y > 2732) {
			marker.y -= 2400;
		}
	}
	// Spawn enemy cars and obstacles, ensuring no overlap with any existing object
	if (ticksSinceStart - lastSpawnTick > (game._spawnInterval || 36)) {
		lastSpawnTick = ticksSinceStart;
		// Randomly pick lanes to spawn cars/obstacles, but never all 4 at once
		var spawnLanes = [];
		for (var i = 0; i < laneCount; i++) {
			if (Math.random() < 0.5) spawnLanes.push(i);
		}
		// Never allow all 4 lanes to be filled at once
		if (spawnLanes.length > 3) {
			// Randomly remove one lane to ensure max 3
			var idxToRemove = Math.floor(Math.random() * spawnLanes.length);
			spawnLanes.splice(idxToRemove, 1);
		}
		if (spawnLanes.length == 0) spawnLanes.push(Math.floor(Math.random() * laneCount));
		// Limit to max 3 obstacles per spawn
		var obstacleCountThisSpawn = 0;
		// Track which lanes will have obstacles this spawn
		var obstacleLanesThisSpawn = [];
		// Track which lanes are used (to prevent both enemy and obstacle in same lane)
		var usedLanes = {};
		// Track all new objects to check for overlap
		var newObjects = [];
		for (var i = 0; i < spawnLanes.length; i++) {
			var laneIdx = spawnLanes[i];
			// If already 3 obstacles, force enemy car for the rest
			var forceEnemy = obstacleCountThisSpawn >= 3;
			// Only allow one object per lane (no overlap of enemy/obstacle)
			if (usedLanes[laneIdx]) continue;
			// Determine spawn Y and type
			var spawnY,
				obj,
				isObstacle = false;
			if (!forceEnemy && Math.random() >= 0.7) {
				// Obstacle
				obj = new Obstacle();
				obj.x = laneCenters[laneIdx];
				obj.y = -100;
				obj.speed = gameSpeed;
				obj.lane = laneIdx;
				spawnY = obj.y;
				isObstacle = true;
			} else {
				// Enemy car
				obj = new EnemyCar();
				obj.x = laneCenters[laneIdx];
				obj.y = -200;
				obj.speed = gameSpeed;
				obj.lane = laneIdx;
				spawnY = obj.y;
			}
			// Check for overlap with all existing objects (enemyCars, obstacles, bonuses) and newObjects
			var overlap = false;
			var objBounds = obj.getBounds();
			// Check with existing enemy cars
			for (var j = 0; j < enemyCars.length; j++) {
				if (enemyCars[j].lane === laneIdx) {
					var other = enemyCars[j];
					var otherBounds = other.getBounds();
					if (!(objBounds.x + objBounds.width < otherBounds.x || objBounds.x > otherBounds.x + otherBounds.width || objBounds.y + objBounds.height < otherBounds.y || objBounds.y > otherBounds.y + otherBounds.height)) {
						overlap = true;
						break;
					}
				}
			}
			// Check with existing obstacles
			if (!overlap) {
				for (var j = 0; j < obstacles.length; j++) {
					if (obstacles[j].lane === laneIdx) {
						var other = obstacles[j];
						var otherBounds = other.getBounds();
						if (!(objBounds.x + objBounds.width < otherBounds.x || objBounds.x > otherBounds.x + otherBounds.width || objBounds.y + objBounds.height < otherBounds.y || objBounds.y > otherBounds.y + otherBounds.height)) {
							overlap = true;
							break;
						}
					}
				}
			}
			// Check with existing bonuses
			if (!overlap) {
				for (var j = 0; j < bonuses.length; j++) {
					if (bonuses[j].lane === laneIdx) {
						var other = bonuses[j];
						var otherBounds = other.getBounds();
						if (!(objBounds.x + objBounds.width < otherBounds.x || objBounds.x > otherBounds.x + otherBounds.width || objBounds.y + objBounds.height < otherBounds.y || objBounds.y > otherBounds.y + otherBounds.height)) {
							overlap = true;
							break;
						}
					}
				}
			}
			// Check with new objects in this spawn
			if (!overlap) {
				for (var j = 0; j < newObjects.length; j++) {
					if (newObjects[j].lane === laneIdx) {
						var other = newObjects[j];
						var otherBounds = other.getBounds();
						if (!(objBounds.x + objBounds.width < otherBounds.x || objBounds.x > otherBounds.x + otherBounds.width || objBounds.y + objBounds.height < otherBounds.y || objBounds.y > otherBounds.y + otherBounds.height)) {
							overlap = true;
							break;
						}
					}
				}
			}
			if (overlap) {
				// Don't spawn this object
				if (obj && obj.destroy) obj.destroy();
				continue;
			}
			// No overlap, spawn
			if (isObstacle) {
				obstacles.push(obj);
				game.addChild(obj);
				obstacleCountThisSpawn++;
				obstacleLanesThisSpawn.push(laneIdx);
				usedLanes[laneIdx] = true;
			} else {
				enemyCars.push(obj);
				game.addChild(obj);
				usedLanes[laneIdx] = true;
			}
			newObjects.push(obj);
		}
		// Store obstacle lanes for this tick for bonus spawn logic
		game._obstacleLanesThisSpawn = obstacleLanesThisSpawn;
	} else {
		// If not spawning this tick, clear obstacle lanes
		game._obstacleLanesThisSpawn = [];
	}
	// Spawn bonus, ensuring no overlap with any object
	if (ticksSinceStart - lastBonusTick > 180 && Math.random() < 0.5) {
		lastBonusTick = ticksSinceStart;
		// Prevent bonus from spawning in a lane with an obstacle this tick
		var availableBonusLanes = [];
		for (var i = 0; i < laneCount; i++) {
			var blocked = false;
			if (game._obstacleLanesThisSpawn) {
				for (var j = 0; j < game._obstacleLanesThisSpawn.length; j++) {
					if (game._obstacleLanesThisSpawn[j] === i) {
						blocked = true;
						break;
					}
				}
			}
			// Check for overlap with any object in this lane at spawn Y
			if (!blocked) {
				var testBonus = new Bonus();
				testBonus.x = laneCenters[i];
				testBonus.y = -100;
				testBonus.lane = i;
				var testBounds = testBonus.getBounds();
				// Check with enemy cars
				for (var j = 0; j < enemyCars.length; j++) {
					if (enemyCars[j].lane === i) {
						var other = enemyCars[j];
						var otherBounds = other.getBounds();
						if (!(testBounds.x + testBounds.width < otherBounds.x || testBounds.x > otherBounds.x + otherBounds.width || testBounds.y + testBounds.height < otherBounds.y || testBounds.y > otherBounds.y + otherBounds.height)) {
							blocked = true;
							break;
						}
					}
				}
				// Check with obstacles
				if (!blocked) {
					for (var j = 0; j < obstacles.length; j++) {
						if (obstacles[j].lane === i) {
							var other = obstacles[j];
							var otherBounds = other.getBounds();
							if (!(testBounds.x + testBounds.width < otherBounds.x || testBounds.x > otherBounds.x + otherBounds.width || testBounds.y + testBounds.height < otherBounds.y || testBounds.y > otherBounds.y + otherBounds.height)) {
								blocked = true;
								break;
							}
						}
					}
				}
				// Check with bonuses
				if (!blocked) {
					for (var j = 0; j < bonuses.length; j++) {
						if (bonuses[j].lane === i) {
							var other = bonuses[j];
							var otherBounds = other.getBounds();
							if (!(testBounds.x + testBounds.width < otherBounds.x || testBounds.x > otherBounds.x + otherBounds.width || testBounds.y + testBounds.height < otherBounds.y || testBounds.y > otherBounds.y + otherBounds.height)) {
								blocked = true;
								break;
							}
						}
					}
				}
				if (!blocked) availableBonusLanes.push(i);
				if (testBonus && testBonus.destroy) testBonus.destroy();
			}
		}
		if (availableBonusLanes.length > 0) {
			var laneIdx = availableBonusLanes[Math.floor(Math.random() * availableBonusLanes.length)];
			var b = new Bonus();
			b.x = laneCenters[laneIdx];
			b.y = -100;
			b.speed = gameSpeed;
			b.lane = laneIdx;
			bonuses.push(b);
			game.addChild(b);
		}
	}
	// Move enemy cars
	for (var i = enemyCars.length - 1; i >= 0; i--) {
		var e = enemyCars[i];
		e.update();
		if (e.y > 2732 + 200) {
			e.destroy();
			enemyCars.splice(i, 1);
			continue;
		}
		// Collision with player
		if (intersects(player, e)) {
			if (!lastCrash) {
				if (player._shield) {
					player._shield = 0;
					LK.effects.flashObject(player, 0x42a5f5, 600);
					enemyCars.splice(i, 1);
					e.destroy();
					continue;
				}
				LK.effects.flashScreen(0xff0000, 800);
				lastCrash = true;
				LK.showGameOver();
				return;
			}
		}
	}
	// Move obstacles
	for (var i = obstacles.length - 1; i >= 0; i--) {
		var o = obstacles[i];
		o.update();
		if (o.y > 2732 + 100) {
			o.destroy();
			obstacles.splice(i, 1);
			continue;
		}
		// Collision with player
		if (intersects(player, o)) {
			if (!lastCrash) {
				if (player._shield) {
					player._shield = 0;
					LK.effects.flashObject(player, 0x42a5f5, 600);
					obstacles.splice(i, 1);
					o.destroy();
					continue;
				}
				LK.effects.flashScreen(0xff0000, 800);
				lastCrash = true;
				LK.showGameOver();
				return;
			}
		}
	}
	// Move bonuses
	for (var i = bonuses.length - 1; i >= 0; i--) {
		var b = bonuses[i];
		b.update();
		if (b.y > 2732 + 100) {
			b.destroy();
			bonuses.splice(i, 1);
			continue;
		}
		// Collision with player
		if (intersects(player, b)) {
			if (b.type === 'shield') {
				player._shield = 1;
				LK.effects.flashObject(player, 0x42a5f5, 600);
				bonusTxt.setText("SHIELD! (Shield Bonus)");
				(function () {
					var t = bonusTxt;
					t.alpha = 1;
					tween(t, {
						alpha: 0
					}, {
						duration: 900,
						easing: tween.linear,
						onFinish: function onFinish() {
							t.setText('');
						}
					});
				})();
			} else if (b.type === 'double') {
				player._doubleScore = 1;
				player._doubleScoreTicks = 600; // 10 seconds at 60fps
				LK.effects.flashObject(player, 0xffd600, 600);
				bonusTxt.setText("x2 SCORE! (Double Score Bonus)");
				(function () {
					var t = bonusTxt;
					t.alpha = 1;
					tween(t, {
						alpha: 0
					}, {
						duration: 900,
						easing: tween.linear,
						onFinish: function onFinish() {
							t.setText('');
						}
					});
				})();
			} else {
				var addScore = 100;
				if (player._doubleScore) addScore *= 2;
				bonusScore += addScore;
				score += addScore;
				LK.effects.flashObject(player, 0x43a047, 400);
				bonusTxt.setText("+" + addScore + "! (Score Bonus)");
				(function () {
					var t = bonusTxt;
					t.alpha = 1;
					tween(t, {
						alpha: 0
					}, {
						duration: 900,
						easing: tween.linear,
						onFinish: function onFinish() {
							t.setText('');
						}
					});
				})();
			}
			b.destroy();
			bonuses.splice(i, 1);
		}
	}
	// Score increases with distance
	if (!lastCrash) {
		var addScore = Math.floor(gameSpeed / 2);
		if (player._doubleScore) addScore *= 2;
		score += addScore;
		scoreTxt.setText(score + "");
		// Handle double score timer
		if (player._doubleScore) {
			player._doubleScoreTicks--;
			if (player._doubleScoreTicks <= 0) {
				player._doubleScore = 0;
				player._doubleScoreTicks = 0;
			}
		}
	}
};
// Reset crash state on new game
LK.on('gameStart', function () {
	lastCrash = false;
	score = 0;
	bonusScore = 0;
	scoreTxt.setText('0');
	bonusTxt.setText('');
	// Remove all cars, obstacles, bonuses
	for (var i = enemyCars.length - 1; i >= 0; i--) {
		enemyCars[i].destroy();
		enemyCars.splice(i, 1);
	}
	for (var i = obstacles.length - 1; i >= 0; i--) {
		obstacles[i].destroy();
		obstacles.splice(i, 1);
	}
	for (var i = bonuses.length - 1; i >= 0; i--) {
		bonuses[i].destroy();
		bonuses.splice(i, 1);
	}
	playerTargetLane = 1;
	player.x = laneCenters[1];
	player.y = 2732 - 500;
	if (playerMoveTween && playerMoveTween.cancel) playerMoveTween.cancel();
	player._shield = 0;
	player._doubleScore = 0;
	player._doubleScoreTicks = 0;
	gameSpeed = 18;
	ticksSinceStart = 0;
	lastSpawnTick = 0;
	lastBonusTick = 0;
	game._spawnInterval = 36; // Easy stage spawn interval
});
// Prevent player from moving into top left menu area
// (handled by roadLeft, but double check)
if (roadLeft < 100) {
	roadLeft = 100;
	roadWidth = roadRight - roadLeft;
	laneWidth = roadWidth / laneCount;
	for (var i = 0; i < laneCount; i++) {
		laneCenters[i] = roadLeft + laneWidth / 2 + i * laneWidth;
	}
}

===================================================================
--- original.js
+++ change.js
@@ -278,35 +278,47 @@
 var dragStartY = 0;
 var playerStartX = 0;
 var playerStartY = 0;
 var lastCrash = false;
-// Touch controls
+// Touch controls: tap a lane to move player car smoothly to that lane
+var playerTargetLane = 1;
+var playerMoveTween = null;
 game.down = function (x, y, obj) {
-	// Only start drag if touch is on player car
-	var local = player.toLocal(game.toGlobal({
-		x: x,
-		y: y
-	}));
-	if (local.x > -player.width / 2 && local.x < player.width / 2 && local.y > -player.height / 2 && local.y < player.height / 2) {
-		isDragging = true;
-		dragStartX = x;
-		dragStartY = y;
-		playerStartX = player.x;
-		playerStartY = player.y;
+	// Find which lane was tapped
+	for (var i = 0; i < laneCount; i++) {
+		var laneX = laneCenters[i];
+		var laneLeftEdge = laneX - laneWidth / 2;
+		var laneRightEdge = laneX + laneWidth / 2;
+		if (x >= laneLeftEdge && x <= laneRightEdge) {
+			playerTargetLane = i;
+			// Tween player car to the center of the tapped lane
+			if (playerMoveTween && playerMoveTween.cancel) playerMoveTween.cancel();
+			var startX = player.x;
+			var endX = laneCenters[i];
+			var t = {
+				val: startX
+			};
+			playerMoveTween = tween(t, {
+				val: endX
+			}, {
+				duration: 180,
+				easing: tween.easeInOutQuad,
+				onUpdate: function onUpdate() {
+					player.x = t.val;
+				},
+				onFinish: function onFinish() {
+					player.x = endX;
+				}
+			});
+			break;
+		}
 	}
 };
 game.move = function (x, y, obj) {
-	if (isDragging) {
-		var dx = x - dragStartX;
-		// Only allow horizontal movement, clamp to road
-		var newX = playerStartX + dx;
-		if (newX < roadLeft + player.width / 2) newX = roadLeft + player.width / 2;
-		if (newX > roadRight - player.width / 2) newX = roadRight - player.width / 2;
-		player.x = newX;
-	}
+	// No drag, so nothing here
 };
 game.up = function (x, y, obj) {
-	isDragging = false;
+	// No drag, so nothing here
 };
 // Helper: collision check (AABB)
 function intersects(a, b) {
 	var ab = a.getBounds();
@@ -729,10 +741,12 @@
 	for (var i = bonuses.length - 1; i >= 0; i--) {
 		bonuses[i].destroy();
 		bonuses.splice(i, 1);
 	}
+	playerTargetLane = 1;
 	player.x = laneCenters[1];
 	player.y = 2732 - 500;
+	if (playerMoveTween && playerMoveTween.cancel) playerMoveTween.cancel();
 	player._shield = 0;
 	player._doubleScore = 0;
 	player._doubleScoreTicks = 0;
 	gameSpeed = 18;