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

/**** 
* Classes
****/ 
var RaceCar = Container.expand(function (carAssetId, startZ) {
	var self = Container.call(this);
	var carGraphics = self.attachAsset(carAssetId, {
		anchorX: 0.5,
		anchorY: 1.0
	});
	self.worldZ = startZ || 0;
	self.worldX = 0;
	self.speed = 0;
	self.maxSpeed = 8;
	self.acceleration = 0.15;
	self.turnSpeed = 0;
	self.isPlayer = false;
	self.racePosition = 6;
	self.lapCount = 0;
	self.updatePosition = function (roadCurve, roadHill) {
		// Update world position based on speed
		self.worldZ += self.speed;
		// Apply road curve effect
		self.worldX += roadCurve * self.speed * 0.01;
		// Calculate perspective scale based on distance
		var perspective = Math.max(0.1, 1 - self.worldZ % 5000 / 5000);
		var screenScale = perspective * 0.8 + 0.2;
		// Position on screen
		self.scaleX = screenScale;
		self.scaleY = screenScale;
		var screenY = 2732 * 0.8 - (1 - perspective) * 600;
		var screenX = 1024 + self.worldX * perspective;
		self.x = screenX;
		self.y = screenY;
		// Hide cars that are too far or too close
		self.visible = perspective > 0.1 && perspective < 1;
	};
	return self;
});
var RoadSegment = Container.expand(function (z) {
	var self = Container.call(this);
	// Create grass background
	var grassGraphics = self.attachAsset('grass', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var roadGraphics = self.attachAsset('roadSegment', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Create center line
	var centerLine = self.attachAsset('centerLine', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Create side barriers
	var leftBarrier = self.attachAsset('sideBarrier', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	leftBarrier.x = -800;
	var rightBarrier = self.attachAsset('sideBarrier', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	rightBarrier.x = 800;
	self.worldZ = z;
	self.curve = 0;
	self.hill = 0;
	self.updateRoad = function (playerZ, roadCurve, roadHill) {
		var relativeZ = self.worldZ - playerZ;
		if (relativeZ < -500) {
			self.worldZ += 10000; // Loop road segments
			relativeZ = self.worldZ - playerZ;
		}
		if (relativeZ > 0 && relativeZ < 5000) {
			var perspective = Math.max(0.05, 1 - relativeZ / 5000);
			self.scaleX = perspective;
			self.scaleY = perspective * 0.1;
			var screenY = 2732 * 0.8 - (1 - perspective) * 600;
			var screenX = 1024;
			self.x = screenX;
			self.y = screenY;
			self.visible = true;
			// Update center line visibility (dashed effect)
			centerLine.visible = Math.floor(self.worldZ / 100) % 2 === 0;
			// Position barriers
			leftBarrier.x = -800 * perspective;
			rightBarrier.x = 800 * perspective;
		} else {
			self.visible = false;
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Game variables
var playerCar;
var aiCars = [];
var roadSegments = [];
var roadCurve = 0;
var roadHill = 0;
var currentLap = 1;
var totalLaps = 3;
var raceFinished = false;
var trackLength = 10000;
// UI elements
var speedText = new Text2('Speed: 0', {
	size: 60,
	fill: 0xFFFFFF
});
speedText.anchor.set(0, 0);
LK.gui.topLeft.addChild(speedText);
speedText.x = 120;
speedText.y = 20;
var positionText = new Text2('Position: 6/6', {
	size: 60,
	fill: 0xFFFFFF
});
positionText.anchor.set(1, 0);
LK.gui.topRight.addChild(positionText);
var lapText = new Text2('Lap: 1/3', {
	size: 60,
	fill: 0xFFFFFF
});
lapText.anchor.set(0.5, 0);
LK.gui.top.addChild(lapText);
// Create road segments
for (var i = 0; i < 100; i++) {
	var segment = new RoadSegment(i * 100);
	roadSegments.push(segment);
	game.addChild(segment);
}
// Create player car
playerCar = new RaceCar('playerCar', 0);
playerCar.isPlayer = true;
playerCar.speed = 6;
game.addChild(playerCar);
// Create AI cars
var aiAssets = ['aiCar1', 'aiCar2', 'aiCar3', 'aiCar4', 'aiCar5'];
for (var i = 0; i < 5; i++) {
	var aiCar = new RaceCar(aiAssets[i], (i + 1) * 200);
	aiCar.speed = 5 + Math.random() * 2;
	aiCar.maxSpeed = 6 + Math.random() * 3;
	aiCar.racePosition = i + 1;
	aiCars.push(aiCar);
	game.addChild(aiCar);
}
// Touch controls
var isSteeringLeft = false;
var isSteeringRight = false;
game.down = function (x, y, obj) {
	if (x < 1024) {
		isSteeringLeft = true;
		isSteeringRight = false;
	} else {
		isSteeringRight = true;
		isSteeringLeft = false;
	}
};
game.up = function (x, y, obj) {
	isSteeringLeft = false;
	isSteeringRight = false;
};
// Helper functions
function calculateRoadCurve(z) {
	return 0;
}
function calculateRoadHill(z) {
	return 0;
}
function updateRacePositions() {
	var allCars = [playerCar].concat(aiCars);
	// Sort cars by world Z position (distance traveled)
	allCars.sort(function (a, b) {
		var aProgress = a.lapCount * trackLength + a.worldZ;
		var bProgress = b.lapCount * trackLength + b.worldZ;
		return bProgress - aProgress;
	});
	// Update positions
	for (var i = 0; i < allCars.length; i++) {
		allCars[i].racePosition = i + 1;
	}
}
function checkLapCompletion() {
	// Check player lap
	if (playerCar.worldZ >= trackLength) {
		playerCar.worldZ -= trackLength;
		playerCar.lapCount++;
		currentLap = playerCar.lapCount + 1;
		if (playerCar.lapCount >= totalLaps) {
			raceFinished = true;
			if (playerCar.racePosition === 1) {
				LK.showYouWin();
			} else {
				LK.showGameOver();
			}
		}
	}
	// Check AI laps
	for (var i = 0; i < aiCars.length; i++) {
		if (aiCars[i].worldZ >= trackLength) {
			aiCars[i].worldZ -= trackLength;
			aiCars[i].lapCount++;
			if (aiCars[i].lapCount >= totalLaps && !raceFinished) {
				raceFinished = true;
				LK.showGameOver();
			}
		}
	}
}
// Main game loop
game.update = function () {
	if (raceFinished) return;
	// Calculate road properties
	roadCurve = calculateRoadCurve(playerCar.worldZ);
	roadHill = calculateRoadHill(playerCar.worldZ);
	// Handle player steering
	if (isSteeringLeft) {
		playerCar.turnSpeed = Math.max(-3, playerCar.turnSpeed - 0.2);
	} else if (isSteeringRight) {
		playerCar.turnSpeed = Math.min(3, playerCar.turnSpeed + 0.2);
	} else {
		playerCar.turnSpeed *= 0.9; // Gradual return to center
	}
	// Apply steering to player car
	playerCar.worldX += playerCar.turnSpeed;
	// Speed management for player
	var targetSpeed = playerCar.maxSpeed - Math.abs(playerCar.turnSpeed) * 0.5;
	if (playerCar.speed < targetSpeed) {
		playerCar.speed += playerCar.acceleration;
	} else {
		playerCar.speed -= playerCar.acceleration * 0.5;
	}
	// Update AI cars
	for (var i = 0; i < aiCars.length; i++) {
		var ai = aiCars[i];
		// Simple AI behavior with more variation
		ai.speed += (ai.maxSpeed - ai.speed) * 0.1;
		// AI steering based on road curve and racing line
		var racingLine = Math.sin(ai.worldZ * 0.0003) * 100;
		var targetX = roadCurve * 0.8 + racingLine;
		var steerForce = (targetX - ai.worldX) * 0.05;
		ai.worldX += steerForce + (Math.random() - 0.5) * 1;
		// Keep AI cars on track with stronger boundaries
		if (Math.abs(ai.worldX) > 600) {
			ai.worldX *= 0.85;
			ai.speed *= 0.95; // Slow down when off track
		}
		// AI collision avoidance with other cars
		for (var j = 0; j < aiCars.length; j++) {
			if (i !== j) {
				var otherCar = aiCars[j];
				var distX = Math.abs(ai.worldX - otherCar.worldX);
				var distZ = Math.abs(ai.worldZ - otherCar.worldZ);
				if (distX < 80 && distZ < 150) {
					// Avoid collision by steering away
					if (ai.worldX < otherCar.worldX) {
						ai.worldX -= 3;
					} else {
						ai.worldX += 3;
					}
					ai.speed *= 0.98;
				}
			}
		}
		// Check collision with player
		var playerDistX = Math.abs(ai.worldX - playerCar.worldX);
		var playerDistZ = Math.abs(ai.worldZ - playerCar.worldZ);
		if (playerDistX < 80 && playerDistZ < 150) {
			// Both cars slow down on collision
			ai.speed *= 0.9;
			playerCar.speed *= 0.9;
			LK.getSound('overtake').play();
		}
	}
	// Update all car positions
	playerCar.updatePosition(roadCurve, roadHill);
	for (var i = 0; i < aiCars.length; i++) {
		aiCars[i].updatePosition(roadCurve, roadHill);
	}
	// Update road segments
	for (var i = 0; i < roadSegments.length; i++) {
		roadSegments[i].updateRoad(playerCar.worldZ, roadCurve, roadHill);
	}
	// Update race positions and check laps
	updateRacePositions();
	checkLapCompletion();
	// Speed boost zones
	var boostZone = Math.floor(playerCar.worldZ / 1000) % 5 === 0;
	if (boostZone && playerCar.speed < playerCar.maxSpeed * 1.2) {
		playerCar.speed += 0.3;
		// Visual feedback for boost
		if (LK.ticks % 10 === 0) {
			LK.effects.flashObject(playerCar, 0x00ff00, 200);
		}
	}
	// Dynamic road difficulty
	var difficultyZone = Math.floor(playerCar.worldZ / 2000);
	roadCurve *= 1 + difficultyZone * 0.1;
	// Update UI with better formatting
	var speedDisplay = Math.round(playerCar.speed * 10);
	speedText.setText('Speed: ' + speedDisplay + ' km/h');
	positionText.setText('Position: ' + playerCar.racePosition + '/6');
	lapText.setText('Lap: ' + Math.min(currentLap, totalLaps) + '/' + totalLaps);
	// Dynamic UI colors based on performance
	if (playerCar.racePosition === 1) {
		speedText.tint = 0x00ff00; // Green for first place
		positionText.tint = 0x00ff00;
	} else if (playerCar.racePosition <= 3) {
		speedText.tint = 0xffff00; // Yellow for top 3
		positionText.tint = 0xffff00;
	} else {
		speedText.tint = 0xff0000; // Red for lower positions
		positionText.tint = 0xff0000;
	}
	// Play engine sound with speed variation
	if (LK.ticks % 45 === 0) {
		var engineSound = LK.getSound('engine');
		engineSound.play();
	}
	// Play overtake sound when position changes
	if (playerCar.lastPosition === undefined) {
		playerCar.lastPosition = playerCar.racePosition;
	}
	if (playerCar.racePosition < playerCar.lastPosition) {
		LK.getSound('overtake').play();
		LK.effects.flashScreen(0x00ff00, 500);
	}
	playerCar.lastPosition = playerCar.racePosition;
};

===================================================================
--- original.js
+++ change.js
@@ -32,15 +32,13 @@
 		// Position on screen
 		self.scaleX = screenScale;
 		self.scaleY = screenScale;
 		var screenY = 2732 * 0.8 - (1 - perspective) * 600;
-		var screenX = 1024 + (self.worldX - roadCurve * 300) * perspective;
+		var screenX = 1024 + self.worldX * perspective;
 		self.x = screenX;
 		self.y = screenY;
 		// Hide cars that are too far or too close
 		self.visible = perspective > 0.1 && perspective < 1;
-		// Apply hill effect
-		self.y += Math.sin(self.worldZ * 0.001) * roadHill * perspective * 50;
 	};
 	return self;
 });
 var RoadSegment = Container.expand(function (z) {
@@ -83,11 +81,11 @@
 			var perspective = Math.max(0.05, 1 - relativeZ / 5000);
 			self.scaleX = perspective;
 			self.scaleY = perspective * 0.1;
 			var screenY = 2732 * 0.8 - (1 - perspective) * 600;
-			var screenX = 1024 + roadCurve * (1 - perspective) * 300;
+			var screenX = 1024;
 			self.x = screenX;
-			self.y = screenY + Math.sin(self.worldZ * 0.001) * roadHill * perspective * 50;
+			self.y = screenY;
 			self.visible = true;
 			// Update center line visibility (dashed effect)
 			centerLine.visible = Math.floor(self.worldZ / 100) % 2 === 0;
 			// Position barriers
@@ -179,12 +177,12 @@
 	isSteeringRight = false;
 };
 // Helper functions
 function calculateRoadCurve(z) {
-	return Math.sin(z * 0.0005) * 100 + Math.sin(z * 0.0008) * 50;
+	return 0;
 }
 function calculateRoadHill(z) {
-	return Math.sin(z * 0.0003) * 0.5;
+	return 0;
 }
 function updateRacePositions() {
 	var allCars = [playerCar].concat(aiCars);
 	// Sort cars by world Z position (distance traveled)