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

/**** 
* Classes
****/ 
var EnemyCar = Container.expand(function () {
	var self = Container.call(this);
	var enemyCarGraphics = self.attachAsset('Cars', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Assign random color (excluding red)
	var enemyColors = [0x0066ff,
	// Blue
	0x00ff66,
	// Green
	0xffff00,
	// Yellow
	0xff8800,
	// Orange
	0x8800ff,
	// Purple
	0x00ffff,
	// Cyan
	0xff00ff,
	// Magenta
	0x888888,
	// Gray
	0xffffff // White
	];
	var randomColorIndex = Math.floor(Math.random() * enemyColors.length);
	enemyCarGraphics.tint = enemyColors[randomColorIndex];
	// Basic properties for enemy car with weight
	self.velocityX = 0;
	self.velocityY = 0;
	self.rotation = 0;
	self.weight = 1.0 + Math.random() * 1.5; // Random weight between 1.0 and 2.5
	return self;
});
var Particle = Container.expand(function () {
	var self = Container.call(this);
	// Random particle size between 10.8-25.2 pixels (20% smaller than original)
	var particleSize = 10.8 + Math.random() * 14.4;
	var particleGraphics = self.attachAsset('ParticulasVel', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: particleSize / 30,
		scaleY: particleSize / 30
	});
	// Random initial properties (20% smaller velocities)
	self.velocityX = (Math.random() - 0.5) * 3.2;
	self.velocityY = Math.random() * 2.4 + 0.8;
	self.lifespan = 20 + Math.random() * 20; // Reduced lifespan: 0.33-0.67 seconds at 60fps
	self.age = 0;
	self.update = function () {
		// Update position
		self.x += self.velocityX;
		self.y += self.velocityY;
		// Age particle
		self.age++;
		// Fade out over time
		var fadeProgress = self.age / self.lifespan;
		particleGraphics.alpha = 1 - fadeProgress;
		// Scale down over time
		var scaleProgress = 1 - fadeProgress * 0.5;
		particleGraphics.scaleX = particleSize / 30 * scaleProgress;
		particleGraphics.scaleY = particleSize / 30 * scaleProgress;
		// Apply gravity and air resistance (20% reduced for smaller scale)
		self.velocityY += 0.08; // Reduced gravity
		self.velocityX *= 0.984; // Slightly less air resistance
		self.velocityY *= 0.984;
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Create gameplay background - 4/5 of screen height (top portion)
6;
var gameplayBackground = game.attachAsset('gameplayBg', {
	x: 0,
	y: 0,
	anchorX: 0,
	anchorY: 0
});
// Create carPlayer character on top of gameplayBackground
var carPlayer = gameplayBackground.attachAsset('CarPlayer', {
	x: 1024,
	// Center horizontally
	y: 1800,
	// Position in lower portion of gameplay area
	anchorX: 0.5,
	anchorY: 0.5
});
// Create array to store multiple enemy cars
var enemyCars = [];
var numEnemyCars = 3 + Math.floor(Math.random() * 3); // Random between 3-5 cars
// Create multiple enemy cars in gameplay area at random positions
for (var carIndex = 0; carIndex < numEnemyCars; carIndex++) {
	var enemyCar = new EnemyCar();
	// Generate random position around the edges or inside the gameplay area
	var spawnSide = Math.floor(Math.random() * 4); // 0=top, 1=right, 2=bottom, 3=left
	var centerX = 1024; // Center of gameplay area
	var centerY = 1093; // Center of gameplay area (2186/2)
	switch (spawnSide) {
		case 0:
		case 0:
			// Top edge
			enemyCar.x = Math.random() * 1800 + 124; // Random X between 124-1924
			enemyCar.y = Math.random() * 300 + 50; // Random Y between 50-350
			break;
		case 1:
			// Right edge
			enemyCar.x = Math.random() * 300 + 1700; // Random X between 1700-2000
			enemyCar.y = Math.random() * 1800 + 193; // Random Y between 193-1993
			break;
		case 2:
			// Bottom edge
			enemyCar.x = Math.random() * 1800 + 124; // Random X between 124-1924
			enemyCar.y = Math.random() * 300 + 1836; // Random Y between 1836-2136
			break;
		case 3:
			// Left edge
			enemyCar.x = Math.random() * 300 + 50; // Random X between 50-350
			enemyCar.y = Math.random() * 1800 + 193; // Random Y between 193-1993
			break;
	}
	// Calculate rotation to face the center
	var deltaX = centerX - enemyCar.x;
	var deltaY = centerY - enemyCar.y;
	enemyCar.rotation = Math.atan2(deltaX, -deltaY); // Rotation to face center
	// Assign unique AI personality and preferred attack mode
	var personalityTypes = [{
		name: "Aggressive Hunter",
		preferredStrategy: 0,
		// Direct pursuit
		aggressiveness: 0.9,
		patience: 0.2,
		followChance: 0.95,
		speedMultiplier: 1.1,
		rotationSpeedMultiplier: 1.2
	}, {
		name: "Sneaky Stalker",
		preferredStrategy: 1,
		// Varied/intimidation approach
		aggressiveness: 0.4,
		patience: 0.8,
		followChance: 0.75,
		speedMultiplier: 0.85,
		rotationSpeedMultiplier: 0.9
	}, {
		name: "Strategic Ambusher",
		preferredStrategy: 2,
		// Ambush tactics
		aggressiveness: 0.7,
		patience: 0.9,
		followChance: 0.85,
		speedMultiplier: 0.95,
		rotationSpeedMultiplier: 1.0
	}, {
		name: "Reckless Rambler",
		preferredStrategy: -1,
		// Prefers free roam but aggressive when following
		aggressiveness: 0.6,
		patience: 0.3,
		followChance: 0.4,
		speedMultiplier: 1.05,
		rotationSpeedMultiplier: 1.3
	}, {
		name: "Persistent Pursuer",
		preferredStrategy: 0,
		// Direct pursuit but more patient
		aggressiveness: 0.8,
		patience: 0.95,
		followChance: 0.9,
		speedMultiplier: 1.0,
		rotationSpeedMultiplier: 0.8
	}];
	// Assign personality based on car index to ensure variety
	var personalityIndex = carIndex % personalityTypes.length;
	enemyCar.personality = personalityTypes[personalityIndex];
	// Set individual car preferences based on personality
	enemyCar.preferredStrategy = enemyCar.personality.preferredStrategy;
	enemyCar.aggressiveness = enemyCar.personality.aggressiveness;
	enemyCar.patience = enemyCar.personality.patience;
	enemyCar.baseFollowChance = enemyCar.personality.followChance;
	enemyCar.speedMultiplier = enemyCar.personality.speedMultiplier;
	enemyCar.rotationSpeedMultiplier = enemyCar.personality.rotationSpeedMultiplier;
	// Add to array and scene
	enemyCars.push(enemyCar);
	gameplayBackground.addChild(enemyCar);
}
// For backward compatibility, keep reference to first enemy car
var enemyCar = enemyCars[0];
// Create UI background - 1/5 of screen height (bottom portion)
var uiBackground = game.attachAsset('uiBg', {
	x: 0,
	y: 2186,
	anchorX: 0,
	anchorY: 0
});
// Create speed display text
var speedText = new Text2('Speed: 0', {
	size: 60,
	fill: 0x000000
});
speedText.anchor.set(0, 0.5);
speedText.x = 50;
speedText.y = 2459; // Center vertically in UI area
game.addChild(speedText);
// Create joystickBG centered in UI background
var joystickBG = uiBackground.attachAsset('JoystickBG', {
	x: 1024,
	// Center horizontally in UI
	y: 273,
	// Center vertically in UI (546/2 = 273)
	anchorX: 0.5,
	anchorY: 0.5
});
// Create point object that will follow touch position
var point = null;
// Create JoystickPoinr that will follow point position smoothly
var joystickPoinr = game.attachAsset('JoystickPoinr', {
	x: 1024,
	y: 2459,
	anchorX: 0.5,
	anchorY: 0.5
});
// Variables for smooth movement
var targetX = 1024;
var targetY = 2459;
var smoothSpeed = 0.2;
// Variables for smooth rotation
var targetRotation = 0;
var baseRotationSpeed = 0.052;
// Variables for realistic car physics
var currentVelocity = 0;
var acceleration = 0.16;
var deceleration = 0.44;
var maxSpeed = 15.36;
// Variables for drift physics
var velocityX = 0;
var velocityY = 0;
var driftFactor = 0.85; // How much momentum is retained (lower = more drift)
var gripFactor = 0.3; // How quickly car aligns with direction (lower = more drift)
// Player car weight
var playerCarWeight = 1.2; // Player car is moderately heavy
// Handle touch down - create and show point
game.down = function (x, y, obj) {
	// Create point at touch position
	point = game.attachAsset('Puntero', {
		x: x,
		y: y,
		anchorX: 0.5,
		anchorY: 0.5
	});
};
// Handle touch move - update point position
game.move = function (x, y, obj) {
	if (point) {
		point.x = x;
		point.y = y;
		// Calculate joystickBG world position
		var joystickWorldX = joystickBG.x + uiBackground.x;
		var joystickWorldY = joystickBG.y + uiBackground.y;
		// Calculate distance from joystick center
		var deltaX = x - joystickWorldX;
		var deltaY = y - joystickWorldY;
		var distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
		var maxRadius = joystickBG.width / 2;
		// Limit movement to joystick radius
		if (distance > maxRadius) {
			var angle = Math.atan2(deltaY, deltaX);
			deltaX = Math.cos(angle) * maxRadius;
			deltaY = Math.sin(angle) * maxRadius;
		}
		// Update target position for smooth movement (constrained)
		targetX = joystickWorldX + deltaX;
		targetY = joystickWorldY + deltaY;
	}
};
// Handle touch up - remove point
game.up = function (x, y, obj) {
	if (point) {
		point.destroy();
		point = null;
		// Reset target position to joystick center
		var joystickWorldX = joystickBG.x + uiBackground.x;
		var joystickWorldY = joystickBG.y + uiBackground.y;
		targetX = joystickWorldX;
		targetY = joystickWorldY;
	}
};
// Update function for smooth movement
game.update = function () {
	// Smoothly move JoystickPoinr towards target position
	var deltaX = targetX - joystickPoinr.x;
	var deltaY = targetY - joystickPoinr.y;
	joystickPoinr.x += deltaX * smoothSpeed;
	joystickPoinr.y += deltaY * smoothSpeed;
	// Double-check that joystickPoinr stays within bounds
	var joystickWorldX = joystickBG.x + uiBackground.x;
	var joystickWorldY = joystickBG.y + uiBackground.y;
	var currentDeltaX = joystickPoinr.x - joystickWorldX;
	var currentDeltaY = joystickPoinr.y - joystickWorldY;
	var currentDistance = Math.sqrt(currentDeltaX * currentDeltaX + currentDeltaY * currentDeltaY);
	var maxRadius = joystickBG.width / 2;
	if (currentDistance > maxRadius) {
		var angle = Math.atan2(currentDeltaY, currentDeltaX);
		joystickPoinr.x = joystickWorldX + Math.cos(angle) * maxRadius;
		joystickPoinr.y = joystickWorldY + Math.sin(angle) * maxRadius;
	}
	// Update car rotation based on joystick position
	var joystickOffsetX = joystickPoinr.x - joystickWorldX;
	var joystickOffsetY = joystickPoinr.y - joystickWorldY;
	var joystickDistance = Math.sqrt(joystickOffsetX * joystickOffsetX + joystickOffsetY * joystickOffsetY);
	// Calculate power based on distance from center (0 to 1)
	var power = Math.min(joystickDistance / maxRadius, 1);
	// Only rotate if joystick is moved significantly from center
	if (joystickDistance > 10) {
		var joystickAngle = Math.atan2(joystickOffsetX, -joystickOffsetY);
		targetRotation = joystickAngle;
	}
	// Smoothly interpolate car rotation towards target
	var rotationDelta = targetRotation - carPlayer.rotation;
	// Handle angle wrapping for shortest rotation path
	while (rotationDelta > Math.PI) {
		rotationDelta -= 2 * Math.PI;
	}
	while (rotationDelta < -Math.PI) {
		rotationDelta += 2 * Math.PI;
	}
	// Calculate rotation speed based on current velocity (slower speed = much slower turning)
	var speedRatio = Math.sqrt(velocityX * velocityX + velocityY * velocityY) / maxSpeed;
	var dynamicRotationSpeed = baseRotationSpeed * Math.max(0.1, speedRatio); // Minimum 10% rotation speed
	carPlayer.rotation += rotationDelta * dynamicRotationSpeed;
	// Calculate target velocity based on joystick power
	var targetVelocity = maxSpeed * power;
	// Apply smooth velocity transitions with exponential interpolation
	if (power > 0.1) {
		// Accelerating - smooth exponential approach to target velocity
		var velocityDiff = targetVelocity - currentVelocity;
		var accelerationRate = 0.004; // Smooth acceleration rate (20% slower for smaller car)
		currentVelocity += velocityDiff * accelerationRate;
	} else {
		// Decelerating when joystick is near center - smooth exponential decay
		var decelerationRate = 0.048; // Smooth deceleration rate (20% slower for smaller car)
		currentVelocity *= 1 - decelerationRate;
		if (Math.abs(currentVelocity) < 0.1) {
			currentVelocity = 0;
		}
	}
	// Limit velocity to max speed
	currentVelocity = Math.min(currentVelocity, maxSpeed);
	// Calculate intended movement direction based on car rotation and current velocity
	var intendedMoveX = Math.sin(carPlayer.rotation) * currentVelocity;
	var intendedMoveY = -Math.cos(carPlayer.rotation) * currentVelocity;
	// Calculate turning friction based on dynamic rotation speed
	var rotationFriction = Math.abs(rotationDelta * dynamicRotationSpeed) * 0.8; // Reduced friction intensity for smoother feel
	var frictionMultiplier = Math.max(0.85, 1 - rotationFriction); // Less velocity reduction when turning (min 0.85 for more natural feel)
	// Apply drift physics - blend current momentum with intended direction
	velocityX = velocityX * driftFactor + intendedMoveX * gripFactor;
	velocityY = velocityY * driftFactor + intendedMoveY * gripFactor;
	// Apply turning friction to reduce velocity when steering
	velocityX *= frictionMultiplier;
	velocityY *= frictionMultiplier;
	// Apply some base deceleration to drift momentum
	velocityX *= 0.98;
	velocityY *= 0.98;
	// Update car position using drift momentum
	carPlayer.x += velocityX;
	carPlayer.y += velocityY;
	// Keep car within gameplay area bounds with realistic collision physics
	var halfCarWidth = 16; // CarPlayer width is 32, so half is 16
	var halfCarHeight = 24; // CarPlayer height is 47.36, so half is ~24
	// Calculate current speed for impact calculations
	var currentSpeed = Math.sqrt(velocityX * velocityX + velocityY * velocityY);
	var impactThreshold = 2; // Minimum speed to trigger impact effects
	// Realistic collision physics with energy loss and proper angles
	if (carPlayer.x < halfCarWidth) {
		carPlayer.x = halfCarWidth;
		// Calculate impact intensity based on perpendicular velocity component
		var impactVelocity = Math.abs(velocityX);
		var energyLoss = 0.4 + impactVelocity / maxSpeed * 0.3; // More energy loss at higher speeds
		// Realistic bounce with energy conservation
		velocityX = -velocityX * (1 - energyLoss);
		velocityY *= 0.8; // Friction reduces parallel velocity component
		// Visual feedback for significant impacts
		if (impactVelocity > impactThreshold) {
			LK.effects.flashObject(carPlayer, 0xff4444, 200);
		}
	}
	if (carPlayer.x > 2048 - halfCarWidth) {
		carPlayer.x = 2048 - halfCarWidth;
		// Calculate impact intensity based on perpendicular velocity component
		var impactVelocity = Math.abs(velocityX);
		var energyLoss = 0.4 + impactVelocity / maxSpeed * 0.3; // More energy loss at higher speeds
		// Realistic bounce with energy conservation
		velocityX = -velocityX * (1 - energyLoss);
		velocityY *= 0.8; // Friction reduces parallel velocity component
		// Visual feedback for significant impacts
		if (impactVelocity > impactThreshold) {
			LK.effects.flashObject(carPlayer, 0xff4444, 200);
		}
	}
	if (carPlayer.y < halfCarHeight) {
		carPlayer.y = halfCarHeight;
		// Calculate impact intensity based on perpendicular velocity component
		var impactVelocity = Math.abs(velocityY);
		var energyLoss = 0.4 + impactVelocity / maxSpeed * 0.3; // More energy loss at higher speeds
		// Realistic bounce with energy conservation
		velocityY = -velocityY * (1 - energyLoss);
		velocityX *= 0.8; // Friction reduces parallel velocity component
		// Visual feedback for significant impacts
		if (impactVelocity > impactThreshold) {
			LK.effects.flashObject(carPlayer, 0xff4444, 200);
		}
	}
	if (carPlayer.y > 2186 - halfCarHeight) {
		carPlayer.y = 2186 - halfCarHeight;
		// Calculate impact intensity based on perpendicular velocity component
		var impactVelocity = Math.abs(velocityY);
		var energyLoss = 0.4 + impactVelocity / maxSpeed * 0.3; // More energy loss at higher speeds
		// Realistic bounce with energy conservation
		velocityY = -velocityY * (1 - energyLoss);
		velocityX *= 0.8; // Friction reduces parallel velocity component
		// Visual feedback for significant impacts
		if (impactVelocity > impactThreshold) {
			LK.effects.flashObject(carPlayer, 0xff4444, 200);
		}
	}
	// Apply smooth braking to player car after wall collision for more natural deceleration
	if (!carPlayer.smoothBraking) carPlayer.smoothBraking = false;
	if (!carPlayer.brakeFrames) carPlayer.brakeFrames = 0;
	var currentPlayerSpeed = Math.sqrt(velocityX * velocityX + velocityY * velocityY);
	// If player car was just launched (high velocity), enable smooth braking
	if (currentPlayerSpeed > maxSpeed * 0.6 && !carPlayer.smoothBraking) {
		carPlayer.smoothBraking = true;
		carPlayer.brakeFrames = 0;
	}
	// Smooth braking logic: apply a gentle, progressive friction for a short period after wall collision
	if (carPlayer.smoothBraking) {
		// Braking lasts for 18 frames (~0.3s at 60fps)
		var brakeDuration = 18;
		var brakeProgress = Math.min(1, carPlayer.brakeFrames / brakeDuration);
		// Start with gentle friction, increase to normal friction
		var minFriction = 0.96;
		var maxFriction = 0.92 - currentPlayerSpeed / maxSpeed * 0.05;
		var frictionRate = minFriction + (maxFriction - minFriction) * brakeProgress;
		velocityX *= frictionRate;
		velocityY *= frictionRate;
		carPlayer.brakeFrames++;
		if (carPlayer.brakeFrames >= brakeDuration) {
			carPlayer.smoothBraking = false;
		}
	} else if (currentPlayerSpeed > 0.1) {
		// Normal progressive friction when not actively controlling
		if (power <= 0.1) {
			// Only apply extra friction when not accelerating
			var frictionRate = 0.92 - currentPlayerSpeed / maxSpeed * 0.05; // More friction at higher speeds
			velocityX *= frictionRate;
			velocityY *= frictionRate;
		}
	} else {
		// Stop very slow movement to prevent endless drift
		if (power <= 0.1) {
			velocityX = 0;
			velocityY = 0;
		}
	}
	// Particle system for car exhaust (global, supports all cars)
	if (!game.particles) {
		game.particles = [];
	}
	// Helper function to emit particles for any car
	function emitCarParticles(car, vx, vy, rotation, maxSpeed, gameplayBackground) {
		var totalSpeed = Math.sqrt(vx * vx + vy * vy);
		var speedRatio = totalSpeed / maxSpeed;
		var particleFrequency = Math.max(1, Math.floor(8 - speedRatio * 6));
		if (speedRatio > 0.05 && LK.ticks % particleFrequency === 0) {
			// Calculate particle spawn position behind the car
			var particleSpawnX = car.x - Math.sin(rotation) * 55;
			var particleSpawnY = car.y + Math.cos(rotation) * 55;
			var particleCount = Math.max(1, Math.floor(speedRatio * 3));
			for (var p = 0; p < particleCount; p++) {
				var newParticle = new Particle();
				newParticle.x = particleSpawnX + (Math.random() - 0.5) * 19.2;
				newParticle.y = particleSpawnY + (Math.random() - 0.5) * 19.2;
				newParticle.velocityX += -vx * 0.12 + (Math.random() - 0.5) * 2.4;
				newParticle.velocityY += -vy * 0.12 + (Math.random() - 0.5) * 2.4;
				game.particles.push(newParticle);
				gameplayBackground.addChild(newParticle);
				// Tween particle color for variety
				var colors = [0xffffff, 0xcccccc, 0x999999, 0x666666];
				var randomColor = colors[Math.floor(Math.random() * colors.length)];
				tween(newParticle.children[0], {
					tint: randomColor
				}, {
					duration: 100
				});
			}
		}
	}
	// Emit particles for player car
	emitCarParticles(carPlayer, velocityX, velocityY, carPlayer.rotation, maxSpeed, gameplayBackground);
	// Emit particles for all enemy cars
	for (var carIdx = 0; carIdx < enemyCars.length; carIdx++) {
		var currentEnemyCar = enemyCars[carIdx];
		var enemyTotalVX = (typeof currentEnemyCar.aiVelocityX !== "undefined" ? currentEnemyCar.aiVelocityX : 0) + (typeof currentEnemyCar.velocityX !== "undefined" ? currentEnemyCar.velocityX : 0);
		var enemyTotalVY = (typeof currentEnemyCar.aiVelocityY !== "undefined" ? currentEnemyCar.aiVelocityY : 0) + (typeof currentEnemyCar.velocityY !== "undefined" ? currentEnemyCar.velocityY : 0);
		emitCarParticles(currentEnemyCar, enemyTotalVX, enemyTotalVY, currentEnemyCar.rotation, maxSpeed, gameplayBackground);
	}
	// Update and clean up particles
	for (var i = game.particles.length - 1; i >= 0; i--) {
		var particle = game.particles[i];
		if (particle.age >= particle.lifespan) {
			particle.destroy();
			game.particles.splice(i, 1);
		}
	}
	// Check collision between player car and all enemy cars using smaller collision boxes
	if (!carPlayer.lastColliding) carPlayer.lastColliding = [];
	// Initialize collision tracking array for all cars
	while (carPlayer.lastColliding.length < enemyCars.length) {
		carPlayer.lastColliding.push(false);
	}
	// Define smaller collision boxes (approximately 60% of actual asset size for more precise collision)
	var playerCollisionWidth = 38; // Reduced from 64px width
	var playerCollisionHeight = 57; // Reduced from ~95px height
	var enemyCollisionWidth = 38; // Reduced from 64px width
	var enemyCollisionHeight = 57; // Reduced from ~94px height
	var playerLeft = carPlayer.x - playerCollisionWidth / 2;
	var playerRight = carPlayer.x + playerCollisionWidth / 2;
	var playerTop = carPlayer.y - playerCollisionHeight / 2;
	var playerBottom = carPlayer.y + playerCollisionHeight / 2;
	// Check collision with each enemy car
	for (var enemyIdx = 0; enemyIdx < enemyCars.length; enemyIdx++) {
		var currentEnemyCar = enemyCars[enemyIdx];
		var enemyLeft = currentEnemyCar.x - enemyCollisionWidth / 2;
		var enemyRight = currentEnemyCar.x + enemyCollisionWidth / 2;
		var enemyTop = currentEnemyCar.y - enemyCollisionHeight / 2;
		var enemyBottom = currentEnemyCar.y + enemyCollisionHeight / 2;
		// More precise collision detection using smaller bounding boxes
		var currentColliding = !(playerRight < enemyLeft || playerLeft > enemyRight || playerBottom < enemyTop || playerTop > enemyBottom);
		if (!carPlayer.lastColliding[enemyIdx] && currentColliding) {
			// Collision just started - calculate collision physics with mass
			var playerSpeed = Math.sqrt(velocityX * velocityX + velocityY * velocityY);
			var enemySpeed = Math.sqrt(currentEnemyCar.velocityX * currentEnemyCar.velocityX + currentEnemyCar.velocityY * currentEnemyCar.velocityY);
			// Calculate collision direction (from player car to enemy car)
			var collisionDeltaX = currentEnemyCar.x - carPlayer.x;
			var collisionDeltaY = currentEnemyCar.y - carPlayer.y;
			var collisionDistance = Math.sqrt(collisionDeltaX * collisionDeltaX + collisionDeltaY * collisionDeltaY);
			// Normalize collision direction
			if (collisionDistance > 0) {
				collisionDeltaX /= collisionDistance;
				collisionDeltaY /= collisionDistance;
			}
			// Calculate momentum transfer using conservation of momentum
			var totalMass = playerCarWeight + currentEnemyCar.weight;
			var massRatio1 = (playerCarWeight - currentEnemyCar.weight) / totalMass;
			var massRatio2 = 2 * currentEnemyCar.weight / totalMass;
			var massRatio3 = 2 * playerCarWeight / totalMass;
			var massRatio4 = (currentEnemyCar.weight - playerCarWeight) / totalMass;
			// Make energy loss proportional to current speed for more natural and realistic crash
			var relativeSpeed = Math.max(playerSpeed, enemySpeed);
			var minLoss = 0.18; // minimum energy loss at very low speed
			var maxLoss = 0.65; // maximum energy loss at very high speed
			var speedNorm = Math.min(1, relativeSpeed / maxSpeed); // 0 to 1
			var energyLoss = minLoss + (maxLoss - minLoss) * speedNorm;
			var restitution = 1 - energyLoss;
			// Separate cars to prevent overlap
			var separationDistance = 70;
			carPlayer.x = currentEnemyCar.x - collisionDeltaX * separationDistance;
			carPlayer.y = currentEnemyCar.y - collisionDeltaY * separationDistance;
			// Calculate new velocities based on mass and current motion
			var playerImpactX = velocityX * massRatio1 + currentEnemyCar.velocityX * massRatio2;
			var playerImpactY = velocityY * massRatio1 + currentEnemyCar.velocityY * massRatio2;
			velocityX = playerImpactX * restitution;
			velocityY = playerImpactY * restitution;
			// Enemy car velocity change
			var enemyImpactX = velocityX * massRatio3 + currentEnemyCar.velocityX * massRatio4;
			var enemyImpactY = velocityY * massRatio3 + currentEnemyCar.velocityY * massRatio4;
			currentEnemyCar.velocityX = enemyImpactX * restitution;
			currentEnemyCar.velocityY = enemyImpactY * restitution;
			// Launch enemy car away from collision
			var launchSpeed = Math.max(playerSpeed, enemySpeed);
			var minPush = 0.4;
			var maxPush = 1.5;
			var pushMultiplier = minPush + (maxPush - minPush) * speedNorm;
			var launchDirX = currentEnemyCar.x - carPlayer.x;
			var launchDirY = currentEnemyCar.y - carPlayer.y;
			var launchDist = Math.sqrt(launchDirX * launchDirX + launchDirY * launchDirY);
			if (launchDist < 0.01) {
				var playerMoveNorm = Math.sqrt(velocityX * velocityX + velocityY * velocityY);
				if (playerMoveNorm > 0.01) {
					launchDirX = velocityX / playerMoveNorm;
					launchDirY = velocityY / playerMoveNorm;
				} else {
					launchDirX = 0;
					launchDirY = -1;
				}
			} else {
				launchDirX /= launchDist;
				launchDirY /= launchDist;
			}
			currentEnemyCar.velocityX += launchDirX * launchSpeed * pushMultiplier;
			currentEnemyCar.velocityY += launchDirY * launchSpeed * pushMultiplier;
			// Add directional push based on collision angle and relative mass
			var pushIntensity = (playerSpeed + enemySpeed) * (0.5 + 0.5 * speedNorm);
			var playerPushRatio = currentEnemyCar.weight / totalMass;
			var enemyPushRatio = playerCarWeight / totalMass;
			velocityX += -collisionDeltaX * pushIntensity * playerPushRatio * 0.7;
			velocityY += -collisionDeltaY * pushIntensity * playerPushRatio * 0.7;
			currentEnemyCar.velocityX += collisionDeltaX * pushIntensity * enemyPushRatio * 0.7;
			currentEnemyCar.velocityY += collisionDeltaY * pushIntensity * enemyPushRatio * 0.7;
			// Reset acceleration interpolation
			var postCrashSpeed = Math.sqrt(velocityX * velocityX + velocityY * velocityY);
			if (relativeSpeed > maxSpeed * 0.7) {
				currentVelocity = postCrashSpeed * 0.4;
			} else if (relativeSpeed > maxSpeed * 0.4) {
				currentVelocity = postCrashSpeed * 0.7;
			} else {
				currentVelocity = postCrashSpeed;
			}
			// Visual feedback for collision
			LK.effects.flashObject(carPlayer, 0xff0000, 500);
		}
		// Update last collision state for this enemy
		carPlayer.lastColliding[enemyIdx] = currentColliding;
	}
	// --- Enemy Cars AI Movement Logic ---
	// Process AI for each enemy car
	for (var aiCarIdx = 0; aiCarIdx < enemyCars.length; aiCarIdx++) {
		var enemyCar = enemyCars[aiCarIdx];
		// Initialize target selection system
		if (typeof enemyCar.targetCar === "undefined") enemyCar.targetCar = null;
		if (typeof enemyCar.targetSelectionTimer === "undefined") enemyCar.targetSelectionTimer = 0;
		if (typeof enemyCar.targetSelectionDuration === "undefined") enemyCar.targetSelectionDuration = 120; // 2 seconds
		// Target selection based on personality preferences
		enemyCar.targetSelectionTimer++;
		if (enemyCar.targetSelectionTimer >= enemyCar.targetSelectionDuration || enemyCar.targetCar === null) {
			// Calculate preferred target speed and distance based on personality
			var preferredSpeed = maxSpeed * 0.5; // Default preference
			var preferredDistance = 300; // Default preference
			// Adjust preferences based on personality
			if (enemyCar.personality.name === "Aggressive Hunter") {
				preferredSpeed = maxSpeed * 0.7; // Prefers fast targets
				preferredDistance = 200; // Likes close combat
			} else if (enemyCar.personality.name === "Sneaky Stalker") {
				preferredSpeed = maxSpeed * 0.3; // Prefers slow/stationary targets
				preferredDistance = 400; // Keeps distance for stalking
			} else if (enemyCar.personality.name === "Strategic Ambusher") {
				preferredSpeed = maxSpeed * 0.8; // Prefers fast targets to ambush
				preferredDistance = 500; // Likes long range setup
			} else if (enemyCar.personality.name === "Reckless Rambler") {
				preferredSpeed = maxSpeed * 0.6; // Medium speed preference
				preferredDistance = 250; // Medium distance preference
			} else if (enemyCar.personality.name === "Persistent Pursuer") {
				preferredSpeed = maxSpeed * 0.4; // Prefers slower targets for persistence
				preferredDistance = 350; // Medium-long range preference
			}
			// Evaluate all potential targets (player + other enemy cars)
			var bestTarget = null;
			var bestScore = -1;
			// Check player as potential target
			var playerSpeed = Math.sqrt(velocityX * velocityX + velocityY * velocityY);
			var playerDistance = Math.sqrt((carPlayer.x - enemyCar.x) * (carPlayer.x - enemyCar.x) + (carPlayer.y - enemyCar.y) * (carPlayer.y - enemyCar.y));
			// Calculate score for player target
			var speedDiff = Math.abs(playerSpeed - preferredSpeed);
			var distanceDiff = Math.abs(playerDistance - preferredDistance);
			var playerScore = 1000 - speedDiff * 2 - distanceDiff * 1.5; // Base high score for player
			if (playerScore > bestScore) {
				bestTarget = carPlayer;
				bestScore = playerScore;
			}
			// Check other enemy cars as potential targets
			for (var targetIdx = 0; targetIdx < enemyCars.length; targetIdx++) {
				if (targetIdx === aiCarIdx) continue; // Don't target self
				var potentialTarget = enemyCars[targetIdx];
				var targetSpeedX = (potentialTarget.aiVelocityX || 0) + (potentialTarget.velocityX || 0);
				var targetSpeedY = (potentialTarget.aiVelocityY || 0) + (potentialTarget.velocityY || 0);
				var targetSpeed = Math.sqrt(targetSpeedX * targetSpeedX + targetSpeedY * targetSpeedY);
				var targetDistance = Math.sqrt((potentialTarget.x - enemyCar.x) * (potentialTarget.x - enemyCar.x) + (potentialTarget.y - enemyCar.y) * (potentialTarget.y - enemyCar.y));
				// Calculate score for this enemy car target
				var speedDiff = Math.abs(targetSpeed - preferredSpeed);
				var distanceDiff = Math.abs(targetDistance - preferredDistance);
				var targetScore = 800 - speedDiff * 2 - distanceDiff * 1.5; // Lower base score than player
				// Bonus for personality-specific preferences
				if (enemyCar.personality.name === "Sneaky Stalker" && targetSpeed < maxSpeed * 0.2) {
					targetScore += 150; // Bonus for very slow targets
				} else if (enemyCar.personality.name === "Aggressive Hunter" && targetSpeed > maxSpeed * 0.6) {
					targetScore += 100; // Bonus for fast targets
				} else if (enemyCar.personality.name === "Strategic Ambusher" && targetDistance > 400) {
					targetScore += 120; // Bonus for distant targets
				}
				if (targetScore > bestScore) {
					bestTarget = potentialTarget;
					bestScore = targetScore;
				}
			}
			enemyCar.targetCar = bestTarget;
			enemyCar.targetSelectionTimer = 0;
			// Vary selection duration based on personality patience
			enemyCar.targetSelectionDuration = Math.floor(90 + enemyCar.patience * 180); // 1.5-4.5 seconds
		}
		// Enemy car can switch between 'follow player' and 'free roam' AI modes
		if (typeof enemyCar.aiMode === "undefined") enemyCar.aiMode = "follow";
		if (typeof enemyCar.aiModeTimer === "undefined") enemyCar.aiModeTimer = 0;
		if (typeof enemyCar.aiModeDuration === "undefined") enemyCar.aiModeDuration = 0;
		// AI mode switching logic: change mode at intervals with personality-based preferences
		enemyCar.aiModeTimer++;
		if (enemyCar.aiModeTimer > enemyCar.aiModeDuration) {
			// Calculate target speed for mode preference using selected target
			var targetSpeed = Math.sqrt(targetVelX * targetVelX + targetVelY * targetVelY);
			var targetSpeedRatio = targetSpeed / maxSpeed; // 0 to 1
			// Use personality-based follow chance as base, modified by target speed
			var personalityFollowChance = enemyCar.baseFollowChance;
			var speedModifier = 1.0;
			// Speed-based adjustments based on personality
			if (enemyCar.personality.name === "Aggressive Hunter") {
				// Always aggressive, prefers follow regardless of speed
				speedModifier = 1.1;
			} else if (enemyCar.personality.name === "Sneaky Stalker") {
				// Prefers to follow slow targets for stalking
				speedModifier = targetSpeedRatio < 0.3 ? 1.3 : 0.8;
			} else if (enemyCar.personality.name === "Strategic Ambusher") {
				// Prefers to follow fast targets for ambush opportunities
				speedModifier = targetSpeedRatio > 0.6 ? 1.2 : 0.9;
			} else if (enemyCar.personality.name === "Reckless Rambler") {
				// Generally prefers free roam, less likely to follow
				speedModifier = 0.7;
			} else if (enemyCar.personality.name === "Persistent Pursuer") {
				// Always wants to follow, regardless of speed
				speedModifier = 1.2;
			}
			var followChance = Math.min(0.95, personalityFollowChance * speedModifier);
			// Pick mode based on personality preference
			if (Math.random() < followChance) {
				enemyCar.aiMode = "follow";
			} else {
				enemyCar.aiMode = "free";
			}
			// Duration based on personality patience
			var baseDuration = 72; // 1.2 seconds
			var variableDuration = Math.floor(138 * enemyCar.patience); // Up to 2.3 seconds based on patience
			enemyCar.aiModeDuration = baseDuration + Math.floor(Math.random() * variableDuration);
			enemyCar.aiModeTimer = 0;
		}
		// --- AI movement logic depending on mode ---
		var aiDeltaX, aiDeltaY, aiDistance, aiTargetRotation, aiPower, aiTargetVelocity;
		// Edge avoidance logic - calculate repulsion from boundaries
		var edgeAvoidanceX = 0;
		var edgeAvoidanceY = 0;
		var edgeBuffer = 200; // Distance from edge to start avoiding
		var avoidanceStrength = 0.3; // How strongly to avoid edges
		// Check distance from each edge and calculate avoidance force
		if (enemyCar.x < edgeBuffer) {
			// Too close to left edge, push right
			var leftForce = (edgeBuffer - enemyCar.x) / edgeBuffer;
			edgeAvoidanceX += leftForce * avoidanceStrength;
		}
		if (enemyCar.x > 2048 - edgeBuffer) {
			// Too close to right edge, push left
			var rightForce = (enemyCar.x - (2048 - edgeBuffer)) / edgeBuffer;
			edgeAvoidanceX -= rightForce * avoidanceStrength;
		}
		if (enemyCar.y < edgeBuffer) {
			// Too close to top edge, push down
			var topForce = (edgeBuffer - enemyCar.y) / edgeBuffer;
			edgeAvoidanceY += topForce * avoidanceStrength;
		}
		if (enemyCar.y > 2186 - edgeBuffer) {
			// Too close to bottom edge, push up
			var bottomForce = (enemyCar.y - (2186 - edgeBuffer)) / edgeBuffer;
			edgeAvoidanceY -= bottomForce * avoidanceStrength;
		}
		if (enemyCar.aiMode === "follow") {
			// Initialize follow strategy if not set
			if (typeof enemyCar.followStrategy === "undefined") {
				enemyCar.followStrategy = 0;
				enemyCar.followStrategyTimer = 0;
				enemyCar.followStrategyDuration = 60 + Math.floor(Math.random() * 60); // 1-2 seconds for adaptive strategy
			}
			// Adaptive strategy selection based on target speed and position
			enemyCar.followStrategyTimer++;
			if (enemyCar.followStrategyTimer > enemyCar.followStrategyDuration) {
				// Calculate target speed and relative position for strategy selection
				var targetSpeed = Math.sqrt(targetVelX * targetVelX + targetVelY * targetVelY);
				var targetSpeedRatio = targetSpeed / maxSpeed; // 0 to 1
				var relativeDistance = Math.sqrt(aiDeltaX * aiDeltaX + aiDeltaY * aiDeltaY);
				var relativeAngle = Math.atan2(aiDeltaX, -aiDeltaY);
				var enemyAngle = enemyCar.rotation;
				var angleDifference = Math.abs(relativeAngle - enemyAngle);
				while (angleDifference > Math.PI) angleDifference = 2 * Math.PI - angleDifference;
				var isTargetAhead = angleDifference < Math.PI / 3; // Within 60 degrees ahead
				var isTargetBehind = angleDifference > 2 * Math.PI / 3; // More than 120 degrees behind
				// Strategy selection based on personality preferences
				var preferredStrat = enemyCar.preferredStrategy;
				// If car has a preferred strategy, use it most of the time
				if (preferredStrat >= 0) {
					var usePreferredChance = 0.7 + enemyCar.aggressiveness * 0.2; // 70-90% based on aggressiveness
					if (Math.random() < usePreferredChance) {
						enemyCar.followStrategy = preferredStrat;
					} else {
						// Occasionally use alternative strategies based on situation
						if (targetSpeedRatio < 0.05) {
							// Target is nearly stationary - use intimidation system
							if (typeof enemyCar.intimidationCount === "undefined") {
								enemyCar.intimidationCount = 0;
								enemyCar.maxIntimidations = Math.floor(1 + Math.random() * (4 - enemyCar.aggressiveness * 3)); // More aggressive = fewer intimidations
							}
							if (enemyCar.intimidationCount >= enemyCar.maxIntimidations) {
								enemyCar.followStrategy = 0; // Direct pursuit for attack
							} else {
								enemyCar.followStrategy = 1; // Intimidation approach
							}
						} else {
							// Choose alternative strategy that complements personality
							if (enemyCar.personality.name === "Aggressive Hunter") {
								enemyCar.followStrategy = Math.random() < 0.8 ? 0 : 2; // Direct or ambush
							} else if (enemyCar.personality.name === "Sneaky Stalker") {
								enemyCar.followStrategy = Math.random() < 0.7 ? 1 : 0; // Varied or direct
							} else if (enemyCar.personality.name === "Strategic Ambusher") {
								enemyCar.followStrategy = Math.random() < 0.6 ? 2 : 1; // Ambush or varied
							} else if (enemyCar.personality.name === "Persistent Pursuer") {
								enemyCar.followStrategy = Math.random() < 0.9 ? 0 : 1; // Almost always direct
							}
						}
					}
				} else {
					// Reckless Rambler has no preferred strategy, choose based on situation and aggression
					if (targetSpeedRatio < 0.05) {
						enemyCar.followStrategy = enemyCar.aggressiveness > 0.6 ? 0 : 1; // Aggressive = direct, else varied
					} else if (isTargetBehind || relativeDistance < 200) {
						enemyCar.followStrategy = 1; // Varied approach for positioning
					} else if (isTargetAhead && relativeDistance < 300) {
						enemyCar.followStrategy = 0; // Direct pursuit
					} else {
						// Choose based on aggressiveness and randomness
						var strategyRoll = Math.random();
						if (strategyRoll < enemyCar.aggressiveness * 0.5) {
							enemyCar.followStrategy = 0; // Direct
						} else if (strategyRoll < 0.7) {
							enemyCar.followStrategy = 1; // Varied
						} else {
							enemyCar.followStrategy = 2; // Ambush
						}
					}
				}
				// Adjust duration based on selected strategy
				switch (enemyCar.followStrategy) {
					case 0:
						// Direct - shorter duration for quick decisions
						enemyCar.followStrategyDuration = 45 + Math.floor(Math.random() * 45);
						break;
					case 1:
						// Varied - medium duration for tactical maneuvering
						enemyCar.followStrategyDuration = 60 + Math.floor(Math.random() * 60);
						break;
					case 2:
						// Ambush - longer duration for prediction accuracy
						enemyCar.followStrategyDuration = 90 + Math.floor(Math.random() * 60);
						break;
				}
				enemyCar.followStrategyTimer = 0;
			}
			// Calculate base values using selected target
			var targetX, targetY, targetVelX, targetVelY;
			if (enemyCar.targetCar === carPlayer) {
				targetX = carPlayer.x;
				targetY = carPlayer.y;
				targetVelX = velocityX;
				targetVelY = velocityY;
			} else {
				targetX = enemyCar.targetCar.x;
				targetY = enemyCar.targetCar.y;
				targetVelX = (enemyCar.targetCar.aiVelocityX || 0) + (enemyCar.targetCar.velocityX || 0);
				targetVelY = (enemyCar.targetCar.aiVelocityY || 0) + (enemyCar.targetCar.velocityY || 0);
			}
			aiDeltaX = targetX - enemyCar.x;
			aiDeltaY = targetY - enemyCar.y;
			aiDistance = Math.sqrt(aiDeltaX * aiDeltaX + aiDeltaY * aiDeltaY);
			// Calculate relative velocity and approach angle for smarter pursuit
			var relativeVelX = targetVelX - (enemyCar.aiVelocityX || 0);
			var relativeVelY = targetVelY - (enemyCar.aiVelocityY || 0);
			var approachAngle = Math.atan2(aiDeltaX, -aiDeltaY);
			var enemyCurrentAngle = enemyCar.rotation;
			var angleDiff = approachAngle - enemyCurrentAngle;
			while (angleDiff > Math.PI) angleDiff -= 2 * Math.PI;
			while (angleDiff < -Math.PI) angleDiff += 2 * Math.PI;
			// Anti-circling detection: check if we're in a circular pattern
			if (typeof enemyCar.lastPositions === "undefined") {
				enemyCar.lastPositions = [];
				enemyCar.circlingDetected = false;
				enemyCar.circlingCooldown = 0;
			}
			// Store position history for circling detection
			enemyCar.lastPositions.push({
				x: enemyCar.x,
				y: enemyCar.y,
				frame: LK.ticks
			});
			if (enemyCar.lastPositions.length > 60) {
				// Keep 1 second of history
				enemyCar.lastPositions.shift();
			}
			// Detect circling by checking if we've been in similar positions recently
			var circlingThreshold = 80; // Distance threshold for considering positions "similar"
			var circlingCount = 0;
			for (var i = 0; i < enemyCar.lastPositions.length - 20; i++) {
				var oldPos = enemyCar.lastPositions[i];
				var dist = Math.sqrt((enemyCar.x - oldPos.x) * (enemyCar.x - oldPos.x) + (enemyCar.y - oldPos.y) * (enemyCar.y - oldPos.y));
				if (dist < circlingThreshold) {
					circlingCount++;
				}
			}
			enemyCar.circlingDetected = circlingCount > 3 && aiDistance < 200; // Circling if close to player and repeating positions
			// Reduce circling cooldown
			if (enemyCar.circlingCooldown > 0) enemyCar.circlingCooldown--;
			// Initialize failure detection system for direct pursuit
			if (typeof enemyCar.directPursuitTimer === "undefined") {
				enemyCar.directPursuitTimer = 0;
				enemyCar.lastPlayerDistance = aiDistance;
				enemyCar.nearMissCount = 0;
				enemyCar.totalPursuitTime = 0;
			}
			// Apply different follow strategies with distance awareness
			switch (enemyCar.followStrategy) {
				case 0:
					// Direct pursuit - straight chase with distance management
					// Track pursuit effectiveness
					enemyCar.directPursuitTimer++;
					enemyCar.totalPursuitTime++;
					// Detect near misses - when AI gets very close but doesn't hit
					if (aiDistance < 80 && enemyCar.lastPlayerDistance > 80) {
						// Just entered close range
						enemyCar.directPursuitTimer = 0; // Reset timer on new approach
					}
					if (enemyCar.lastPlayerDistance < 80 && aiDistance > 120) {
						// Just left close range without collision - potential near miss
						enemyCar.nearMissCount++;
					}
					// Check for failure conditions in direct pursuit
					var pursuitFailed = false;
					if (enemyCar.nearMissCount >= 2) {
						// Failed after 2 near misses
						pursuitFailed = true;
					} else if (enemyCar.totalPursuitTime > 300 && !currentColliding) {
						// Failed after 5 seconds without collision
						pursuitFailed = true;
					} else if (enemyCar.directPursuitTimer > 120 && aiDistance > 200) {
						// Failed if stuck at medium distance for 2 seconds
						pursuitFailed = true;
					}
					// Switch strategy if direct pursuit failed
					if (pursuitFailed) {
						// Reset failure tracking
						enemyCar.nearMissCount = 0;
						enemyCar.totalPursuitTime = 0;
						enemyCar.directPursuitTimer = 0;
						// Calculate target speed for strategy selection
						var currentTargetSpeed = Math.sqrt(velocityX * velocityX + velocityY * velocityY);
						var targetSpeedRatio = currentTargetSpeed / maxSpeed;
						// Choose new strategy based on current situation
						if (targetSpeedRatio > 0.5 || aiDistance > 300) {
							// Fast target or far away - try ambush
							enemyCar.followStrategy = 2;
							enemyCar.followStrategyDuration = 90 + Math.floor(Math.random() * 60);
						} else {
							// Slow target or close - try varied approach
							enemyCar.followStrategy = 1;
							enemyCar.followStrategyDuration = 60 + Math.floor(Math.random() * 60);
						}
						enemyCar.followStrategyTimer = 0;
					}
					// Check if AI can go straight to target for speed optimization
					var currentEnemyAngle = enemyCar.rotation;
					var straightLineAngle = Math.atan2(aiDeltaX, -aiDeltaY);
					var angleToTarget = straightLineAngle - currentEnemyAngle;
					while (angleToTarget > Math.PI) angleToTarget -= 2 * Math.PI;
					while (angleToTarget < -Math.PI) angleToTarget += 2 * Math.PI;
					// AI is considered "aligned" if facing within 15 degrees of target
					var isAlignedWithTarget = Math.abs(angleToTarget) < Math.PI / 12; // 15 degrees
					if (aiDistance < 120 && !enemyCar.circlingDetected) {
						// Too close - back off slightly at an angle
						var backoffAngle = approachAngle + Math.PI + (Math.random() - 0.5) * Math.PI * 0.5;
						aiTargetRotation = backoffAngle;
						aiPower = 0.3;
						aiTargetVelocity = maxSpeed * aiPower * 0.6;
					} else if (aiDistance > 500) {
						// Far away - check for straight line opportunity
						if (isAlignedWithTarget) {
							// Can go straight - use maximum speed for efficiency
							aiTargetRotation = straightLineAngle;
							aiPower = Math.min(1, aiDistance / 600);
							aiTargetVelocity = maxSpeed * aiPower * 1.0; // Full speed when aligned
						} else {
							// Need to turn first - direct approach at normal speed
							aiTargetRotation = approachAngle;
							aiPower = Math.min(1, aiDistance / 600);
							aiTargetVelocity = maxSpeed * aiPower * 0.95;
						}
					} else {
						// Medium distance - check alignment for speed boost
						if (isAlignedWithTarget && aiDistance > 200) {
							// Aligned and far enough - go straight at higher speed
							aiTargetRotation = straightLineAngle;
							aiPower = Math.min(1, aiDistance / 500);
							aiTargetVelocity = maxSpeed * aiPower * 0.98; // Near full speed when aligned
						} else {
							// Not aligned or too close - slight offset to avoid head-on collision
							var offsetAngle = (Math.random() - 0.5) * Math.PI * 0.2; // ±18 degrees
							aiTargetRotation = approachAngle + offsetAngle;
							aiPower = Math.min(1, aiDistance / 500);
							aiTargetVelocity = maxSpeed * aiPower * 0.92;
						}
					}
					// Update last distance for next frame
					enemyCar.lastPlayerDistance = aiDistance;
					break;
				case 1:
					// Varied pursuit - intimidation mode: follows like direct but maintains safe distance to scare
					if (enemyCar.circlingDetected && enemyCar.circlingCooldown <= 0) {
						// Break out of circling pattern
						var escapeAngle = approachAngle + Math.PI * 0.75 * (Math.random() < 0.5 ? 1 : -1);
						aiTargetRotation = escapeAngle;
						aiPower = 0.8;
						aiTargetVelocity = maxSpeed * aiPower * 0.85;
						enemyCar.circlingCooldown = 120; // 2 second cooldown
					} else if (aiDistance < 180) {
						// Intimidation range - follow closely but maintain threatening distance
						// Stay close enough to scare but far enough to avoid collision
						var intimidationDistance = 150; // Target distance for intimidation
						var distanceError = aiDistance - intimidationDistance;
						if (Math.abs(distanceError) < 30) {
							// Perfect intimidation distance - match player direction but slightly offset
							var intimidationOffset = Math.sin(LK.ticks * 0.05) * (Math.PI * 0.15); // Subtle weaving ±27 degrees
							aiTargetRotation = approachAngle + intimidationOffset;
							aiPower = 0.7;
							aiTargetVelocity = maxSpeed * aiPower * 0.85;
							// Check if target is stationary and we're intimidating
							var currentTargetSpeed = Math.sqrt(targetVelX * targetVelX + targetVelY * targetVelY);
							if (currentTargetSpeed < maxSpeed * 0.05 && typeof enemyCar.intimidationCount !== "undefined") {
								// Mark intimidation as successful after maintaining perfect distance for a while
								if (typeof enemyCar.intimidationTimer === "undefined") enemyCar.intimidationTimer = 0;
								enemyCar.intimidationTimer++;
								// Complete intimidation after 2 seconds of perfect positioning
								if (enemyCar.intimidationTimer > 120) {
									enemyCar.intimidationCount++;
									enemyCar.intimidationTimer = 0;
									// Force strategy recalculation
									enemyCar.followStrategyTimer = enemyCar.followStrategyDuration + 1;
								}
							}
						} else if (distanceError < 0) {
							// Too close - back off while still facing player
							aiTargetRotation = approachAngle + Math.PI + (Math.random() - 0.5) * Math.PI * 0.3;
							aiPower = 0.4;
							aiTargetVelocity = maxSpeed * aiPower * 0.6;
						} else {
							// Too far - approach for intimidation
							aiTargetRotation = approachAngle;
							aiPower = 0.8;
							aiTargetVelocity = maxSpeed * aiPower * 0.9;
						}
					} else {
						// Long range - approach like direct pursuit for intimidation setup
						aiTargetRotation = approachAngle;
						aiPower = Math.min(1, aiDistance / 500);
						aiTargetVelocity = maxSpeed * aiPower * 0.92;
					}
					break;
				case 2:
					// Ambush - predict player's future position with smarter interception
					var playerVelX = velocityX;
					var playerVelY = velocityY;
					var playerSpeed = Math.sqrt(playerVelX * playerVelX + playerVelY * playerVelY);
					if (enemyCar.circlingDetected && enemyCar.circlingCooldown <= 0) {
						// Break circling with wide flanking maneuver
						var flankAngle = approachAngle + Math.PI * 0.8 * (Math.random() < 0.5 ? 1 : -1);
						aiTargetRotation = flankAngle;
						aiPower = 0.9;
						aiTargetVelocity = maxSpeed * aiPower * 0.9;
						enemyCar.circlingCooldown = 180; // 3 second cooldown
					} else if (aiDistance < 150) {
						// Close range - position for optimal angle of attack
						var attackAngle = approachAngle + Math.PI * 0.4 * (angleDiff > 0 ? 1 : -1);
						aiTargetRotation = attackAngle;
						aiPower = 0.7;
						aiTargetVelocity = maxSpeed * aiPower * 0.8;
					} else {
						// Long range interception
						var predictionTime = Math.min(2.5, aiDistance / maxSpeed * 0.9);
						var interceptX = targetX + targetVelX * predictionTime;
						var interceptY = targetY + targetVelY * predictionTime;
						// Keep predicted position within bounds
						interceptX = Math.max(80, Math.min(1968, interceptX));
						interceptY = Math.max(80, Math.min(2106, interceptY));
						// Calculate optimal interception approach
						var interceptDeltaX = interceptX - enemyCar.x;
						var interceptDeltaY = interceptY - enemyCar.y;
						var interceptDistance = Math.sqrt(interceptDeltaX * interceptDeltaX + interceptDeltaY * interceptDeltaY);
						// Lead the target slightly based on relative speeds
						var speedRatio = (enemyCar.aiCurrentVelocity || 0) / Math.max(0.1, playerSpeed);
						var leadAdjustment = (1 - speedRatio) * 0.3;
						aiTargetRotation = Math.atan2(interceptDeltaX, -interceptDeltaY);
						aiPower = Math.min(1, interceptDistance / 700);
						var speedBoost = Math.min(0.2, playerSpeed / maxSpeed * 0.2);
						aiTargetVelocity = maxSpeed * aiPower * (0.85 + speedBoost + leadAdjustment);
					}
					break;
			}
			// Blend in edge avoidance with follow behavior
			if (edgeAvoidanceX !== 0 || edgeAvoidanceY !== 0) {
				// Calculate edge avoidance angle
				var avoidanceAngle = Math.atan2(edgeAvoidanceX, -edgeAvoidanceY);
				// Blend the target rotation with avoidance (stronger when closer to edges)
				var avoidanceWeight = Math.min(0.7, Math.abs(edgeAvoidanceX) + Math.abs(edgeAvoidanceY));
				var followWeight = 1 - avoidanceWeight;
				// Convert angles to vectors for blending
				var followVecX = Math.sin(aiTargetRotation) * followWeight;
				var followVecY = -Math.cos(aiTargetRotation) * followWeight;
				var avoidVecX = Math.sin(avoidanceAngle) * avoidanceWeight;
				var avoidVecY = -Math.cos(avoidanceAngle) * avoidanceWeight;
				// Combine and convert back to angle
				var blendedVecX = followVecX + avoidVecX;
				var blendedVecY = followVecY + avoidVecY;
				aiTargetRotation = Math.atan2(blendedVecX, -blendedVecY);
			}
		} else {
			// Enhanced Free roam logic with dynamic behavior patterns
			if (typeof enemyCar.freeRoamAngle === "undefined" || enemyCar.aiModeTimer === 0) {
				// Initialize free roam variables
				enemyCar.freeRoamAngle = Math.random() * Math.PI * 2;
				enemyCar.freeRoamSpeed = maxSpeed * (0.4 + Math.random() * 0.4); // 40%-80% of max speed
				enemyCar.freeRoamTimer = 0;
				enemyCar.freeRoamDirectionTimer = 0;
				enemyCar.freeRoamPattern = Math.floor(Math.random() * 3); // 0=wander, 1=circular, 2=aggressive
			}
			// Dynamic free roam behavior - change direction periodically for more interesting movement
			enemyCar.freeRoamTimer++;
			enemyCar.freeRoamDirectionTimer++;
			// Change direction every 1-3 seconds based on pattern
			var directionChangeInterval;
			switch (enemyCar.freeRoamPattern) {
				case 0:
					// Wander pattern - gentle direction changes
					directionChangeInterval = 90 + Math.floor(Math.random() * 60); // 1.5-2.5 seconds
					break;
				case 1:
					// Circular pattern - more frequent turns
					directionChangeInterval = 45 + Math.floor(Math.random() * 30); // 0.75-1.25 seconds
					break;
				case 2:
					// Aggressive pattern - quick direction changes
					directionChangeInterval = 30 + Math.floor(Math.random() * 40); // 0.5-1.17 seconds
					break;
			}
			if (enemyCar.freeRoamDirectionTimer > directionChangeInterval) {
				enemyCar.freeRoamDirectionTimer = 0;
				// Different behavior patterns for more variety
				switch (enemyCar.freeRoamPattern) {
					case 0:
						// Wander - small random direction changes
						var angleChange = (Math.random() - 0.5) * Math.PI * 0.6; // ±54 degrees
						enemyCar.freeRoamAngle += angleChange;
						enemyCar.freeRoamSpeed = maxSpeed * (0.3 + Math.random() * 0.4);
						break;
					case 1:
						// Circular - tends to turn in one direction
						if (typeof enemyCar.circularDirection === "undefined") {
							enemyCar.circularDirection = Math.random() < 0.5 ? -1 : 1;
						}
						var circularTurn = enemyCar.circularDirection * (Math.PI * 0.3 + Math.random() * Math.PI * 0.4); // 54-126 degrees
						enemyCar.freeRoamAngle += circularTurn;
						enemyCar.freeRoamSpeed = maxSpeed * (0.5 + Math.random() * 0.3);
						// Occasionally reverse direction
						if (Math.random() < 0.15) enemyCar.circularDirection *= -1;
						break;
					case 2:
						// Aggressive - sharp turns and speed changes
						var aggressiveTurn = (Math.random() - 0.5) * Math.PI * 1.2; // ±108 degrees
						enemyCar.freeRoamAngle += aggressiveTurn;
						enemyCar.freeRoamSpeed = maxSpeed * (0.6 + Math.random() * 0.3);
						break;
				}
			}
			// Add some target awareness even in free roam - occasionally look towards current target
			var targetDistance = aiDistance;
			var targetInfluence = 0;
			if (targetDistance < 400) {
				// Within 400 pixels
				// Closer target = more influence on direction
				targetInfluence = Math.max(0, (400 - targetDistance) / 400 * 0.3); // Up to 30% influence
				if (Math.random() < 0.02) {
					// 2% chance per frame to look at target
					var targetAngle = Math.atan2(targetX - enemyCar.x, -(targetY - enemyCar.y));
					// Blend current angle with target angle
					var currentVecX = Math.sin(enemyCar.freeRoamAngle);
					var currentVecY = -Math.cos(enemyCar.freeRoamAngle);
					var targetVecX = Math.sin(targetAngle) * targetInfluence;
					var targetVecY = -Math.cos(targetAngle) * targetInfluence;
					var blendedVecX = currentVecX * (1 - targetInfluence) + targetVecX;
					var blendedVecY = currentVecY * (1 - targetInfluence) + targetVecY;
					enemyCar.freeRoamAngle = Math.atan2(blendedVecX, -blendedVecY);
				}
			}
			aiTargetRotation = enemyCar.freeRoamAngle;
			aiPower = 1;
			aiTargetVelocity = enemyCar.freeRoamSpeed;
			// Apply edge avoidance to free roam mode with stronger influence
			if (edgeAvoidanceX !== 0 || edgeAvoidanceY !== 0) {
				// Calculate edge avoidance angle
				var avoidanceAngle = Math.atan2(edgeAvoidanceX, -edgeAvoidanceY);
				// Much stronger avoidance in free roam mode
				var avoidanceWeight = Math.min(0.85, (Math.abs(edgeAvoidanceX) + Math.abs(edgeAvoidanceY)) * 1.5);
				var roamWeight = 1 - avoidanceWeight;
				// Convert angles to vectors for blending
				var roamVecX = Math.sin(aiTargetRotation) * roamWeight;
				var roamVecY = -Math.cos(aiTargetRotation) * roamWeight;
				var avoidVecX = Math.sin(avoidanceAngle) * avoidanceWeight;
				var avoidVecY = -Math.cos(avoidanceAngle) * avoidanceWeight;
				// Combine and convert back to angle
				var blendedVecX = roamVecX + avoidVecX;
				var blendedVecY = roamVecY + avoidVecY;
				aiTargetRotation = Math.atan2(blendedVecX, -blendedVecY);
				// Update the free roam angle to new direction after avoidance
				enemyCar.freeRoamAngle = aiTargetRotation;
			}
		}
		// AI: Smoothly rotate enemy car towards target
		if (typeof enemyCar.aiRotation === "undefined") enemyCar.aiRotation = enemyCar.rotation;
		var aiRotationDelta = aiTargetRotation - enemyCar.aiRotation;
		while (aiRotationDelta > Math.PI) aiRotationDelta -= 2 * Math.PI;
		while (aiRotationDelta < -Math.PI) aiRotationDelta += 2 * Math.PI;
		var aiRotationSpeed = baseRotationSpeed * 0.7 * enemyCar.rotationSpeedMultiplier; // Apply personality rotation speed
		enemyCar.aiRotation += aiRotationDelta * aiRotationSpeed;
		enemyCar.rotation = enemyCar.aiRotation;
		// AI: Velocity logic with personality-based speed
		if (typeof enemyCar.aiCurrentVelocity === "undefined") enemyCar.aiCurrentVelocity = 0;
		if (aiPower > 0.1) {
			// Accelerate with personality-based acceleration rate
			var personalityAcceleration = 0.003 * (0.8 + enemyCar.aggressiveness * 0.4); // More aggressive = faster acceleration
			var aiVelocityDiff = aiTargetVelocity * enemyCar.speedMultiplier - enemyCar.aiCurrentVelocity;
			enemyCar.aiCurrentVelocity += aiVelocityDiff * personalityAcceleration;
		} else {
			// Decelerate based on personality patience
			var personalityDeceleration = 0.045 * (0.7 + (1 - enemyCar.patience) * 0.6); // Less patient = faster deceleration
			enemyCar.aiCurrentVelocity *= 1 - personalityDeceleration;
			if (Math.abs(enemyCar.aiCurrentVelocity) < 0.1) enemyCar.aiCurrentVelocity = 0;
		}
		enemyCar.aiCurrentVelocity = Math.min(enemyCar.aiCurrentVelocity, maxSpeed * 0.92 * enemyCar.speedMultiplier);
		// AI: Intended movement direction
		var aiIntendedMoveX = Math.sin(enemyCar.aiRotation) * enemyCar.aiCurrentVelocity;
		var aiIntendedMoveY = -Math.cos(enemyCar.aiRotation) * enemyCar.aiCurrentVelocity;
		// AI: Drift physics for enemy car
		if (typeof enemyCar.aiVelocityX === "undefined") enemyCar.aiVelocityX = 0;
		if (typeof enemyCar.aiVelocityY === "undefined") enemyCar.aiVelocityY = 0;
		enemyCar.aiVelocityX = enemyCar.aiVelocityX * driftFactor + aiIntendedMoveX * gripFactor;
		enemyCar.aiVelocityY = enemyCar.aiVelocityY * driftFactor + aiIntendedMoveY * gripFactor;
		// AI: Apply friction and update position
		enemyCar.aiVelocityX *= 0.98;
		enemyCar.aiVelocityY *= 0.98;
		enemyCar.x += enemyCar.aiVelocityX + enemyCar.velocityX;
		enemyCar.y += enemyCar.aiVelocityY + enemyCar.velocityY;
		// --- End Enemy Car AI Movement Logic ---
		// Apply smooth braking to enemy car after collision for more natural deceleration
		if (!enemyCar.smoothBraking) enemyCar.smoothBraking = false;
		if (!enemyCar.brakeFrames) enemyCar.brakeFrames = 0;
		var currentEnemySpeed = Math.sqrt(enemyCar.velocityX * enemyCar.velocityX + enemyCar.velocityY * enemyCar.velocityY);
		// If enemy car was just launched (high velocity), enable smooth braking
		if (currentEnemySpeed > maxSpeed * 0.6 && !enemyCar.smoothBraking) {
			enemyCar.smoothBraking = true;
			enemyCar.brakeFrames = 0;
		}
		// Smooth braking logic: apply a gentle, progressive friction for a short period after being launched
		if (enemyCar.smoothBraking) {
			// Braking lasts for 18 frames (~0.3s at 60fps)
			var brakeDuration = 18;
			var brakeProgress = Math.min(1, enemyCar.brakeFrames / brakeDuration);
			// Start with gentle friction, increase to normal friction
			var minFriction = 0.96;
			var maxFriction = 0.92 - currentEnemySpeed / maxSpeed * 0.05;
			var frictionRate = minFriction + (maxFriction - minFriction) * brakeProgress;
			enemyCar.velocityX *= frictionRate;
			enemyCar.velocityY *= frictionRate;
			enemyCar.brakeFrames++;
			if (enemyCar.brakeFrames >= brakeDuration) {
				enemyCar.smoothBraking = false;
			}
		} else if (currentEnemySpeed > 0.1) {
			// Normal progressive friction
			var frictionRate = 0.92 - currentEnemySpeed / maxSpeed * 0.05; // More friction at higher speeds
			enemyCar.velocityX *= frictionRate;
			enemyCar.velocityY *= frictionRate;
		} else {
			// Stop very slow movement to prevent endless drift
			enemyCar.velocityX = 0;
			enemyCar.velocityY = 0;
		}
		// Keep enemy car within bounds
		var enemyHalfWidth = 32;
		var enemyHalfHeight = 47;
		if (enemyCar.x < enemyHalfWidth) {
			enemyCar.x = enemyHalfWidth;
			enemyCar.velocityX = -enemyCar.velocityX * 0.6;
		}
		if (enemyCar.x > 2048 - enemyHalfWidth) {
			enemyCar.x = 2048 - enemyHalfWidth;
			enemyCar.velocityX = -enemyCar.velocityX * 0.6;
		}
		if (enemyCar.y < enemyHalfHeight) {
			enemyCar.y = enemyHalfHeight;
			enemyCar.velocityY = -enemyCar.velocityY * 0.6;
		}
		if (enemyCar.y > 2186 - enemyHalfHeight) {
			enemyCar.y = 2186 - enemyHalfHeight;
			enemyCar.velocityY = -enemyCar.velocityY * 0.6;
		}
	}
	// --- End Enemy Cars AI Movement Logic ---
	// Add collision detection between enemy cars
	for (var carA = 0; carA < enemyCars.length; carA++) {
		for (var carB = carA + 1; carB < enemyCars.length; carB++) {
			var enemyCarA = enemyCars[carA];
			var enemyCarB = enemyCars[carB];
			// Initialize collision tracking if not exists
			if (!enemyCarA.enemyColliding) enemyCarA.enemyColliding = [];
			if (!enemyCarB.enemyColliding) enemyCarB.enemyColliding = [];
			while (enemyCarA.enemyColliding.length <= carB) enemyCarA.enemyColliding.push(false);
			while (enemyCarB.enemyColliding.length <= carA) enemyCarB.enemyColliding.push(false);
			// Calculate collision boxes for both cars
			var carALeft = enemyCarA.x - enemyCollisionWidth / 2;
			var carARight = enemyCarA.x + enemyCollisionWidth / 2;
			var carATop = enemyCarA.y - enemyCollisionHeight / 2;
			var carABottom = enemyCarA.y + enemyCollisionHeight / 2;
			var carBLeft = enemyCarB.x - enemyCollisionWidth / 2;
			var carBRight = enemyCarB.x + enemyCollisionWidth / 2;
			var carBTop = enemyCarB.y - enemyCollisionHeight / 2;
			var carBBottom = enemyCarB.y + enemyCollisionHeight / 2;
			// Check for collision
			var currentColliding = !(carARight < carBLeft || carALeft > carBRight || carABottom < carBTop || carATop > carBBottom);
			if (!enemyCarA.enemyColliding[carB] && currentColliding) {
				// Collision just started - apply physics
				var carASpeedX = (enemyCarA.aiVelocityX || 0) + (enemyCarA.velocityX || 0);
				var carASpeedY = (enemyCarA.aiVelocityY || 0) + (enemyCarA.velocityY || 0);
				var carBSpeedX = (enemyCarB.aiVelocityX || 0) + (enemyCarB.velocityX || 0);
				var carBSpeedY = (enemyCarB.aiVelocityY || 0) + (enemyCarB.velocityY || 0);
				var carASpeed = Math.sqrt(carASpeedX * carASpeedX + carASpeedY * carASpeedY);
				var carBSpeed = Math.sqrt(carBSpeedX * carBSpeedX + carBSpeedY * carBSpeedY);
				// Calculate collision direction
				var collisionDeltaX = enemyCarB.x - enemyCarA.x;
				var collisionDeltaY = enemyCarB.y - enemyCarA.y;
				var collisionDistance = Math.sqrt(collisionDeltaX * collisionDeltaX + collisionDeltaY * collisionDeltaY);
				// Normalize collision direction
				if (collisionDistance > 0) {
					collisionDeltaX /= collisionDistance;
					collisionDeltaY /= collisionDistance;
				}
				// Calculate momentum transfer using conservation of momentum
				var totalMass = enemyCarA.weight + enemyCarB.weight;
				var massRatioA1 = (enemyCarA.weight - enemyCarB.weight) / totalMass;
				var massRatioA2 = 2 * enemyCarB.weight / totalMass;
				var massRatioB1 = 2 * enemyCarA.weight / totalMass;
				var massRatioB2 = (enemyCarB.weight - enemyCarA.weight) / totalMass;
				// Energy loss calculation
				var relativeSpeed = Math.max(carASpeed, carBSpeed);
				var minLoss = 0.15;
				var maxLoss = 0.55;
				var speedNorm = Math.min(1, relativeSpeed / maxSpeed);
				var energyLoss = minLoss + (maxLoss - minLoss) * speedNorm;
				var restitution = 1 - energyLoss;
				// Separate cars to prevent overlap
				var separationDistance = 75;
				var halfSeparation = separationDistance / 2;
				enemyCarA.x = enemyCarA.x - collisionDeltaX * halfSeparation;
				enemyCarA.y = enemyCarA.y - collisionDeltaY * halfSeparation;
				enemyCarB.x = enemyCarB.x + collisionDeltaX * halfSeparation;
				enemyCarB.y = enemyCarB.y + collisionDeltaY * halfSeparation;
				// Calculate new velocities for car A
				var carAImpactX = carASpeedX * massRatioA1 + carBSpeedX * massRatioA2;
				var carAImpactY = carASpeedY * massRatioA1 + carBSpeedY * massRatioA2;
				enemyCarA.velocityX = carAImpactX * restitution;
				enemyCarA.velocityY = carAImpactY * restitution;
				// Calculate new velocities for car B
				var carBImpactX = carASpeedX * massRatioB1 + carBSpeedX * massRatioB2;
				var carBImpactY = carASpeedY * massRatioB1 + carBSpeedY * massRatioB2;
				enemyCarB.velocityX = carBImpactX * restitution;
				enemyCarB.velocityY = carBImpactY * restitution;
				// Add directional push based on collision
				var pushIntensity = (carASpeed + carBSpeed) * (0.4 + 0.4 * speedNorm);
				var carAPushRatio = enemyCarB.weight / totalMass;
				var carBPushRatio = enemyCarA.weight / totalMass;
				enemyCarA.velocityX += -collisionDeltaX * pushIntensity * carAPushRatio * 0.6;
				enemyCarA.velocityY += -collisionDeltaY * pushIntensity * carAPushRatio * 0.6;
				enemyCarB.velocityX += collisionDeltaX * pushIntensity * carBPushRatio * 0.6;
				enemyCarB.velocityY += collisionDeltaY * pushIntensity * carBPushRatio * 0.6;
				// Visual feedback for collision
				LK.effects.flashObject(enemyCarA, 0xffaa00, 300);
				LK.effects.flashObject(enemyCarB, 0xffaa00, 300);
			}
			// Update collision tracking
			enemyCarA.enemyColliding[carB] = currentColliding;
			enemyCarB.enemyColliding[carA] = currentColliding;
		}
	}
	// Update speed display
	var totalSpeed = Math.sqrt(velocityX * velocityX + velocityY * velocityY);
	speedText.setText('Speed: ' + Math.round(totalSpeed));
};

===================================================================
--- original.js
+++ change.js
@@ -642,17 +642,88 @@
 	// --- Enemy Cars AI Movement Logic ---
 	// Process AI for each enemy car
 	for (var aiCarIdx = 0; aiCarIdx < enemyCars.length; aiCarIdx++) {
 		var enemyCar = enemyCars[aiCarIdx];
+		// Initialize target selection system
+		if (typeof enemyCar.targetCar === "undefined") enemyCar.targetCar = null;
+		if (typeof enemyCar.targetSelectionTimer === "undefined") enemyCar.targetSelectionTimer = 0;
+		if (typeof enemyCar.targetSelectionDuration === "undefined") enemyCar.targetSelectionDuration = 120; // 2 seconds
+		// Target selection based on personality preferences
+		enemyCar.targetSelectionTimer++;
+		if (enemyCar.targetSelectionTimer >= enemyCar.targetSelectionDuration || enemyCar.targetCar === null) {
+			// Calculate preferred target speed and distance based on personality
+			var preferredSpeed = maxSpeed * 0.5; // Default preference
+			var preferredDistance = 300; // Default preference
+			// Adjust preferences based on personality
+			if (enemyCar.personality.name === "Aggressive Hunter") {
+				preferredSpeed = maxSpeed * 0.7; // Prefers fast targets
+				preferredDistance = 200; // Likes close combat
+			} else if (enemyCar.personality.name === "Sneaky Stalker") {
+				preferredSpeed = maxSpeed * 0.3; // Prefers slow/stationary targets
+				preferredDistance = 400; // Keeps distance for stalking
+			} else if (enemyCar.personality.name === "Strategic Ambusher") {
+				preferredSpeed = maxSpeed * 0.8; // Prefers fast targets to ambush
+				preferredDistance = 500; // Likes long range setup
+			} else if (enemyCar.personality.name === "Reckless Rambler") {
+				preferredSpeed = maxSpeed * 0.6; // Medium speed preference
+				preferredDistance = 250; // Medium distance preference
+			} else if (enemyCar.personality.name === "Persistent Pursuer") {
+				preferredSpeed = maxSpeed * 0.4; // Prefers slower targets for persistence
+				preferredDistance = 350; // Medium-long range preference
+			}
+			// Evaluate all potential targets (player + other enemy cars)
+			var bestTarget = null;
+			var bestScore = -1;
+			// Check player as potential target
+			var playerSpeed = Math.sqrt(velocityX * velocityX + velocityY * velocityY);
+			var playerDistance = Math.sqrt((carPlayer.x - enemyCar.x) * (carPlayer.x - enemyCar.x) + (carPlayer.y - enemyCar.y) * (carPlayer.y - enemyCar.y));
+			// Calculate score for player target
+			var speedDiff = Math.abs(playerSpeed - preferredSpeed);
+			var distanceDiff = Math.abs(playerDistance - preferredDistance);
+			var playerScore = 1000 - speedDiff * 2 - distanceDiff * 1.5; // Base high score for player
+			if (playerScore > bestScore) {
+				bestTarget = carPlayer;
+				bestScore = playerScore;
+			}
+			// Check other enemy cars as potential targets
+			for (var targetIdx = 0; targetIdx < enemyCars.length; targetIdx++) {
+				if (targetIdx === aiCarIdx) continue; // Don't target self
+				var potentialTarget = enemyCars[targetIdx];
+				var targetSpeedX = (potentialTarget.aiVelocityX || 0) + (potentialTarget.velocityX || 0);
+				var targetSpeedY = (potentialTarget.aiVelocityY || 0) + (potentialTarget.velocityY || 0);
+				var targetSpeed = Math.sqrt(targetSpeedX * targetSpeedX + targetSpeedY * targetSpeedY);
+				var targetDistance = Math.sqrt((potentialTarget.x - enemyCar.x) * (potentialTarget.x - enemyCar.x) + (potentialTarget.y - enemyCar.y) * (potentialTarget.y - enemyCar.y));
+				// Calculate score for this enemy car target
+				var speedDiff = Math.abs(targetSpeed - preferredSpeed);
+				var distanceDiff = Math.abs(targetDistance - preferredDistance);
+				var targetScore = 800 - speedDiff * 2 - distanceDiff * 1.5; // Lower base score than player
+				// Bonus for personality-specific preferences
+				if (enemyCar.personality.name === "Sneaky Stalker" && targetSpeed < maxSpeed * 0.2) {
+					targetScore += 150; // Bonus for very slow targets
+				} else if (enemyCar.personality.name === "Aggressive Hunter" && targetSpeed > maxSpeed * 0.6) {
+					targetScore += 100; // Bonus for fast targets
+				} else if (enemyCar.personality.name === "Strategic Ambusher" && targetDistance > 400) {
+					targetScore += 120; // Bonus for distant targets
+				}
+				if (targetScore > bestScore) {
+					bestTarget = potentialTarget;
+					bestScore = targetScore;
+				}
+			}
+			enemyCar.targetCar = bestTarget;
+			enemyCar.targetSelectionTimer = 0;
+			// Vary selection duration based on personality patience
+			enemyCar.targetSelectionDuration = Math.floor(90 + enemyCar.patience * 180); // 1.5-4.5 seconds
+		}
 		// Enemy car can switch between 'follow player' and 'free roam' AI modes
 		if (typeof enemyCar.aiMode === "undefined") enemyCar.aiMode = "follow";
 		if (typeof enemyCar.aiModeTimer === "undefined") enemyCar.aiModeTimer = 0;
 		if (typeof enemyCar.aiModeDuration === "undefined") enemyCar.aiModeDuration = 0;
 		// AI mode switching logic: change mode at intervals with personality-based preferences
 		enemyCar.aiModeTimer++;
 		if (enemyCar.aiModeTimer > enemyCar.aiModeDuration) {
-			// Calculate target speed for mode preference
-			var targetSpeed = Math.sqrt(velocityX * velocityX + velocityY * velocityY);
+			// Calculate target speed for mode preference using selected target
+			var targetSpeed = Math.sqrt(targetVelX * targetVelX + targetVelY * targetVelY);
 			var targetSpeedRatio = targetSpeed / maxSpeed; // 0 to 1
 			// Use personality-based follow chance as base, modified by target speed
 			var personalityFollowChance = enemyCar.baseFollowChance;
 			var speedModifier = 1.0;
@@ -724,9 +795,9 @@
 			// Adaptive strategy selection based on target speed and position
 			enemyCar.followStrategyTimer++;
 			if (enemyCar.followStrategyTimer > enemyCar.followStrategyDuration) {
 				// Calculate target speed and relative position for strategy selection
-				var targetSpeed = Math.sqrt(velocityX * velocityX + velocityY * velocityY);
+				var targetSpeed = Math.sqrt(targetVelX * targetVelX + targetVelY * targetVelY);
 				var targetSpeedRatio = targetSpeed / maxSpeed; // 0 to 1
 				var relativeDistance = Math.sqrt(aiDeltaX * aiDeltaX + aiDeltaY * aiDeltaY);
 				var relativeAngle = Math.atan2(aiDeltaX, -aiDeltaY);
 				var enemyAngle = enemyCar.rotation;
@@ -803,15 +874,27 @@
 						break;
 				}
 				enemyCar.followStrategyTimer = 0;
 			}
-			// Calculate base values
-			aiDeltaX = carPlayer.x - enemyCar.x;
-			aiDeltaY = carPlayer.y - enemyCar.y;
+			// Calculate base values using selected target
+			var targetX, targetY, targetVelX, targetVelY;
+			if (enemyCar.targetCar === carPlayer) {
+				targetX = carPlayer.x;
+				targetY = carPlayer.y;
+				targetVelX = velocityX;
+				targetVelY = velocityY;
+			} else {
+				targetX = enemyCar.targetCar.x;
+				targetY = enemyCar.targetCar.y;
+				targetVelX = (enemyCar.targetCar.aiVelocityX || 0) + (enemyCar.targetCar.velocityX || 0);
+				targetVelY = (enemyCar.targetCar.aiVelocityY || 0) + (enemyCar.targetCar.velocityY || 0);
+			}
+			aiDeltaX = targetX - enemyCar.x;
+			aiDeltaY = targetY - enemyCar.y;
 			aiDistance = Math.sqrt(aiDeltaX * aiDeltaX + aiDeltaY * aiDeltaY);
 			// Calculate relative velocity and approach angle for smarter pursuit
-			var relativeVelX = velocityX - (enemyCar.aiVelocityX || 0);
-			var relativeVelY = velocityY - (enemyCar.aiVelocityY || 0);
+			var relativeVelX = targetVelX - (enemyCar.aiVelocityX || 0);
+			var relativeVelY = targetVelY - (enemyCar.aiVelocityY || 0);
 			var approachAngle = Math.atan2(aiDeltaX, -aiDeltaY);
 			var enemyCurrentAngle = enemyCar.rotation;
 			var angleDiff = approachAngle - enemyCurrentAngle;
 			while (angleDiff > Math.PI) angleDiff -= 2 * Math.PI;
@@ -966,9 +1049,9 @@
 							aiTargetRotation = approachAngle + intimidationOffset;
 							aiPower = 0.7;
 							aiTargetVelocity = maxSpeed * aiPower * 0.85;
 							// Check if target is stationary and we're intimidating
-							var currentTargetSpeed = Math.sqrt(velocityX * velocityX + velocityY * velocityY);
+							var currentTargetSpeed = Math.sqrt(targetVelX * targetVelX + targetVelY * targetVelY);
 							if (currentTargetSpeed < maxSpeed * 0.05 && typeof enemyCar.intimidationCount !== "undefined") {
 								// Mark intimidation as successful after maintaining perfect distance for a while
 								if (typeof enemyCar.intimidationTimer === "undefined") enemyCar.intimidationTimer = 0;
 								enemyCar.intimidationTimer++;
@@ -1018,10 +1101,10 @@
 						aiTargetVelocity = maxSpeed * aiPower * 0.8;
 					} else {
 						// Long range interception
 						var predictionTime = Math.min(2.5, aiDistance / maxSpeed * 0.9);
-						var interceptX = carPlayer.x + playerVelX * predictionTime;
-						var interceptY = carPlayer.y + playerVelY * predictionTime;
+						var interceptX = targetX + targetVelX * predictionTime;
+						var interceptY = targetY + targetVelY * predictionTime;
 						// Keep predicted position within bounds
 						interceptX = Math.max(80, Math.min(1968, interceptX));
 						interceptY = Math.max(80, Math.min(2106, interceptY));
 						// Calculate optimal interception approach
@@ -1112,25 +1195,25 @@
 						enemyCar.freeRoamSpeed = maxSpeed * (0.6 + Math.random() * 0.3);
 						break;
 				}
 			}
-			// Add some player awareness even in free roam - occasionally look towards player
-			var playerDistance = Math.sqrt((carPlayer.x - enemyCar.x) * (carPlayer.x - enemyCar.x) + (carPlayer.y - enemyCar.y) * (carPlayer.y - enemyCar.y));
-			var playerInfluence = 0;
-			if (playerDistance < 400) {
+			// Add some target awareness even in free roam - occasionally look towards current target
+			var targetDistance = aiDistance;
+			var targetInfluence = 0;
+			if (targetDistance < 400) {
 				// Within 400 pixels
-				// Closer player = more influence on direction
-				playerInfluence = Math.max(0, (400 - playerDistance) / 400 * 0.3); // Up to 30% influence
+				// Closer target = more influence on direction
+				targetInfluence = Math.max(0, (400 - targetDistance) / 400 * 0.3); // Up to 30% influence
 				if (Math.random() < 0.02) {
-					// 2% chance per frame to look at player
-					var playerAngle = Math.atan2(carPlayer.x - enemyCar.x, -(carPlayer.y - enemyCar.y));
-					// Blend current angle with player angle
+					// 2% chance per frame to look at target
+					var targetAngle = Math.atan2(targetX - enemyCar.x, -(targetY - enemyCar.y));
+					// Blend current angle with target angle
 					var currentVecX = Math.sin(enemyCar.freeRoamAngle);
 					var currentVecY = -Math.cos(enemyCar.freeRoamAngle);
-					var playerVecX = Math.sin(playerAngle) * playerInfluence;
-					var playerVecY = -Math.cos(playerAngle) * playerInfluence;
-					var blendedVecX = currentVecX * (1 - playerInfluence) + playerVecX;
-					var blendedVecY = currentVecY * (1 - playerInfluence) + playerVecY;
+					var targetVecX = Math.sin(targetAngle) * targetInfluence;
+					var targetVecY = -Math.cos(targetAngle) * targetInfluence;
+					var blendedVecX = currentVecX * (1 - targetInfluence) + targetVecX;
+					var blendedVecY = currentVecY * (1 - targetInfluence) + targetVecY;
 					enemyCar.freeRoamAngle = Math.atan2(blendedVecX, -blendedVecY);
 				}
 			}
 			aiTargetRotation = enemyCar.freeRoamAngle;