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

/**** 
* Classes
****/ 
var PlayerCar = Container.expand(function () {
	var self = Container.call(this);
	var carGraphics = self.attachAsset('playerCar', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.currentLane = 1; // 0 = left, 1 = center, 2 = right
	self.targetX = 0;
	self.speed = 0;
	self.maxSpeed = 15;
	self.gear = 1;
	self.nitroBoost = 0;
	self.tuningLevel = 1;
	self.update = function () {
		// Smooth lane switching with steering animation
		if (Math.abs(self.x - self.targetX) > 2) {
			self.x += (self.targetX - self.x) * 0.15;
			// Add steering tilt based on movement direction
			var steerDirection = self.targetX - self.x;
			carGraphics.rotation = Math.max(-0.15, Math.min(0.15, steerDirection * 0.001));
		} else {
			// Return to straight position when not steering
			carGraphics.rotation *= 0.9;
		}
		// Update speed based on gear and power-ups
		var baseSpeed = 8 + self.gear * 2;
		if (self.nitroBoost > 0) {
			baseSpeed *= 1.5;
			self.nitroBoost--;
			// Add nitro visual effect
			if (self.nitroBoost % 10 === 0) {
				LK.effects.flashObject(carGraphics, 0x00ccff, 200);
			}
		}
		self.speed = Math.min(baseSpeed * self.tuningLevel, self.maxSpeed);
		// Update gear based on speed
		var newGear = Math.floor(self.speed / 3) + 1;
		if (newGear > self.gear) {
			self.gear = newGear;
			updateGearDisplay();
			// Flash for gear change
			LK.effects.flashObject(carGraphics, 0xffff00, 300);
		}
	};
	self.switchLane = function (direction) {
		if (direction === 'left' && self.currentLane > 0) {
			self.currentLane--;
		} else if (direction === 'right' && self.currentLane < 2) {
			self.currentLane++;
		}
		self.targetX = getLaneX(self.currentLane);
	};
	return self;
});
var PowerUp = Container.expand(function (powerUpType) {
	var self = Container.call(this);
	var powerUpGraphics = self.attachAsset(powerUpType, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.powerUpType = powerUpType;
	self.speed = 4;
	self.bobOffset = Math.random() * Math.PI * 2;
	self.bobSpeed = 0.1;
	self.update = function () {
		self.y += self.speed;
		// Bobbing animation
		self.bobOffset += self.bobSpeed;
		powerUpGraphics.y = Math.sin(self.bobOffset) * 5;
	};
	return self;
});
var RoadElement = Container.expand(function (elementType) {
	var self = Container.call(this);
	var elementGraphics = self.attachAsset(elementType, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 5;
	self.update = function () {
		self.y += self.speed;
	};
	return self;
});
var TrafficVehicle = Container.expand(function (vehicleType) {
	var self = Container.call(this);
	var vehicleGraphics = self.attachAsset(vehicleType, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Apply realistic proportions based on vehicle type
	switch (vehicleType) {
		case 'bus':
			vehicleGraphics.width = 135;
			vehicleGraphics.height = 300;
			break;
		case 'truck':
			vehicleGraphics.width = 150;
			vehicleGraphics.height = 330;
			break;
		case 'fireTruck':
			vehicleGraphics.width = 135;
			vehicleGraphics.height = 270;
			break;
		case 'enemyCar':
		case 'policeCar':
			vehicleGraphics.width = 120;
			vehicleGraphics.height = 210;
			break;
		case 'van':
			vehicleGraphics.width = 110;
			vehicleGraphics.height = 240;
			break;
		case 'motorcycle':
			vehicleGraphics.width = 60;
			vehicleGraphics.height = 120;
			break;
	}
	self.vehicleType = vehicleType;
	self.speed = 3 + Math.random() * 4;
	self.currentLane = Math.floor(Math.random() * 3);
	self.targetX = getLaneX(self.currentLane);
	self.laneChangeTimer = 0;
	self.laneChangeDelay = 120 + Math.random() * 240;
	self.update = function () {
		// Move vehicle forward
		self.y += self.speed;
		// Smooth lane switching with steering animation
		if (Math.abs(self.x - self.targetX) > 2) {
			self.x += (self.targetX - self.x) * 0.1;
			// Add subtle steering rotation
			var steerDirection = self.targetX - self.x;
			vehicleGraphics.rotation = Math.max(-0.08, Math.min(0.08, steerDirection * 0.0005));
		} else {
			// Return to straight position
			vehicleGraphics.rotation *= 0.95;
		}
		// Add subtle engine vibration for larger vehicles
		if (self.vehicleType === 'truck' || self.vehicleType === 'bus') {
			vehicleGraphics.x = Math.sin(LK.ticks * 0.1) * 0.5;
		}
		// Occasional lane switching
		self.laneChangeTimer++;
		if (self.laneChangeTimer > self.laneChangeDelay && Math.random() < 0.02) {
			var newLane = Math.floor(Math.random() * 3);
			if (newLane !== self.currentLane) {
				self.currentLane = newLane;
				self.targetX = getLaneX(self.currentLane);
				self.laneChangeTimer = 0;
				self.laneChangeDelay = 120 + Math.random() * 240;
			}
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Game variables
var player;
var trafficVehicles = [];
var powerUps = [];
var roadElements = [];
var roadLines = [];
var gameSpeed = 1;
var distanceTraveled = 0;
var spawnTimer = 0;
var powerUpSpawnTimer = 0;
var environmentSpawnTimer = 0;
var roadLineSpawnTimer = 0;
var pedestrianSpawnTimer = 0;
// Lane positions - realistic 3.5m wide lanes (scaled to game coordinates)
var lanePositions = [2048 / 2 - 420,
// Left lane
2048 / 2,
// Center lane
2048 / 2 + 420 // Right lane
];
function getLaneX(lane) {
	return lanePositions[lane];
}
// Create road background with realistic asphalt appearance
var roadBackground = LK.getAsset('roadLane', {
	anchorX: 0.5,
	anchorY: 0.5,
	scaleY: 30
});
roadBackground.x = 2048 / 2;
roadBackground.y = 2732 / 2;
game.addChild(roadBackground);
// Create road shoulders
var leftShoulder = LK.getAsset('roadShoulder', {
	anchorX: 0.5,
	anchorY: 0.5,
	scaleY: 30
});
leftShoulder.x = 2048 / 2 - 840;
leftShoulder.y = 2732 / 2;
game.addChild(leftShoulder);
var rightShoulder = LK.getAsset('roadShoulder', {
	anchorX: 0.5,
	anchorY: 0.5,
	scaleY: 30
});
rightShoulder.x = 2048 / 2 + 840;
rightShoulder.y = 2732 / 2;
game.addChild(rightShoulder);
// Create player car
player = new PlayerCar();
player.x = getLaneX(1);
player.y = 2732 - 300;
game.addChild(player);
// UI Elements
var speedText = new Text2('Speed: 0 KM/H', {
	size: 60,
	fill: '#ffffff'
});
speedText.anchor.set(0, 0);
speedText.x = 200;
speedText.y = 50;
LK.gui.topLeft.addChild(speedText);
var gearText = new Text2('Gear: 1', {
	size: 60,
	fill: '#ffffff'
});
gearText.anchor.set(1, 0);
gearText.x = -200;
gearText.y = 50;
LK.gui.topRight.addChild(gearText);
var scoreText = new Text2('Distance: 0m', {
	size: 50,
	fill: '#ffffff'
});
scoreText.anchor.set(0.5, 0);
scoreText.x = 0;
scoreText.y = 120;
LK.gui.top.addChild(scoreText);
function updateGearDisplay() {
	gearText.setText('Gear: ' + player.gear);
}
// Touch controls
game.down = function (x, y, obj) {
	if (x < 2048 / 2) {
		// Left tap - switch left
		player.switchLane('left');
	} else {
		// Right tap - switch right
		player.switchLane('right');
	}
};
// Spawn traffic vehicles
function spawnTrafficVehicle() {
	var vehicleTypes = ['enemyCar', 'bus', 'truck', 'policeCar', 'fireTruck'];
	var vehicleType = vehicleTypes[Math.floor(Math.random() * vehicleTypes.length)];
	var vehicle = new TrafficVehicle(vehicleType);
	vehicle.x = getLaneX(vehicle.currentLane);
	vehicle.y = -100;
	vehicle.speed += gameSpeed;
	// Check for nearby vehicles in the same lane to maintain spacing
	var tooClose = false;
	for (var i = 0; i < trafficVehicles.length; i++) {
		var existingVehicle = trafficVehicles[i];
		if (Math.abs(existingVehicle.x - vehicle.x) < 150 &&
		// Same lane (within 150px)
		existingVehicle.y < 350 && existingVehicle.y > -400) {
			// Within spawn safety zone
			tooClose = true;
			break;
		}
	}
	// Only spawn if there's enough space
	if (!tooClose) {
		trafficVehicles.push(vehicle);
		game.addChild(vehicle);
	} else {
		// Don't spawn, try again next frame
		vehicle.destroy();
	}
}
// Spawn power-ups
function spawnPowerUp() {
	var powerUpTypes = ['fuelPowerUp', 'nitroPowerUp', 'tuningPowerUp'];
	var powerUpType = powerUpTypes[Math.floor(Math.random() * powerUpTypes.length)];
	var powerUp = new PowerUp(powerUpType);
	powerUp.x = getLaneX(Math.floor(Math.random() * 3));
	powerUp.y = -50;
	powerUps.push(powerUp);
	game.addChild(powerUp);
}
// Spawn road elements
function spawnRoadElement() {
	var elementTypes = ['roadSign', 'tree'];
	var elementType = elementTypes[Math.floor(Math.random() * elementTypes.length)];
	var element = new RoadElement(elementType);
	// Place on road shoulders with proper spacing
	element.x = Math.random() < 0.5 ? 2048 / 2 - 900 : 2048 / 2 + 900; // Roadside shoulders
	element.y = -50;
	roadElements.push(element);
	game.addChild(element);
}
// Spawn pedestrians
function spawnPedestrian() {
	var pedestrian = new RoadElement('pedestrian');
	// Place pedestrians on far roadside (sidewalk areas)
	pedestrian.x = Math.random() < 0.5 ? 2048 / 2 - 1000 : 2048 / 2 + 1000;
	pedestrian.y = -30;
	pedestrian.speed = 1 + Math.random() * 2; // Slower than vehicles
	roadElements.push(pedestrian);
	game.addChild(pedestrian);
}
// Spawn road lines
function spawnRoadLine() {
	// Left lane divider (between left and center lanes)
	var leftLine = new RoadElement('roadLine');
	leftLine.x = 2048 / 2 - 210;
	leftLine.y = -40;
	// Add subtle fade in animation
	leftLine.alpha = 0;
	tween(leftLine).to({
		alpha: 1
	}, 300).start();
	roadLines.push(leftLine);
	game.addChild(leftLine);
	// Right lane divider (between center and right lanes)
	var rightLine = new RoadElement('roadLine');
	rightLine.x = 2048 / 2 + 210;
	rightLine.y = -40;
	// Add subtle fade in animation
	rightLine.alpha = 0;
	tween(rightLine).to({
		alpha: 1
	}, 300).start();
	roadLines.push(rightLine);
	game.addChild(rightLine);
}
// Handle power-up collection
function collectPowerUp(powerUp) {
	// Add visual collection effect
	LK.effects.flashObject(powerUp, 0x00ff00, 300);
	tween(powerUp).to({
		scaleX: 1.5,
		scaleY: 1.5,
		alpha: 0
	}, 300).start();
	switch (powerUp.powerUpType) {
		case 'fuelPowerUp':
			// Fuel extends game time or boosts score
			LK.setScore(LK.getScore() + 50);
			// Flash player car green for fuel
			LK.effects.flashObject(player, 0x00ff00, 500);
			break;
		case 'nitroPowerUp':
			player.nitroBoost = 180; // 3 seconds of boost
			// Flash player car blue for nitro
			LK.effects.flashObject(player, 0x0099ff, 500);
			break;
		case 'tuningPowerUp':
			player.tuningLevel = Math.min(player.tuningLevel + 0.1, 2.0);
			// Flash player car purple for tuning
			LK.effects.flashObject(player, 0x9b59b6, 500);
			break;
	}
	LK.getSound('powerUpCollect').play();
}
// Main game loop
game.update = function () {
	// Update distance traveled
	distanceTraveled += player.speed * 0.1;
	// Update speed display
	var speedKmh = Math.floor(player.speed * 10);
	speedText.setText('Speed: ' + speedKmh + ' KM/H');
	scoreText.setText('Distance: ' + Math.floor(distanceTraveled) + 'm');
	// Increase game difficulty over time
	gameSpeed = 1 + distanceTraveled / 1000;
	// Spawn traffic vehicles
	spawnTimer++;
	if (spawnTimer > Math.max(60 - gameSpeed * 5, 20)) {
		spawnTrafficVehicle();
		spawnTimer = 0;
	}
	// Spawn power-ups
	powerUpSpawnTimer++;
	if (powerUpSpawnTimer > 300 + Math.random() * 300) {
		spawnPowerUp();
		powerUpSpawnTimer = 0;
	}
	// Spawn road elements
	environmentSpawnTimer++;
	if (environmentSpawnTimer > 90 + Math.random() * 60) {
		spawnRoadElement();
		environmentSpawnTimer = 0;
	}
	// Spawn road lines
	roadLineSpawnTimer++;
	if (roadLineSpawnTimer > 40) {
		spawnRoadLine();
		roadLineSpawnTimer = 0;
	}
	// Spawn pedestrians occasionally
	pedestrianSpawnTimer++;
	if (pedestrianSpawnTimer > 200 + Math.random() * 400) {
		spawnPedestrian();
		pedestrianSpawnTimer = 0;
	}
	// Update and clean up traffic vehicles
	for (var i = trafficVehicles.length - 1; i >= 0; i--) {
		var vehicle = trafficVehicles[i];
		// Check collision with player
		if (vehicle.intersects(player)) {
			LK.getSound('carCrash').play();
			// Enhanced crash effect with multiple flashes
			LK.effects.flashScreen(0xff0000, 1000);
			LK.effects.flashObject(player, 0xff0000, 800);
			LK.effects.flashObject(vehicle, 0xff0000, 800);
			// Screen shake effect
			tween(game).to({
				x: 10
			}, 50).to({
				x: -10
			}, 50).to({
				x: 5
			}, 50).to({
				x: -5
			}, 50).to({
				x: 0
			}, 50).start();
			LK.showGameOver();
			return;
		}
		// Check collisions between traffic vehicles
		for (var j = trafficVehicles.length - 1; j >= 0; j--) {
			if (i !== j) {
				var otherVehicle = trafficVehicles[j];
				if (vehicle.intersects(otherVehicle)) {
					// Create enhanced crash effect
					LK.effects.flashObject(vehicle, 0xff0000, 500);
					LK.effects.flashObject(otherVehicle, 0xff0000, 500);
					// Add explosion-like scaling effect
					tween(vehicle).to({
						scaleX: 1.3,
						scaleY: 1.3
					}, 100).to({
						scaleX: 1,
						scaleY: 1
					}, 100).start();
					tween(otherVehicle).to({
						scaleX: 1.3,
						scaleY: 1.3
					}, 100).to({
						scaleX: 1,
						scaleY: 1
					}, 100).start();
					LK.getSound('carCrash').play();
					// Remove both vehicles involved in crash
					vehicle.destroy();
					otherVehicle.destroy();
					trafficVehicles.splice(i, 1);
					// Adjust index for removed vehicle
					var otherIndex = trafficVehicles.indexOf(otherVehicle);
					if (otherIndex > -1) {
						trafficVehicles.splice(otherIndex, 1);
						if (otherIndex < i) {
							i--;
						} // Adjust current index if needed
					}
					break; // Exit inner loop since vehicle is destroyed
				}
			}
		}
		// Remove off-screen vehicles
		if (vehicle.y > 2732 + 100) {
			vehicle.destroy();
			trafficVehicles.splice(i, 1);
			// Award points for successful overtake
			LK.setScore(LK.getScore() + 10);
		}
	}
	// Update and clean up power-ups
	for (var i = powerUps.length - 1; i >= 0; i--) {
		var powerUp = powerUps[i];
		// Check collection
		if (powerUp.intersects(player)) {
			collectPowerUp(powerUp);
			powerUp.destroy();
			powerUps.splice(i, 1);
			continue;
		}
		// Remove off-screen power-ups
		if (powerUp.y > 2732 + 50) {
			powerUp.destroy();
			powerUps.splice(i, 1);
		}
	}
	// Update and clean up road elements
	for (var i = roadElements.length - 1; i >= 0; i--) {
		var element = roadElements[i];
		// Add speed-based movement for visual effect
		element.speed = 5 + gameSpeed * 2;
		// Add subtle sway animation to trees
		if (element.elementType === 'tree') {
			element.x += Math.sin(LK.ticks * 0.02 + element.y * 0.01) * 0.3;
		}
		if (element.y > 2732 + 100) {
			element.destroy();
			roadElements.splice(i, 1);
		}
	}
	// Update and clean up road lines
	for (var i = roadLines.length - 1; i >= 0; i--) {
		var line = roadLines[i];
		if (line.y > 2732 + 100) {
			line.destroy();
			roadLines.splice(i, 1);
		}
	}
	// Update final score
	LK.setScore(Math.floor(distanceTraveled));
};

===================================================================
--- original.js
+++ change.js
@@ -474,9 +474,11 @@
 					// Adjust index for removed vehicle
 					var otherIndex = trafficVehicles.indexOf(otherVehicle);
 					if (otherIndex > -1) {
 						trafficVehicles.splice(otherIndex, 1);
-						if (otherIndex < i) i--; // Adjust current index if needed
+						if (otherIndex < i) {
+							i--;
+						} // Adjust current index if needed
 					}
 					break; // Exit inner loop since vehicle is destroyed
 				}
 			}