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

/**** 
* Classes
****/ 
// Player Car
var Car = Container.expand(function () {
	var self = Container.call(this);
	var carAsset = self.attachAsset('car', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.width = carAsset.width;
	self.height = carAsset.height;
	// For collision box
	// Removed custom getBounds to avoid recursion bug
	return self;
});
// Coin
var Coin = Container.expand(function () {
	var self = Container.call(this);
	var coinAsset = self.attachAsset('coin', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.width = coinAsset.width;
	self.height = coinAsset.height;
	self.speed = 10; // Will be increased by game
	self.update = function () {
		self.y += self.speed;
	};
	// Removed custom getBounds to avoid recursion bug
	return self;
});
// Obstacle
var Obstacle = Container.expand(function () {
	var self = Container.call(this);
	var obsAsset = self.attachAsset('obstacle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Assign a random color tint to the obstacle asset
	var obstacleColors = [0xff4444,
	// red
	0x44aaff,
	// blue
	0x44ff44,
	// green
	0xffcc44,
	// yellow
	0xff44cc,
	// pink
	0xffffff,
	// white
	0xff8800,
	// orange
	0x888888 // gray
	];
	var colorIdx = Math.floor(Math.random() * obstacleColors.length);
	obsAsset.tint = obstacleColors[colorIdx];
	self.width = obsAsset.width;
	self.height = obsAsset.height;
	self.speed = 10; // Will be increased by game
	self.update = function () {
		self.y += self.speed;
	};
	// Removed custom getBounds to avoid recursion bug
	return self;
});
// RoadLine: vertical dashed line for road center/lanes
var RoadLine = Container.expand(function () {
	var self = Container.call(this);
	// Parameters for dashed line
	var dashHeight = 120;
	var gap = 80;
	var lineWidth = 24;
	var color = 0xffffff;
	var y = 0;
	// Fill vertical line with dashes
	while (y < 2732 + dashHeight) {
		var dash = LK.getAsset('roadline_dash', {
			width: lineWidth,
			height: dashHeight,
			color: color,
			shape: 'box',
			anchorX: 0.5,
			anchorY: 0
		});
		dash.x = 0;
		dash.y = y;
		self.addChild(dash);
		y += dashHeight + gap;
	}
	return self;
});

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

/**** 
* Game Code
****/ 
// Coin
// Obstacle
// Car (player)
// Game area
var GAME_WIDTH = 2048;
var GAME_HEIGHT = 2732;
// Lane system (3 lanes)
var LANE_COUNT = 3;
var LANE_WIDTH = GAME_WIDTH / LANE_COUNT;
var LANE_X = [Math.floor(LANE_WIDTH / 2), Math.floor(GAME_WIDTH / 2), Math.floor(GAME_WIDTH - LANE_WIDTH / 2)];
// Draw road lines (between lanes)
var roadLines = [];
for (var i = 1; i < LANE_COUNT; i++) {
	var line = new RoadLine();
	line.x = i * LANE_WIDTH;
	line.y = 0;
	game.addChild(line);
	roadLines.push(line);
}
// For rolling stripes
var roadLineSpeed = 14; // Stripes move faster than obstacles
// Player car
var car = new Car();
game.addChild(car);
car.x = GAME_WIDTH / 2;
car.y = GAME_HEIGHT - 400;
// Dragging
var dragCar = false;
var dragOffsetX = 0;
// Obstacles and coins
var obstacles = [];
var coins = [];
// Difficulty
var baseSpeed = 10; // Slower starting speed
var speed = baseSpeed;
var speedIncreaseInterval = 600; // every 10 seconds (60*10)
var minObstacleInterval = 36; // minimum ticks between obstacles
var obstacleInterval = 60; // ticks between obstacles, will decrease
var minCoinInterval = 30;
var coinInterval = 60;
// Score
var score = 0;
var scoreTxt = new Text2('0', {
	size: 120,
	fill: "#fff"
});
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
// Helper: collision
function rectsIntersect(a, b) {
	return !(a.x + a.width < b.x || a.x > b.x + b.width || a.y + a.height < b.y || a.y > b.y + b.height);
}
// Touch controls
function clamp(val, min, max) {
	return Math.max(min, Math.min(max, val));
}
game.down = function (x, y, obj) {
	// Only start drag if touch is on car
	var local = car.toLocal(game.toGlobal({
		x: x,
		y: y
	}));
	if (local.x >= -car.width / 2 && local.x <= car.width / 2 && local.y >= -car.height / 2 && local.y <= car.height / 2) {
		dragCar = true;
		dragOffsetX = car.x - x;
	}
};
game.move = function (x, y, obj) {
	if (dragCar) {
		// Only move horizontally, clamp to game area
		var newX = clamp(x + dragOffsetX, car.width / 2, GAME_WIDTH - car.width / 2);
		car.x = newX;
	}
};
game.up = function (x, y, obj) {
	dragCar = false;
};
// Spawning
var lastObstacleTick = 0;
var lastCoinTick = 0;
// Main update loop
game.update = function () {
	// Increase speed and difficulty over time
	if (LK.ticks % speedIncreaseInterval === 0 && LK.ticks > 0) {
		speed += 1; // Slower speed increase
		obstacleInterval = Math.max(minObstacleInterval, obstacleInterval - 4);
		coinInterval = Math.max(minCoinInterval, coinInterval - 2);
	}
	// Spawn obstacles
	if (LK.ticks - lastObstacleTick >= obstacleInterval) {
		var obs = new Obstacle();
		obs.speed = speed;
		// Random lane
		var lane = Math.floor(Math.random() * LANE_COUNT);
		// Allow obstacle to be anywhere inside the lane, not just center
		var laneLeft = lane * LANE_WIDTH;
		var laneRight = (lane + 1) * LANE_WIDTH;
		var minX = laneLeft + obs.width / 2;
		var maxX = laneRight - obs.width / 2;
		obs.x = minX + Math.random() * (maxX - minX);
		obs.y = -obs.height / 2;
		obstacles.push(obs);
		game.addChild(obs);
		lastObstacleTick = LK.ticks;
	}
	// Spawn coins
	if (LK.ticks - lastCoinTick >= coinInterval) {
		var coin = new Coin();
		coin.speed = speed;
		// Random lane, but not same as last obstacle
		var lane = Math.floor(Math.random() * LANE_COUNT);
		coin.x = LANE_X[lane];
		coin.y = -coin.height / 2 - 200;
		coins.push(coin);
		game.addChild(coin);
		lastCoinTick = LK.ticks;
	}
	// Move road lines down and wrap
	for (var rl = 0; rl < roadLines.length; rl++) {
		var line = roadLines[rl];
		line.y += roadLineSpeed;
		// The height of the dashed line pattern is dash+gap repeated, so wrap when y > dash+gap
		// We know from RoadLine: dashHeight=120, gap=80, so pattern=200
		var patternHeight = 120 + 80;
		if (line.y >= patternHeight) {
			line.y -= patternHeight;
		}
	}
	// Update obstacles
	for (var i = obstacles.length - 1; i >= 0; i--) {
		var obs = obstacles[i];
		obs.update();
		// Remove if off screen
		if (obs.y - obs.height / 2 > GAME_HEIGHT + 100) {
			obs.destroy();
			obstacles.splice(i, 1);
			continue;
		}
		// Collision with car
		if (rectsIntersect(obs.getBounds(), car.getBounds())) {
			// Flash and game over
			LK.effects.flashScreen(0xff0000, 800);
			LK.showGameOver();
			return;
		}
	}
	// Update coins
	for (var j = coins.length - 1; j >= 0; j--) {
		var coin = coins[j];
		coin.update();
		// Remove if off screen
		if (coin.y - coin.height / 2 > GAME_HEIGHT + 100) {
			coin.destroy();
			coins.splice(j, 1);
			continue;
		}
		// Collect coin
		if (rectsIntersect(coin.getBounds(), car.getBounds())) {
			score += 1;
			LK.setScore(score);
			scoreTxt.setText(score);
			// Animate coin
			tween(coin, {
				scaleX: 1.5,
				scaleY: 1.5,
				alpha: 0
			}, {
				duration: 200,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					coin.destroy();
				}
			});
			coins.splice(j, 1);
		}
	}
};
// Center score text at top, avoid top left 100x100
scoreTxt.x = LK.gui.top.width / 2;
scoreTxt.y = 20;

===================================================================
--- original.js
+++ change.js
@@ -63,29 +63,10 @@
 	obsAsset.tint = obstacleColors[colorIdx];
 	self.width = obsAsset.width;
 	self.height = obsAsset.height;
 	self.speed = 10; // Will be increased by game
-	// Sliding parameters (initialize if not already)
-	if (self.slideAmplitude === undefined) {
-		// Amplitude: 120-320 px, random per obstacle for more visible sliding
-		self.slideAmplitude = 120 + Math.random() * 200;
-		// Frequency: 0.002-0.006, random per obstacle for smoothness
-		self.slideFrequency = 0.002 + Math.random() * 0.004;
-		// Phase offset: random start
-		self.slidePhase = Math.random() * Math.PI * 2;
-		// Store original X (lane center)
-		self.baseX = self.x;
-	}
-	// Add update method for obstacle movement
 	self.update = function () {
-		// Store lastY for possible future use
-		if (self.lastY === undefined) self.lastY = self.y;
-		self.lastY = self.y;
-		// Move obstacle down
 		self.y += self.speed;
-		// Slide X in a smooth sinusoidal pattern
-		if (self.baseX === undefined) self.baseX = self.x;
-		self.x = self.baseX + Math.sin(self.y * self.slideFrequency + self.slidePhase) * self.slideAmplitude;
 	};
 	// Removed custom getBounds to avoid recursion bug
 	return self;
 });
@@ -217,11 +198,15 @@
 	// Spawn obstacles
 	if (LK.ticks - lastObstacleTick >= obstacleInterval) {
 		var obs = new Obstacle();
 		obs.speed = speed;
-		// Random X position across the road width, keeping obstacle fully on screen
-		var minX = obs.width / 2;
-		var maxX = GAME_WIDTH - obs.width / 2;
+		// Random lane
+		var lane = Math.floor(Math.random() * LANE_COUNT);
+		// Allow obstacle to be anywhere inside the lane, not just center
+		var laneLeft = lane * LANE_WIDTH;
+		var laneRight = (lane + 1) * LANE_WIDTH;
+		var minX = laneLeft + obs.width / 2;
+		var maxX = laneRight - obs.width / 2;
 		obs.x = minX + Math.random() * (maxX - minX);
 		obs.y = -obs.height / 2;
 		obstacles.push(obs);
 		game.addChild(obs);