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

/**** 
* Classes
****/ 
// Coin for road
var Coin = Container.expand(function () {
	var self = Container.call(this);
	// Use a simple yellow ellipse as the coin
	var coinAsset = self.attachAsset('coin', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	coinAsset.width = coinWidth;
	coinAsset.height = coinHeight;
	self.width = coinAsset.width;
	self.height = coinAsset.height;
	self.speedY = 0;
	self.update = function () {
		self.y += self.speedY;
	};
	return self;
});
// Road Lane Marking
var LaneMarking = Container.expand(function () {
	var self = Container.call(this);
	var marking = self.attachAsset('laneMarking', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	marking.width = laneMarkingWidth;
	marking.height = laneMarkingHeight;
	self.width = marking.width;
	self.height = marking.height;
	self.speedY = 0;
	self.update = function () {
		self.y += self.speedY;
	};
	return self;
});
// Obstacle Car
var ObstacleCar = Container.expand(function () {
	var self = Container.call(this);
	var carAsset = self.attachAsset('obstacleCar', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	carAsset.width = obstacleCarWidth;
	carAsset.height = obstacleCarHeight;
	self.width = carAsset.width;
	self.height = carAsset.height;
	self.speedY = 0; // Vertical speed
	self.update = function () {
		self.y += self.speedY;
	};
	return self;
});
// Player's Car
var PlayerCar = Container.expand(function () {
	var self = Container.call(this);
	var carAsset = self.attachAsset('playerCar', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	carAsset.width = playerCarWidth;
	carAsset.height = playerCarHeight;
	self.width = carAsset.width;
	self.height = carAsset.height;
	self.speedX = 0; // Horizontal speed
	// Update method called every tick
	self.update = function () {
		// Sliding/skid effect variables
		if (self.slideAngle === undefined) self.slideAngle = 0;
		if (self.targetAngle === undefined) self.targetAngle = 0;
		// Calculate target angle based on speedX (simulate drift)
		if (self.speedX < -1) {
			self.targetAngle = -Math.PI / 10; // left drift
		} else if (self.speedX > 1) {
			self.targetAngle = Math.PI / 10; // right drift
		} else {
			self.targetAngle = 0; // straighten
		}
		// Smoothly interpolate slideAngle towards targetAngle
		self.slideAngle += (self.targetAngle - self.slideAngle) * 0.18;
		// Apply rotation to car asset (visual only, not affecting movement)
		if (self.children && self.children.length > 0) {
			self.children[0].rotation = self.slideAngle;
		}
		self.x += self.speedX;
		// Clamp to road bounds
		if (self.x < roadLeft + self.width / 2) self.x = roadLeft + self.width / 2;
		if (self.x > roadRight - self.width / 2) self.x = roadRight - self.width / 2;
	};
	return self;
});
// Tree for road edge
var Tree = Container.expand(function () {
	var self = Container.call(this);
	var treeAsset = self.attachAsset('tree', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.width = treeAsset.width;
	self.height = treeAsset.height;
	self.speedY = 0;
	self.update = function () {
		self.y += self.speedY;
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Road dimensions
var roadWidth = 900;
var roadLeft = (2048 - roadWidth) / 2;
var roadRight = roadLeft + roadWidth;
// Lane count and positions
var laneCount = 3;
var laneWidth = roadWidth / laneCount;
var laneCenters = [roadLeft + laneWidth / 2, roadLeft + laneWidth * 1.5, roadLeft + laneWidth * 2.5];
// Player and obstacle car size (equalized, made slightly larger)
var playerCarWidth = 200;
var playerCarHeight = 320;
var obstacleCarWidth = 200;
var obstacleCarHeight = 320;
// Lane marking size
var laneMarkingWidth = 54;
var laneMarkingHeight = 330;
// Tree size and spacing
var treeWidth = 180;
var treeHeight = 270;
var treeSpacing = 220;
// Asset initialization (shapes)
// Game variables
var playerCar;
var obstacles = [];
var laneMarkings = [];
var trees = [];
var coins = [];
var coinSpawnTimer = 0;
var coinSpawnInterval = 45; // frames, coins spawn more frequently
var coinWidth = 80;
var coinHeight = 80;
var obstacleSpawnTimer = 0;
var obstacleSpawnInterval = 60; // frames
var laneMarkingSpacing = 320;
var speed = 18; // vertical speed (pixels per frame)
var score = 0;
var distance = 0;
var isGameOver = false;
// Score text removed
// Initialize player car
playerCar = new PlayerCar();
playerCar.x = laneCenters[1];
playerCar.y = 2732 - 400;
game.addChild(playerCar);
// Initialize lane markings as dashed (split into short segments)
var dashLength = 80;
var dashGap = 80;
var dashesPerMarking = Math.floor(laneMarkingHeight / (dashLength + dashGap));
for (var i = 0; i < laneCount - 1; i++) {
	for (var j = 0; j < Math.ceil(2732 / laneMarkingSpacing) + 2; j++) {
		var baseY = j * laneMarkingSpacing - laneMarkingHeight / 2;
		for (var d = 0; d < dashesPerMarking; d++) {
			var marking = new LaneMarking();
			marking.x = roadLeft + laneWidth * (i + 1);
			marking.y = baseY + d * (dashLength + dashGap);
			marking.speedY = speed;
			marking.height = dashLength;
			marking.width = laneMarkingWidth;
			laneMarkings.push(marking);
			game.addChild(marking);
		}
	}
}
// Initialize trees along both sides of the road (slightly more trees)
for (var side = 0; side < 2; side++) {
	var xPos = side === 0 ? roadLeft - treeWidth / 2 - 30 : roadRight + treeWidth / 2 + 30;
	for (var j = 0; j < 6; j++) {
		// 6 trees per side! 
		var tree = new Tree();
		tree.x = xPos;
		tree.y = j * (2732 / 6) + 100;
		tree.speedY = speed;
		trees.push(tree);
		game.addChild(tree);
	}
}
// Touch controls
var moveLeft = false;
var moveRight = false;
// Helper: get which side of the screen is pressed
function getSide(x) {
	if (x < 2048 / 2) return 'left';
	return 'right';
}
// Touch down
game.down = function (x, y, obj) {
	if (isGameOver) return;
	var side = getSide(x);
	if (side === 'left') {
		moveLeft = true;
		moveRight = false;
	} else {
		moveRight = true;
		moveLeft = false;
	}
	updatePlayerSpeed();
};
// Touch up
game.up = function (x, y, obj) {
	moveLeft = false;
	moveRight = false;
	updatePlayerSpeed();
};
// Touch move (optional, for smoother control)
game.move = function (x, y, obj) {
	if (isGameOver) return;
	var side = getSide(x);
	if (side === 'left') {
		moveLeft = true;
		moveRight = false;
	} else {
		moveRight = true;
		moveLeft = false;
	}
	updatePlayerSpeed();
};
// Update player car speedX based on input
function updatePlayerSpeed() {
	if (moveLeft && !moveRight) {
		playerCar.speedX = -22;
	} else if (moveRight && !moveLeft) {
		playerCar.speedX = 22;
	} else {
		playerCar.speedX = 0;
	}
}
// Main game update loop
game.update = function () {
	if (isGameOver) return;
	// Update lane markings
	for (var i = 0; i < laneMarkings.length; i++) {
		var marking = laneMarkings[i];
		marking.speedY = speed;
		marking.update();
		if (marking.y > 2732 + laneMarkingHeight / 2) {
			marking.y -= (Math.ceil(2732 / laneMarkingSpacing) + 2) * laneMarkingSpacing;
		}
	}
	// Update trees
	for (var i = 0; i < trees.length; i++) {
		var tree = trees[i];
		tree.speedY = speed;
		tree.update();
		if (tree.y > 2732 + treeHeight / 2) {
			tree.y -= (Math.ceil(2732 / treeSpacing) + 3) * treeSpacing;
		}
	}
	// Update player car
	playerCar.update();
	// Spawn coins
	coinSpawnTimer++;
	if (coinSpawnTimer >= coinSpawnInterval) {
		coinSpawnTimer = 0;
		// Spawn coin in a random lane
		var coin = new Coin();
		var laneIdx = Math.floor(Math.random() * laneCount);
		coin.x = laneCenters[laneIdx];
		coin.y = -coinHeight / 2;
		coin.speedY = speed;
		coins.push(coin);
		game.addChild(coin);
	}
	// Update coins
	for (var i = coins.length - 1; i >= 0; i--) {
		var coin = coins[i];
		coin.speedY = speed;
		coin.update();
		// Remove if off screen
		if (coin.y > 2732 + coinHeight) {
			coin.destroy();
			coins.splice(i, 1);
			continue;
		}
		// Collect coin
		if (playerCar.intersects(coin)) {
			coin.destroy();
			coins.splice(i, 1);
			score += 10; // Add 10 points for each coin
			continue;
		}
	}
	// Spawn obstacles
	obstacleSpawnTimer++;
	if (obstacleSpawnTimer >= obstacleSpawnInterval) {
		obstacleSpawnTimer = 0;
		spawnObstacle();
	}
	// Update obstacles
	for (var i = obstacles.length - 1; i >= 0; i--) {
		var obs = obstacles[i];
		obs.update();
		// Remove if off screen
		if (obs.y > 2732 + obstacleCarHeight) {
			obs.destroy();
			obstacles.splice(i, 1);
			continue;
		}
		// Collision detection
		if (playerCar.intersects(obs)) {
			gameOver();
			return;
		}
	}
	// Update score (distance)
	distance += speed;
	score = Math.floor(distance / 10) + score; // Add coin score to distance score
	// scoreTxt.setText(score);//{2B} (removed)
	// Gradually increase speed for difficulty
	if (LK.ticks % 180 === 0 && speed < 36) {
		speed += 1;
	}
};
// Spawn an obstacle car in a random lane
function spawnObstacle() {
	// Synchronize the red car (obstacle) to the blue car (player) on spawn
	var obs = new ObstacleCar();
	obs.x = playerCar.x;
	obs.y = -obstacleCarHeight / 2;
	obs.speedY = speed;
	obstacles.push(obs);
	game.addChild(obs);
}
// Game over logic
function gameOver() {
	isGameOver = true;
	LK.effects.flashScreen(0xff0000, 800);
	LK.showGameOver();
}
// Reset on game restart
game.on('reset', function () {
	// Remove all obstacles
	for (var i = 0; i < obstacles.length; i++) {
		obstacles[i].destroy();
	}
	obstacles = [];
	// Remove all coins
	for (var i = 0; i < coins.length; i++) {
		coins[i].destroy();
	}
	coins = [];
	// Remove all lane markings
	for (var i = 0; i < laneMarkings.length; i++) {
		laneMarkings[i].destroy();
	}
	laneMarkings = [];
	// Remove all trees
	for (var i = 0; i < trees.length; i++) {
		trees[i].destroy();
	}
	trees = [];
	// Recreate lane markings as dashed
	var dashLength = 80;
	var dashGap = 80;
	var dashesPerMarking = Math.floor(laneMarkingHeight / (dashLength + dashGap));
	for (var i = 0; i < laneCount - 1; i++) {
		for (var j = 0; j < Math.ceil(2732 / laneMarkingSpacing) + 2; j++) {
			var baseY = j * laneMarkingSpacing - laneMarkingHeight / 2;
			for (var d = 0; d < dashesPerMarking; d++) {
				var marking = new LaneMarking();
				marking.x = roadLeft + laneWidth * (i + 1);
				marking.y = baseY + d * (dashLength + dashGap);
				marking.speedY = speed;
				marking.height = dashLength;
				marking.width = laneMarkingWidth;
				laneMarkings.push(marking);
				game.addChild(marking);
			}
		}
	}
	// Recreate trees (slightly more trees)
	for (var side = 0; side < 2; side++) {
		var xPos = side === 0 ? roadLeft - treeWidth / 2 - 30 : roadRight + treeWidth / 2 + 30;
		for (var j = 0; j < 6; j++) {
			// 6 trees per side! 
			var tree = new Tree();
			tree.x = xPos;
			tree.y = j * (2732 / 6) + 100;
			tree.speedY = speed;
			trees.push(tree);
			game.addChild(tree);
		}
	}
	// Reset player position
	playerCar.x = laneCenters[1];
	playerCar.y = 2732 - 400;
	playerCar.speedX = 0;
	moveLeft = false;
	moveRight = false;
	updatePlayerSpeed();
	// Reset score and distance
	score = 0;
	distance = 0;
	// scoreTxt.setText('0'); (removed)
	isGameOver = false;
	speed = 18;
	obstacleSpawnTimer = 0;
});
// Prevent placing anything in top left 100x100 px (no code needed, just a reminder)

===================================================================
--- original.js
+++ change.js
@@ -95,28 +95,8 @@
 		if (self.x > roadRight - self.width / 2) self.x = roadRight - self.width / 2;
 	};
 	return self;
 });
-// Rare Coin for road (rarer, different color)
-var RareCoin = Container.expand(function () {
-	var self = Container.call(this);
-	// Use the same coin asset but tint it for visual difference
-	var coinAsset = self.attachAsset('coin', {
-		anchorX: 0.5,
-		anchorY: 0.5
-	});
-	coinAsset.width = coinWidth;
-	coinAsset.height = coinHeight;
-	self.width = coinAsset.width;
-	self.height = coinAsset.height;
-	self.speedY = 0;
-	// Tint to a blueish color for rare coin
-	coinAsset.tint = 0x44c0ff;
-	self.update = function () {
-		self.y += self.speedY;
-	};
-	return self;
-});
 // Tree for road edge
 var Tree = Container.expand(function () {
 	var self = Container.call(this);
 	var treeAsset = self.attachAsset('tree', {
@@ -294,18 +274,10 @@
 	// Spawn coins
 	coinSpawnTimer++;
 	if (coinSpawnTimer >= coinSpawnInterval) {
 		coinSpawnTimer = 0;
-		// 10% chance to spawn a rare coin, otherwise normal coin
-		var isRare = Math.random() < 0.10;
-		var coin;
-		if (isRare) {
-			coin = new RareCoin();
-			coin.isRare = true;
-		} else {
-			coin = new Coin();
-			coin.isRare = false;
-		}
+		// Spawn coin in a random lane
+		var coin = new Coin();
 		var laneIdx = Math.floor(Math.random() * laneCount);
 		coin.x = laneCenters[laneIdx];
 		coin.y = -coinHeight / 2;
 		coin.speedY = speed;
@@ -326,14 +298,9 @@
 		// Collect coin
 		if (playerCar.intersects(coin)) {
 			coin.destroy();
 			coins.splice(i, 1);
-			if (coin.isRare) {
-				score += 50; // Rare coin gives more points
-			} else {
-				score += 10; // Add 10 points for each normal coin
-			}
-			// scoreTxt.setText(score);//{2q} (removed)
+			score += 10; // Add 10 points for each coin
 			continue;
 		}
 	}
 	// Spawn obstacles