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

/**** 
* Classes
****/ 
// 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 = 120;
var treeHeight = 180;
var treeSpacing = 220;
// Asset initialization (shapes)
// Game variables
var playerCar;
var obstacles = [];
var laneMarkings = [];
var trees = [];
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
var scoreTxt = new Text2('0', {
	size: 120,
	fill: 0xFFFFFF
});
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
// 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 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);
	scoreTxt.setText(score);
	// 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 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');
	isGameOver = false;
	speed = 18;
	obstacleSpawnTimer = 0;
});
// Prevent placing anything in top left 100x100 px (no code needed, just a reminder)

===================================================================
--- original.js
+++ change.js
@@ -111,13 +111,13 @@
 // 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 smaller)
-var playerCarWidth = 160;
-var playerCarHeight = 256;
-var obstacleCarWidth = 160;
-var obstacleCarHeight = 256;
+// 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