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

/**** 
* Classes
****/ 
var Motorcycle = Container.expand(function () {
	var self = Container.call(this);
	var motorcycleGraphics = self.attachAsset('motorcycle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.health = 3;
	self.power = 100;
	self.speed = 0;
	self.maxSpeed = 3;
	self.x = 0;
	self.update = function () {
		if (gameStarted) {
			if (self.speed < self.maxSpeed) {
				LK.getSound('corruptosLoTuyos').play();
				self.speed += 0.02;
			}
			roadOffset += self.speed;
		}
	};
	self.takeDamage = function (damageAmount) {
		damageAmount = damageAmount || 3;
		self.power = Math.max(0, self.power - damageAmount);
		LK.effects.flashObject(self, 0xff0000, 500);
		LK.getSound('hit').play();
		if (self.power <= 0) {
			LK.showGameOver();
		}
	};
	self.restorePower = function (amount) {
		amount = amount || 3;
		self.power = Math.min(100, self.power + amount);
		LK.getSound('power_up').play();
	};
	return self;
});
var PowerItem = Container.expand(function () {
	var self = Container.call(this);
	var itemGraphics = self.attachAsset('power_item', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.velocityX = 0;
	self.velocityY = 0;
	self.gravity = 0.15;
	self.update = function () {
		self.x += self.velocityX;
		self.y += self.velocityY;
		self.velocityY += self.gravity;
	};
	return self;
});
var Projectile = Container.expand(function (isHeavy) {
	var self = Container.call(this);
	self.isHeavy = isHeavy || false;
	var assetName = self.isHeavy ? 'heavy_projectile' : 'projectile';
	var projectileGraphics = self.attachAsset(assetName, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.velocityX = 0;
	self.velocityY = 0;
	self.gravity = 0;
	self.update = function () {
		self.x += self.velocityX;
		self.y += self.velocityY;
		self.velocityY += self.gravity;
		self.rotation += 0.1;
	};
	return self;
});
var RoadsideObject = Container.expand(function (type) {
	var self = Container.call(this);
	self.objectType = type || 'person';
	var objectGraphics = self.attachAsset(self.objectType, {
		anchorX: 0.5,
		anchorY: 1.0
	});
	self.throwTimer = 0;
	// lateral offset base by type (trees further from road than people)
	self.sideOffsetBase = 120;
	if (type === 'tree') {
		self.sideOffsetBase = 400;
	}
	if (type === 'sign') {
		self.sideOffsetBase = 160;
	}
	// Configurar delay de lanzamiento por tipo
	var baseMin = 800,
		baseRand = 240;
	if (type === 'person') {
		baseMin = 840;
		baseRand = 320;
	}
	if (type === 'person2') {
		baseMin = 720;
		baseRand = 280;
	}
	if (type === 'person3') {
		baseMin = 600;
		baseRand = 360;
	}
	self.throwDelay = Math.random() * baseRand + baseMin;
	self.isLeftSide = true;
	self.originalY = 0;
	self.hasThrownThisCycle = false;
	self.minThrowDistanceFromMotorcycleFactor = 0.6;
	self.update = function () {
		if (self.objectType === 'person' || self.objectType === 'person2' || self.objectType === 'person3') {
			self.throwTimer++;
			if (self.throwTimer >= self.throwDelay && gameStarted && !self.hasThrownThisCycle) {
				var requiredDistance = horizonDistance * self.minThrowDistanceFromMotorcycleFactor;
				if (self.y <= motorcycle.y - requiredDistance) {
					self.throwObject();
					self.hasThrownThisCycle = true;
					self.throwTimer = 0;
					// Recalcular segfn tipo
					var nMin = 400,
						nRand = 120;
					if (self.objectType === 'person') {
						nMin = 420;
						nRand = 160;
					}
					if (self.objectType === 'person2') {
						nMin = 360;
						nRand = 140;
					}
					if (self.objectType === 'person3') {
						nMin = 300;
						nRand = 180;
					}
					self.throwDelay = Math.random() * nRand + nMin;
				}
			}
		}
		if (gameStarted && motorcycle.speed > 0) {
			// Enhanced movement with better perspective scaling
			var distBefore = Math.max(0, roadY - self.y);
			var perspBefore = Math.max(0.01, Math.min(1, 1 - distBefore / horizonDistance));
			var speedFactor = 1 + 2.5 * perspBefore; // Slightly increased speed factor
			self.y += motorcycle.speed * 3.2 * speedFactor; // Increased base movement speed
			// Calculate perspective with extended range for smoother transitions
			var currentDistance = Math.max(0, extendedRoadY - self.y);
			var perspective = 1 - currentDistance / horizonDistance;
			// Allow objects to appear much earlier (when perspective is negative) and scale properly
			if (perspective > -2.0) {
				// Extended range for earlier appearance
				// Calculate road width with minimum constraint for stability
				var roadWidth = 2048 * Math.max(0.005, perspective);
				var sideOffset = self.sideOffsetBase * Math.max(0.005, perspective);
				// Position objects with extended side margins
				// Additional margin for better visibility
				if (self.isLeftSide) {
					self.x = 1024 - roadWidth / 2 - sideOffset;
				} else {
					self.x = 1024 + roadWidth / 2 + sideOffset;
				}
				// Enhanced scaling that allows very small objects in distance
				var finalScale = Math.max(0.0005, perspective); // Even smaller minimum scale
				if (finalScale < 0.01) {
					finalScale = 0.01;
				} // Prevent invisible objects
				self.scaleX = (self.isLeftSide ? -1 : 1) * finalScale;
				self.scaleY = finalScale;
			}
			if (gameStarted && (self.objectType === 'person' || self.objectType === 'person2' || self.objectType === 'person3') && !self.hasThrownThisCycle) {
				var requiredDistanceNow = horizonDistance * self.minThrowDistanceFromMotorcycleFactor;
				if (self.y <= motorcycle.y - requiredDistanceNow) {
					self.throwObject();
					self.hasThrownThisCycle = true;
					self.throwTimer = 0;
					var nMin2 = 400,
						nRand2 = 120;
					if (self.objectType === 'person') {
						nMin2 = 420;
						nRand2 = 160;
					}
					if (self.objectType === 'person2') {
						nMin2 = 360;
						nRand2 = 140;
					}
					if (self.objectType === 'person3') {
						nMin2 = 300;
						nRand2 = 180;
					}
					self.throwDelay = Math.random() * nRand2 + nMin2;
				}
			}
			// Reset when completely off screen with much larger margin
			if (self.y > extendedRoadY + 1600 || perspective < -2.0) {
				// Extended thresholds
				self.y = self.originalY;
				var resetDistance = extendedRoadY - self.originalY;
				var resetPerspective = Math.max(0.005, Math.min(1, 1 - resetDistance / horizonDistance));
				var resetRoadWidth = 2048 * resetPerspective;
				var resetSideOffset = self.sideOffsetBase * resetPerspective;
				self.scaleX = (self.isLeftSide ? -1 : 1) * resetPerspective;
				self.scaleY = resetPerspective;
				if (self.isLeftSide) {
					self.x = 1024 - resetRoadWidth / 2 - resetSideOffset;
				} else {
					self.x = 1024 + resetRoadWidth / 2 + resetSideOffset;
				}
				self.hasThrownThisCycle = false;
			}
		}
	};
	self.throwObject = function () {
		if (projectiles.length >= 3) {
			return;
		}
		var isHeavy = Math.random() < 0.15;
		var projectile = new Projectile(isHeavy);
		projectile.x = self.x;
		projectile.y = self.y - 20;
		var targetX = motorcycle.x + (Math.random() - 0.5) * 260;
		var horizontalFactor = isHeavy ? 0.009 : 0.008;
		projectile.velocityX = (targetX - projectile.x) * horizontalFactor;
		var initialUpImpulse = isHeavy ? -6 - Math.random() * 2 : -8 - Math.random() * 3;
		projectile.velocityY = initialUpImpulse;
		projectile.gravity = isHeavy ? 0.35 : 0.28;
		projectiles.push(projectile);
		game.addChild(projectile);
		LK.getSound('throw').play();
	};
	return self;
});
var Truck = Container.expand(function () {
	var self = Container.call(this);
	var truckGraphics = self.attachAsset('truck', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// karina indicator above the truck before dropping power item
	var karinaSprite = self.attachAsset('karina', {
		anchorX: 0.5,
		anchorY: 1.0
	});
	self.karinaBaseY = -450;
	self.karinaUpY = self.karinaBaseY - 30;
	karinaSprite.y = self.karinaBaseY;
	karinaSprite.scaleX = 3.0;
	karinaSprite.scaleY = 3.0;
	karinaSprite.visible = false;
	self.speed = -6;
	self.active = true;
	self.dropTimer = 0;
	self.dropDelay = 120;
	self.targetY = horizonY + (extendedRoadY - horizonY) * 0.25;
	self.baseXFactorFromCenter = 0.42;
	self.oscAmp = 30;
	self.oscSpeed = 0.02;
	self.oscPhase = Math.random() * Math.PI * 2;
	self.karinaLead = 30; // frames before drop to show karina
	self.karinaAnimating = false;
	self.update = function () {
		if (self.active) {
			if (self.y > self.targetY) {
				self.y += self.speed;
				if (self.y <= self.targetY) {
					self.y = self.targetY;
				}
			} else {
				self.y = self.targetY;
			}
			var currentDistance = roadY - self.y;
			var perspective = Math.max(0.01, Math.min(1, 1 - currentDistance / (roadY - horizonY)));
			var roadWidthAtY = 2048 * perspective;
			var roadRightEdge = 1024 + roadWidthAtY / 2;
			var centerX = 1024;
			var targetBaseX = centerX + roadWidthAtY * self.baseXFactorFromCenter;
			self.oscPhase += self.oscSpeed;
			self.x = Math.min(roadRightEdge - 40 * perspective, targetBaseX + Math.sin(self.oscPhase) * self.oscAmp * perspective);
			var distanceToHorizon = extendedRoadY - horizonY;
			var currentDistance = extendedRoadY - self.y;
			var perspective = Math.max(0, 1 - currentDistance / distanceToHorizon);
			var centerX = 1024;
			self.scaleX = perspective;
			self.scaleY = perspective;
			if (gameStarted) {
				self.dropTimer++;
				if (!karinaSprite.visible && self.dropTimer >= self.dropDelay - self.karinaLead) {
					karinaSprite.visible = true;
					if (!self.karinaAnimating) {
						self.karinaAnimating = true;
						var upDur = Math.max(6, Math.floor(self.karinaLead * 0.4));
						var downDur = Math.max(6, self.karinaLead - upDur);
						tween(karinaSprite, {
							y: self.karinaUpY
						}, {
							duration: upDur,
							easing: tween.easeOut,
							onFinish: function onFinish() {
								tween(karinaSprite, {
									y: self.karinaBaseY
								}, {
									duration: downDur,
									easing: tween.easeIn,
									onFinish: function onFinish() {
										self.karinaAnimating = false;
									}
								});
							}
						});
					}
				}
				if (self.dropTimer >= self.dropDelay) {
					self.dropPowerItem();
					self.dropTimer = 0;
					karinaSprite.visible = false;
					karinaSprite.y = self.karinaBaseY;
					self.karinaAnimating = false;
				}
			}
		}
	};
	self.dropPowerItem = function () {
		var powerItem = new PowerItem();
		// Start from karina sprite position (global position within truck)
		var karinaWorldX = self.x + karinaSprite.x * self.scaleX;
		var karinaWorldY = self.y + karinaSprite.y * self.scaleY;
		powerItem.x = karinaWorldX;
		powerItem.y = karinaWorldY;
		// choose random point on the road (not targeting the motorcycle)
		var roadLeft = 200;
		var roadRight = 1848;
		var margin = 60;
		var targetX = roadLeft + margin + Math.random() * Math.max(0, roadRight - roadLeft - margin * 2);
		var targetY = extendedRoadY;
		// Calculate parabolic trajectory
		var distanceX = targetX - powerItem.x;
		var distanceY = targetY - powerItem.y;
		var timeToTarget = 60; // frames to reach target
		// Horizontal velocity (constant)
		powerItem.velocityX = distanceX / timeToTarget;
		// Initial vertical velocity for parabolic arc
		// Using kinematic equation: finalY = initialY + initialVy*t + 0.5*gravity*t^2
		// Solving for initialVy: initialVy = (finalY - initialY - 0.5*gravity*t^2) / t
		var gravity = 0.15;
		powerItem.velocityY = (distanceY - 0.5 * gravity * timeToTarget * timeToTarget) / timeToTarget;
		powerItems.push(powerItem);
		game.addChild(powerItem);
	};
	return self;
});

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

/**** 
* Game Code
****/ 
var roadY = 2732;
var horizonY = Math.floor(roadY * 0.6);
var roadOffset = 0;
var gameStarted = false;
var phraseTimer = 0;
var phraseInterval = 600; // 10 seconds at 60 FPS
var phraseAssets = ['frase1', 'frase2', 'frase3', 'frase4', 'frase5', 'frase6'];
var trucksCleared = false;
var roadSegments = [];
var roadLines = [];
var leftSidewalks = [];
var rightSidewalks = [];
var totalSegments = 90;
var horizonDistance = roadY - horizonY;
var segmentSpacing = horizonDistance / totalSegments;
// Agregar margen inferior para evitar que la ruta se corte
var bottomMargin = 400;
var extendedRoadY = roadY + bottomMargin;
LK.playMusic('gritos');
LK.playMusic('moto');
game.addChild(LK.getAsset('cesped', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 1024,
	y: 2500,
	scaleX: 5,
	scaleY: 3.45
}));
game.addChild(LK.getAsset('skyline', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 1024,
	y: 739,
	scaleX: 21,
	scaleY: 18
}));
for (var i = 0; i < totalSegments; i++) {
	var distance = i * segmentSpacing;
	var yPosition = roadY - distance;
	var perspective = 1 - distance / horizonDistance;
	var roadWidth = 2048 * perspective;
	var segmentHeight = segmentSpacing * 1.2 * perspective;
	if (yPosition >= horizonY) {
		if (i % 4 == 0) {
			var centerLine = game.addChild(LK.getAsset('road_line', {
				anchorX: 0.5,
				anchorY: 0.5,
				x: 1024,
				y: yPosition,
				scaleX: perspective * 2,
				scaleY: perspective * 2
			}));
			roadLines.push(centerLine);
		}
		var roadSeg = game.addChild(LK.getAsset('road_segment', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: 1024,
			y: yPosition,
			scaleX: roadWidth / 100,
			scaleY: segmentSpacing / 5 * perspective
		}));
		roadSegments.push(roadSeg);
	}
}
var powerBarBg = LK.getAsset('power_bar_bg', {
	anchorX: 0.5,
	anchorY: 1.0,
	x: 600,
	y: -300
});
LK.gui.center.addChild(powerBarBg);
var powerBarFill = LK.getAsset('power_bar_fill', {
	anchorX: 0.5,
	anchorY: 1.0,
	x: 600,
	y: -300
});
LK.gui.center.addChild(powerBarFill);
var powerItems = [];
var roadsideObjects = [];
var projectiles = [];
var objectTypes = ['person', 'tree', 'sign'];
// incluir variantes de personas
objectTypes = ['person', 'person2', 'person3', 'person3', 'tree', 'sign'];
for (var i = 0; i < 12; i++) {
	var objectType = objectTypes[i % objectTypes.length];
	var leftObject = game.addChild(new RoadsideObject(objectType));
	// Start objects much earlier - extend beyond horizon for smoother appearance
	var extendedDistance = horizonDistance * 2.5; // Aumentado de 1.5 a 2.5 para mayor distancia
	var distance = i / 12 * extendedDistance;
	var yPos = extendedRoadY - distance; // Usar extendedRoadY en lugar de roadY
	var perspective = 1 - distance / extendedDistance;
	var roadWidth = 2048 * Math.max(0.005, perspective);
	// Remove horizon restriction to allow objects to start from far distance
	leftObject.x = 1024 - roadWidth / 2 - 120 * Math.max(0.005, perspective);
	leftObject.y = yPos;
	leftObject.originalY = yPos;
	leftObject.scaleX = -Math.max(0.01, perspective); // Ensure minimum visible scale
	leftObject.scaleY = Math.max(0.01, perspective);
	leftObject.isLeftSide = true;
	roadsideObjects.push(leftObject);
}
for (var i = 0; i < 12; i++) {
	var objectType = objectTypes[i % objectTypes.length];
	var rightObject = game.addChild(new RoadsideObject(objectType));
	// Start objects much earlier - extend beyond horizon for smoother appearance
	var extendedDistance = horizonDistance * 2.5; // Aumentado de 1.5 a 2.5 para mayor distancia
	var distance = i / 12 * extendedDistance;
	var yPos = extendedRoadY - distance; // Usar extendedRoadY en lugar de roadY
	var perspective = 1 - distance / extendedDistance;
	var roadWidth = 2048 * Math.max(0.005, perspective);
	// Remove horizon restriction to allow objects to start from far distance
	rightObject.x = 1024 + roadWidth / 2 + 120 * Math.max(0.005, perspective);
	rightObject.y = yPos;
	rightObject.originalY = yPos;
	rightObject.scaleX = Math.max(0.01, perspective); // Ensure minimum visible scale
	rightObject.scaleY = Math.max(0.01, perspective);
	rightObject.isLeftSide = false;
	roadsideObjects.push(rightObject);
}
var scoreTxt = new Text2('Distancia: 0m', {
	size: 80,
	fill: 0xFFFFFF
});
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
var healthTxt = new Text2('Power: 3', {
	size: 60,
	fill: 0xFF0000
});
healthTxt.anchor.set(0, 0);
healthTxt.x = 0;
healthTxt.y = 0;
var motorcycle = game.addChild(new Motorcycle());
motorcycle.x = 800;
motorcycle.y = roadY - 250;
LK.gui.topRight.addChild(healthTxt);
var dragStartX = 0;
var isDragging = false;
game.down = function (x, y, obj) {
	if (gameStarted) {
		isDragging = true;
		dragStartX = x;
	}
};
game.move = function (x, y, obj) {
	if (isDragging && gameStarted) {
		var deltaX = x - dragStartX;
		var newX = motorcycle.x + deltaX * 0.5;
		var roadLeft = 200;
		var roadRight = 1848;
		if (newX >= roadLeft && newX <= roadRight) {
			motorcycle.x = newX;
		}
		dragStartX = x;
	}
};
game.up = function (x, y, obj) {
	isDragging = false;
};
var trucks = [];
var truck1 = game.addChild(new Truck());
truck1.x = 1024;
truck1.y = roadY - 600;
trucks.push(truck1);
game.update = function () {
	if (!trucksCleared) {
		var allTrucksCleared = true;
		for (var i = 0; i < trucks.length; i++) {
			if (trucks[i].y > roadY - 300) {
				allTrucksCleared = false;
				break;
			}
		}
		if (allTrucksCleared) {
			trucksCleared = true;
			gameStarted = true;
		}
	}
	if (gameStarted && motorcycle.speed > 0) {
		var movementFactor = 3;
		var offset = roadOffset * movementFactor % horizonDistance;
		for (var i = 0; i < roadSegments.length; i++) {
			var distanceAlong = (i * segmentSpacing + offset) % horizonDistance;
			var yPosition = extendedRoadY - distanceAlong;
			var perspective = Math.max(0.01, Math.min(1, 1 - distanceAlong / horizonDistance));
			var roadWidth = 2048 * perspective;
			roadSegments[i].y = yPosition;
			roadSegments[i].scaleX = roadWidth / 100;
			roadSegments[i].scaleY = horizonDistance / totalSegments / 5 * perspective;
		}
		var lineSpacing = segmentSpacing * 4;
		for (var j = 0; j < roadLines.length; j++) {
			var lineDistance = (j * lineSpacing + offset) % horizonDistance;
			var lineY = extendedRoadY - lineDistance;
			var linePerspective = Math.max(0.01, Math.min(1, 1 - lineDistance / horizonDistance));
			roadLines[j].y = lineY;
			var lineCenterShift = typeof curveCenterShift !== 'undefined' ? curveCenterShift : 0;
			roadLines[j].x = 1024 + lineCenterShift;
			roadLines[j].scaleX = linePerspective * 3;
			roadLines[j].scaleY = linePerspective * 4;
		}
		for (var k = 0; k < leftSidewalks.length; k++) {
			var swDistance = (k * segmentSpacing + offset) % horizonDistance;
			var swY = extendedRoadY - swDistance;
			var swPerspective = Math.max(0.01, Math.min(1, 1 - swDistance / horizonDistance));
			var swRoadWidth = 2048 * swPerspective;
			var segmentHeight = horizonDistance / totalSegments * 1.2 * swPerspective;
			leftSidewalks[k].y = swY;
			rightSidewalks[k].y = swY;
			leftSidewalks[k].x = 1024 - swRoadWidth / 2 - 80 * swPerspective;
			leftSidewalks[k].scaleX = swPerspective * 2;
			leftSidewalks[k].scaleY = segmentHeight / 40;
			rightSidewalks[k].x = 1024 + swRoadWidth / 2 + 80 * swPerspective;
			rightSidewalks[k].scaleX = swPerspective * 2;
			rightSidewalks[k].scaleY = segmentHeight / 40;
		}
	}
	if (gameStarted) {
		var distance = Math.floor(roadOffset / 10);
		scoreTxt.setText('Distance: ' + distance + 'm');
		LK.setScore(distance);
	}
	healthTxt.setText('Power: ' + Math.round(motorcycle.power) + '%');
	if (gameStarted) {
		if (motorcycle.lastX === undefined) {
			motorcycle.lastX = motorcycle.x;
			motorcycle.isFlipping = false;
		}
		var screenCenter = 1024;
		var crossedToRight = motorcycle.lastX < screenCenter && motorcycle.x >= screenCenter;
		var crossedToLeft = motorcycle.lastX > screenCenter && motorcycle.x <= screenCenter;
		if ((crossedToRight || crossedToLeft) && !motorcycle.isFlipping) {
			motorcycle.isFlipping = true;
			tween(motorcycle, {
				scaleX: -motorcycle.scaleX
			}, {
				duration: 0,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					motorcycle.isFlipping = false;
				}
			});
		}
		motorcycle.lastX = motorcycle.x;
	}
	var powerPercentage = motorcycle.power / 100;
	powerBarFill.scaleY = powerPercentage;
	if (powerPercentage > 0.6) {
		powerBarFill.tint = 0x99ff99;
	} else if (powerPercentage > 0.3) {
		powerBarFill.tint = 0xffff99;
	} else {
		powerBarFill.tint = 0xff9999;
	}
	for (var i = projectiles.length - 1; i >= 0; i--) {
		var projectile = projectiles[i];
		if (projectile.x < -100 || projectile.x > 2148 || projectile.y > extendedRoadY + 100) {
			projectile.destroy();
			projectiles.splice(i, 1);
			continue;
		}
		if (gameStarted && projectile.intersects(motorcycle)) {
			var damageAmount = projectile.isHeavy ? 20 : 3;
			motorcycle.takeDamage(damageAmount);
			projectile.destroy();
			projectiles.splice(i, 1);
			continue;
		}
		if (projectile.y >= extendedRoadY - 20 && projectile.velocityY > 0) {
			projectile.destroy();
			projectiles.splice(i, 1);
		}
	}
	for (var i = powerItems.length - 1; i >= 0; i--) {
		var powerItem = powerItems[i];
		if (powerItem.x < -100 || powerItem.x > 2148 || powerItem.y > extendedRoadY + 100) {
			powerItem.destroy();
			powerItems.splice(i, 1);
			continue;
		}
		if (gameStarted && powerItem.intersects(motorcycle)) {
			motorcycle.restorePower(3);
			powerItem.destroy();
			powerItems.splice(i, 1);
			continue;
		}
		if (powerItem.y >= extendedRoadY - 20 && powerItem.velocityY > 0) {
			powerItem.destroy();
			powerItems.splice(i, 1);
		}
	}
	// Random phrase system - play one of six phrases every 10 seconds
	if (gameStarted) {
		phraseTimer++;
		if (phraseTimer >= phraseInterval) {
			var randomPhraseIndex = Math.floor(Math.random() * phraseAssets.length);
			var phraseSoundId = phraseAssets[randomPhraseIndex];
			LK.getSound(phraseSoundId).play();
			phraseTimer = 0; // Reset timer
		}
	}
	if (gameStarted && LK.ticks % 600 == 0) {
		for (var j = 0; j < roadsideObjects.length; j++) {
			if (roadsideObjects[j].objectType === 'person' || roadsideObjects[j].objectType === 'person2' || roadsideObjects[j].objectType === 'person3') {
				var dec = 5;
				if (roadsideObjects[j].objectType === 'person3') {
					dec = 8;
				}
				if (roadsideObjects[j].objectType === 'person2') {
					dec = 6;
				}
				roadsideObjects[j].throwDelay = Math.max(20, roadsideObjects[j].throwDelay - dec);
			}
		}
	}
};

