/**** 
* 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 (no logic yet)
	self.velocityX = 0;
	self.velocityY = 0;
	self.rotation = 0;
	// Mass property for physics calculations
	self.mass = 800 + Math.random() * 800; // Random mass between 800-1600 kg
	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 enemy car in gameplay area
var enemyCar = new EnemyCar();
enemyCar.x = 500;
enemyCar.y = 500;
gameplayBackground.addChild(enemyCar);
// 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;
// Vehicle mass properties
var playerMass = 1200; // Player car mass in kg
// 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)
// 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);
		}
	}
	// Particle system for car exhaust
	if (!game.particles) {
		game.particles = [];
	}
	// Generate particles proportional to current velocity (from very little to much)
	var totalSpeed = Math.sqrt(velocityX * velocityX + velocityY * velocityY);
	var speedRatio = totalSpeed / maxSpeed; // 0 to 1 ratio of current speed to max speed
	// Calculate particle generation frequency based on speed (more speed = more frequent particles)
	var particleFrequency = Math.max(1, Math.floor(8 - speedRatio * 6)); // From every 8 ticks (slow) to every 2 ticks (fast)
	if (speedRatio > 0.05 && LK.ticks % particleFrequency === 0) {
		// Only generate particles when moving at least 5% of max speed
		// Calculate particle spawn position further behind the car (20% closer for smaller car)
		var particleSpawnX = carPlayer.x - Math.sin(carPlayer.rotation) * 55;
		var particleSpawnY = carPlayer.y + Math.cos(carPlayer.rotation) * 55;
		// Create particles based on speed - more speed = more particles
		var particleCount = Math.max(1, Math.floor(speedRatio * 3)); // 1-3 particles based on speed ratio
		for (var p = 0; p < particleCount; p++) {
			// Create new particle
			var newParticle = new Particle();
			newParticle.x = particleSpawnX + (Math.random() - 0.5) * 19.2; // 20% smaller spawn area
			newParticle.y = particleSpawnY + (Math.random() - 0.5) * 19.2;
			// Add velocity variation based on car movement (20% reduced for smaller scale)
			newParticle.velocityX += -velocityX * 0.12 + (Math.random() - 0.5) * 2.4;
			newParticle.velocityY += -velocityY * 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
			});
		}
	}
	// 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 enemy car
	if (!carPlayer.lastColliding) carPlayer.lastColliding = false;
	var currentColliding = carPlayer.intersects(enemyCar);
	if (!carPlayer.lastColliding && currentColliding) {
		// Collision just started - calculate collision physics
		var carSpeed = Math.sqrt(velocityX * velocityX + velocityY * velocityY);
		// Calculate collision direction (from enemy car to player car)
		var collisionDeltaX = carPlayer.x - enemyCar.x;
		var collisionDeltaY = carPlayer.y - enemyCar.y;
		var collisionDistance = Math.sqrt(collisionDeltaX * collisionDeltaX + collisionDeltaY * collisionDeltaY);
		// Normalize collision direction
		if (collisionDistance > 0) {
			collisionDeltaX /= collisionDistance;
			collisionDeltaY /= collisionDistance;
		}
		// Calculate player car facing direction
		var playerFacingX = Math.sin(carPlayer.rotation);
		var playerFacingY = -Math.cos(carPlayer.rotation);
		// Calculate how much player velocity aligns with their facing direction
		var velocityMagnitude = Math.sqrt(velocityX * velocityX + velocityY * velocityY);
		var facingDotVelocity = 0;
		if (velocityMagnitude > 0) {
			// Normalize velocity vector
			var normalizedVelX = velocityX / velocityMagnitude;
			var normalizedVelY = velocityY / velocityMagnitude;
			// Calculate dot product to see if moving forward or backward
			facingDotVelocity = playerFacingX * normalizedVelX + playerFacingY * normalizedVelY;
		}
		// EXAGGERATED COLLISION PHYSICS - Speed-based force multiplier
		var speedRatio = carSpeed / maxSpeed; // 0 to 1 ratio of current speed
		var speedExaggeration = Math.pow(speedRatio, 2) * 3 + 0.2; // Quadratic scaling: gentle at low speeds, explosive at high speeds
		// Calculate momentum transfer with exaggerated speed effect
		var baseTransferRatio = 0.4 + speedRatio * 1.2; // From 0.4 (gentle push) to 1.6 (massive transfer)
		var directionBonus = Math.max(0, facingDotVelocity) * (0.3 + speedRatio * 0.7); // More directional bonus at high speeds
		var totalTransferRatio = (baseTransferRatio + directionBonus) * speedExaggeration;
		// Calculate mass-based momentum transfer with speed amplification
		var massRatio = playerMass / (playerMass + enemyCar.mass);
		var transferMultiplier = totalTransferRatio * massRatio;
		// Transfer velocity from player to enemy car with exaggerated effect
		var transferVelocityX = velocityX * transferMultiplier;
		var transferVelocityY = velocityY * transferMultiplier;
		// Apply transferred velocity to enemy car with additional speed-based boost
		var speedBoost = 1 + speedRatio * 2; // Extra boost based on impact speed
		enemyCar.velocityX += transferVelocityX * speedBoost;
		enemyCar.velocityY += transferVelocityY * speedBoost;
		// Reduce player velocity by transferred amount (less reduction at high speeds for dramatic effect)
		var playerReduction = 0.6 + speedRatio * 0.3; // More dramatic velocity loss at high speeds
		velocityX -= transferVelocityX * playerReduction;
		velocityY -= transferVelocityY * playerReduction;
		// Exaggerated collision bounce based on speed
		var bounceStrength = carSpeed * (0.2 + speedRatio * 1.5); // Much stronger bounce at high speeds
		var playerBounceX = -collisionDeltaX * bounceStrength * (enemyCar.mass / (playerMass + enemyCar.mass));
		var playerBounceY = -collisionDeltaY * bounceStrength * (enemyCar.mass / (playerMass + enemyCar.mass));
		var enemyBounceX = collisionDeltaX * bounceStrength * (playerMass / (playerMass + enemyCar.mass)) * speedBoost;
		var enemyBounceY = collisionDeltaY * bounceStrength * (playerMass / (playerMass + enemyCar.mass)) * speedBoost;
		// Apply bounce velocities
		velocityX += playerBounceX;
		velocityY += playerBounceY;
		enemyCar.velocityX += enemyBounceX;
		enemyCar.velocityY += enemyBounceY;
		// Separate cars with speed-based distance
		var separationDistance = 60 + speedRatio * 40; // Longer separation at high speeds
		carPlayer.x = enemyCar.x + collisionDeltaX * separationDistance;
		carPlayer.y = enemyCar.y + collisionDeltaY * separationDistance;
		// Visual feedback with intensity based on speed
		var flashIntensity = 300 + speedRatio * 700; // Longer flash for harder impacts
		var flashColor = speedRatio > 0.7 ? 0xff0000 : speedRatio > 0.3 ? 0xff4400 : 0xff8800; // Red for hard hits, orange for gentle
		LK.effects.flashObject(carPlayer, flashColor, flashIntensity);
		// Enemy car also flashes based on impact
		LK.effects.flashObject(enemyCar, flashColor, flashIntensity * 0.8);
		// Play collision sound
		var collisionSounds = ['SonidoChoque', 'SonidoChoque2', 'SonidoChoque3'];
		var randomSound = collisionSounds[Math.floor(Math.random() * collisionSounds.length)];
		LK.getSound(randomSound).play();
	}
	// Update last collision state
	carPlayer.lastColliding = currentColliding;
	// Update enemy car physics (simple momentum with friction)
	enemyCar.x += enemyCar.velocityX;
	enemyCar.y += enemyCar.velocityY;
	// Apply friction to enemy car
	enemyCar.velocityX *= 0.95;
	enemyCar.velocityY *= 0.95;
	// 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;
	}
	// Update speed display
	speedText.setText('Speed: ' + Math.round(totalSpeed));
};

===================================================================
--- original.js
+++ change.js
@@ -417,41 +417,50 @@
 			var normalizedVelY = velocityY / velocityMagnitude;
 			// Calculate dot product to see if moving forward or backward
 			facingDotVelocity = playerFacingX * normalizedVelX + playerFacingY * normalizedVelY;
 		}
-		// Calculate momentum transfer based on player's facing direction and velocity alignment
-		var baseTransferRatio = 0.6; // Base amount of velocity to transfer
-		var directionBonus = Math.max(0, facingDotVelocity) * 0.4; // Bonus for moving forward
-		var totalTransferRatio = baseTransferRatio + directionBonus;
-		// Calculate mass-based momentum transfer
+		// EXAGGERATED COLLISION PHYSICS - Speed-based force multiplier
+		var speedRatio = carSpeed / maxSpeed; // 0 to 1 ratio of current speed
+		var speedExaggeration = Math.pow(speedRatio, 2) * 3 + 0.2; // Quadratic scaling: gentle at low speeds, explosive at high speeds
+		// Calculate momentum transfer with exaggerated speed effect
+		var baseTransferRatio = 0.4 + speedRatio * 1.2; // From 0.4 (gentle push) to 1.6 (massive transfer)
+		var directionBonus = Math.max(0, facingDotVelocity) * (0.3 + speedRatio * 0.7); // More directional bonus at high speeds
+		var totalTransferRatio = (baseTransferRatio + directionBonus) * speedExaggeration;
+		// Calculate mass-based momentum transfer with speed amplification
 		var massRatio = playerMass / (playerMass + enemyCar.mass);
 		var transferMultiplier = totalTransferRatio * massRatio;
-		// Transfer velocity from player to enemy car based on facing direction
+		// Transfer velocity from player to enemy car with exaggerated effect
 		var transferVelocityX = velocityX * transferMultiplier;
 		var transferVelocityY = velocityY * transferMultiplier;
-		// Apply transferred velocity to enemy car
-		enemyCar.velocityX += transferVelocityX;
-		enemyCar.velocityY += transferVelocityY;
-		// Reduce player velocity by transferred amount
-		velocityX -= transferVelocityX * 0.8; // Player loses less velocity to maintain control
-		velocityY -= transferVelocityY * 0.8;
-		// Add collision bounce based on collision normal
-		var bounceStrength = carSpeed * 0.3;
+		// Apply transferred velocity to enemy car with additional speed-based boost
+		var speedBoost = 1 + speedRatio * 2; // Extra boost based on impact speed
+		enemyCar.velocityX += transferVelocityX * speedBoost;
+		enemyCar.velocityY += transferVelocityY * speedBoost;
+		// Reduce player velocity by transferred amount (less reduction at high speeds for dramatic effect)
+		var playerReduction = 0.6 + speedRatio * 0.3; // More dramatic velocity loss at high speeds
+		velocityX -= transferVelocityX * playerReduction;
+		velocityY -= transferVelocityY * playerReduction;
+		// Exaggerated collision bounce based on speed
+		var bounceStrength = carSpeed * (0.2 + speedRatio * 1.5); // Much stronger bounce at high speeds
 		var playerBounceX = -collisionDeltaX * bounceStrength * (enemyCar.mass / (playerMass + enemyCar.mass));
 		var playerBounceY = -collisionDeltaY * bounceStrength * (enemyCar.mass / (playerMass + enemyCar.mass));
-		var enemyBounceX = collisionDeltaX * bounceStrength * (playerMass / (playerMass + enemyCar.mass));
-		var enemyBounceY = collisionDeltaY * bounceStrength * (playerMass / (playerMass + enemyCar.mass));
+		var enemyBounceX = collisionDeltaX * bounceStrength * (playerMass / (playerMass + enemyCar.mass)) * speedBoost;
+		var enemyBounceY = collisionDeltaY * bounceStrength * (playerMass / (playerMass + enemyCar.mass)) * speedBoost;
 		// Apply bounce velocities
 		velocityX += playerBounceX;
 		velocityY += playerBounceY;
 		enemyCar.velocityX += enemyBounceX;
 		enemyCar.velocityY += enemyBounceY;
-		// Separate cars to prevent overlap
-		var separationDistance = 80;
+		// Separate cars with speed-based distance
+		var separationDistance = 60 + speedRatio * 40; // Longer separation at high speeds
 		carPlayer.x = enemyCar.x + collisionDeltaX * separationDistance;
 		carPlayer.y = enemyCar.y + collisionDeltaY * separationDistance;
-		// Visual feedback for collision
-		LK.effects.flashObject(carPlayer, 0xff0000, 500);
+		// Visual feedback with intensity based on speed
+		var flashIntensity = 300 + speedRatio * 700; // Longer flash for harder impacts
+		var flashColor = speedRatio > 0.7 ? 0xff0000 : speedRatio > 0.3 ? 0xff4400 : 0xff8800; // Red for hard hits, orange for gentle
+		LK.effects.flashObject(carPlayer, flashColor, flashIntensity);
+		// Enemy car also flashes based on impact
+		LK.effects.flashObject(enemyCar, flashColor, flashIntensity * 0.8);
 		// Play collision sound
 		var collisionSounds = ['SonidoChoque', 'SonidoChoque2', 'SonidoChoque3'];
 		var randomSound = collisionSounds[Math.floor(Math.random() * collisionSounds.length)];
 		LK.getSound(randomSound).play();