===================================================================
--- original.js
+++ change.js
@@ -147,22 +147,22 @@
 			var perspBefore = Math.max(0.01, Math.min(1, 1 - distBefore / horizonDistance));
 			var speedFactor = 1 + 2.5 * perspBefore; // Slightly increased speed factor
 			self.y += motorcycle.speed * 3.2 * speedFactor; // Increased base movement speed
 			// Calculate perspective with extended range for smoother transitions
-			var currentDistance = Math.max(0, roadY - self.y);
+			var currentDistance = Math.max(0, extendedRoadY - self.y);
 			var perspective = 1 - currentDistance / horizonDistance;
 			// Allow objects to appear much earlier (when perspective is negative) and scale properly
-			if (perspective > -1.2) {
+			if (perspective > -2.0) {
 				// Extended range for earlier appearance
 				// Calculate road width with minimum constraint for stability
 				var roadWidth = 2048 * Math.max(0.005, perspective);
 				var sideOffset = self.sideOffsetBase * Math.max(0.005, perspective);
 				// Position objects with extended side margins
-				var extraMargin = 100000; // Additional margin for better visibility
+				// Additional margin for better visibility
 				if (self.isLeftSide) {
-					self.x = 1024 - roadWidth / 2 - sideOffset - extraMargin;
+					self.x = 1024 - roadWidth / 2 - sideOffset;
 				} else {
-					self.x = 1024 + roadWidth / 2 + sideOffset + extraMargin;
+					self.x = 1024 + roadWidth / 2 + sideOffset;
 				}
 				// Enhanced scaling that allows very small objects in distance
 				var finalScale = Math.max(0.0005, perspective); // Even smaller minimum scale
 				if (finalScale < 0.01) {
@@ -194,22 +194,21 @@
 					self.throwDelay = Math.random() * nRand2 + nMin2;
 				}
 			}
 			// Reset when completely off screen with much larger margin
-			if (self.y > roadY + 800 || perspective < -1.2) {
+			if (self.y > extendedRoadY + 1600 || perspective < -2.0) {
 				// Extended thresholds
 				self.y = self.originalY;
-				var resetDistance = roadY - self.originalY;
+				var resetDistance = extendedRoadY - self.originalY;
 				var resetPerspective = Math.max(0.005, Math.min(1, 1 - resetDistance / horizonDistance));
 				var resetRoadWidth = 2048 * resetPerspective;
 				var resetSideOffset = self.sideOffsetBase * resetPerspective;
-				var extraMargin = 100;
 				self.scaleX = (self.isLeftSide ? -1 : 1) * resetPerspective;
 				self.scaleY = resetPerspective;
 				if (self.isLeftSide) {
-					self.x = 1024 - resetRoadWidth / 2 - resetSideOffset - extraMargin;
+					self.x = 1024 - resetRoadWidth / 2 - resetSideOffset;
 				} else {
-					self.x = 1024 + resetRoadWidth / 2 + resetSideOffset + extraMargin;
+					self.x = 1024 + resetRoadWidth / 2 + resetSideOffset;
 				}
 				self.hasThrownThisCycle = false;
 			}
 		}
@@ -253,10 +252,10 @@
 	karinaSprite.visible = false;
 	self.speed = -6;
 	self.active = true;
 	self.dropTimer = 0;
-	self.dropDelay = 180;
-	self.targetY = horizonY + (roadY - horizonY) * 0.25;
+	self.dropDelay = 120;
+	self.targetY = horizonY + (extendedRoadY - horizonY) * 0.25;
 	self.baseXFactorFromCenter = 0.42;
 	self.oscAmp = 30;
 	self.oscSpeed = 0.02;
 	self.oscPhase = Math.random() * Math.PI * 2;
@@ -279,10 +278,10 @@
 			var centerX = 1024;
 			var targetBaseX = centerX + roadWidthAtY * self.baseXFactorFromCenter;
 			self.oscPhase += self.oscSpeed;
 			self.x = Math.min(roadRightEdge - 40 * perspective, targetBaseX + Math.sin(self.oscPhase) * self.oscAmp * perspective);
-			var distanceToHorizon = roadY - horizonY;
-			var currentDistance = roadY - self.y;
+			var distanceToHorizon = extendedRoadY - horizonY;
+			var currentDistance = extendedRoadY - self.y;
 			var perspective = Math.max(0, 1 - currentDistance / distanceToHorizon);
 			var centerX = 1024;
 			self.scaleX = perspective;
 			self.scaleY = perspective;
@@ -334,9 +333,9 @@
 		var roadLeft = 200;
 		var roadRight = 1848;
 		var margin = 60;
 		var targetX = roadLeft + margin + Math.random() * Math.max(0, roadRight - roadLeft - margin * 2);
-		var targetY = roadY;
+		var targetY = extendedRoadY;
 		// Calculate parabolic trajectory
 		var distanceX = targetX - powerItem.x;
 		var distanceY = targetY - powerItem.y;
 		var timeToTarget = 60; // frames to reach target
@@ -377,8 +376,11 @@
 var rightSidewalks = [];
 var totalSegments = 90;
 var horizonDistance = roadY - horizonY;
 var segmentSpacing = horizonDistance / totalSegments;
+// Agregar margen inferior para evitar que la ruta se corte
+var bottomMargin = 400;
+var extendedRoadY = roadY + bottomMargin;
 LK.playMusic('gritos');
 LK.playMusic('moto');
 game.addChild(LK.getAsset('cesped', {
 	anchorX: 0.5,
@@ -448,16 +450,15 @@
 for (var i = 0; i < 12; i++) {
 	var objectType = objectTypes[i % objectTypes.length];
 	var leftObject = game.addChild(new RoadsideObject(objectType));
 	// Start objects much earlier - extend beyond horizon for smoother appearance
-	var extendedDistance = horizonDistance * 1.5; // 50% beyond normal horizon
+	var extendedDistance = horizonDistance * 2.5; // Aumentado de 1.5 a 2.5 para mayor distancia
 	var distance = i / 12 * extendedDistance;
-	var yPos = roadY - distance;
+	var yPos = extendedRoadY - distance; // Usar extendedRoadY en lugar de roadY
 	var perspective = 1 - distance / extendedDistance;
 	var roadWidth = 2048 * Math.max(0.005, perspective);
-	var extraMargin = 100;
 	// Remove horizon restriction to allow objects to start from far distance
-	leftObject.x = 1024 - roadWidth / 2 - 120 * Math.max(0.005, perspective) - extraMargin;
+	leftObject.x = 1024 - roadWidth / 2 - 120 * Math.max(0.005, perspective);
 	leftObject.y = yPos;
 	leftObject.originalY = yPos;
 	leftObject.scaleX = -Math.max(0.01, perspective); // Ensure minimum visible scale
 	leftObject.scaleY = Math.max(0.01, perspective);
@@ -467,16 +468,15 @@
 for (var i = 0; i < 12; i++) {
 	var objectType = objectTypes[i % objectTypes.length];
 	var rightObject = game.addChild(new RoadsideObject(objectType));
 	// Start objects much earlier - extend beyond horizon for smoother appearance
-	var extendedDistance = horizonDistance * 1.5; // 50% beyond normal horizon
+	var extendedDistance = horizonDistance * 2.5; // Aumentado de 1.5 a 2.5 para mayor distancia
 	var distance = i / 12 * extendedDistance;
-	var yPos = roadY - distance;
+	var yPos = extendedRoadY - distance; // Usar extendedRoadY en lugar de roadY
 	var perspective = 1 - distance / extendedDistance;
 	var roadWidth = 2048 * Math.max(0.005, perspective);
-	var extraMargin = 100;
 	// Remove horizon restriction to allow objects to start from far distance
-	rightObject.x = 1024 + roadWidth / 2 + 120 * Math.max(0.005, perspective) + extraMargin;
+	rightObject.x = 1024 + roadWidth / 2 + 120 * Math.max(0.005, perspective);
 	rightObject.y = yPos;
 	rightObject.originalY = yPos;
 	rightObject.scaleX = Math.max(0.01, perspective); // Ensure minimum visible scale
 	rightObject.scaleY = Math.max(0.01, perspective);
@@ -546,9 +546,9 @@
 		var movementFactor = 3;
 		var offset = roadOffset * movementFactor % horizonDistance;
 		for (var i = 0; i < roadSegments.length; i++) {
 			var distanceAlong = (i * segmentSpacing + offset) % horizonDistance;
-			var yPosition = roadY - distanceAlong;
+			var yPosition = extendedRoadY - distanceAlong;
 			var perspective = Math.max(0.01, Math.min(1, 1 - distanceAlong / horizonDistance));
 			var roadWidth = 2048 * perspective;
 			roadSegments[i].y = yPosition;
 			roadSegments[i].scaleX = roadWidth / 100;
@@ -556,9 +556,9 @@
 		}
 		var lineSpacing = segmentSpacing * 4;
 		for (var j = 0; j < roadLines.length; j++) {
 			var lineDistance = (j * lineSpacing + offset) % horizonDistance;
-			var lineY = roadY - lineDistance;
+			var lineY = extendedRoadY - lineDistance;
 			var linePerspective = Math.max(0.01, Math.min(1, 1 - lineDistance / horizonDistance));
 			roadLines[j].y = lineY;
 			var lineCenterShift = typeof curveCenterShift !== 'undefined' ? curveCenterShift : 0;
 			roadLines[j].x = 1024 + lineCenterShift;
@@ -566,9 +566,9 @@
 			roadLines[j].scaleY = linePerspective * 4;
 		}
 		for (var k = 0; k < leftSidewalks.length; k++) {
 			var swDistance = (k * segmentSpacing + offset) % horizonDistance;
-			var swY = roadY - swDistance;
+			var swY = extendedRoadY - swDistance;
 			var swPerspective = Math.max(0.01, Math.min(1, 1 - swDistance / horizonDistance));
 			var swRoadWidth = 2048 * swPerspective;
 			var segmentHeight = horizonDistance / totalSegments * 1.2 * swPerspective;
 			leftSidewalks[k].y = swY;
@@ -619,9 +619,9 @@
 		powerBarFill.tint = 0xff9999;
 	}
 	for (var i = projectiles.length - 1; i >= 0; i--) {
 		var projectile = projectiles[i];
-		if (projectile.x < -100 || projectile.x > 2148 || projectile.y > 2732 + 100) {
+		if (projectile.x < -100 || projectile.x > 2148 || projectile.y > extendedRoadY + 100) {
 			projectile.destroy();
 			projectiles.splice(i, 1);
 			continue;
 		}
@@ -631,16 +631,16 @@
 			projectile.destroy();
 			projectiles.splice(i, 1);
 			continue;
 		}
-		if (projectile.y >= roadY - 20 && projectile.velocityY > 0) {
+		if (projectile.y >= extendedRoadY - 20 && projectile.velocityY > 0) {
 			projectile.destroy();
 			projectiles.splice(i, 1);
 		}
 	}
 	for (var i = powerItems.length - 1; i >= 0; i--) {
 		var powerItem = powerItems[i];
-		if (powerItem.x < -100 || powerItem.x > 2148 || powerItem.y > 2732 + 100) {
+		if (powerItem.x < -100 || powerItem.x > 2148 || powerItem.y > extendedRoadY + 100) {
 			powerItem.destroy();
 			powerItems.splice(i, 1);
 			continue;
 		}
@@ -649,9 +649,9 @@
 			powerItem.destroy();
 			powerItems.splice(i, 1);
 			continue;
 		}
-		if (powerItem.y >= roadY - 20 && powerItem.velocityY > 0) {
+		if (powerItem.y >= extendedRoadY - 20 && powerItem.velocityY > 0) {
 			powerItem.destroy();
 			powerItems.splice(i, 1);
 		}
 	}