/**** 
* Classes
****/ 
var BootText = Container.expand(function (text) {
	var self = Container.call(this);
	var bootText = self.addChild(new Text2(text, {
		size: 100,
		fill: "#FFFFFF",
		fontWeight: 'bolder',
		stroke: "#000000",
		// Black outline
		strokeThickness: 5 // Thickness of the outline
	}));
	bootText.anchor.set(0.5, 0);
	self.alpha = 0;
	self.fadeIn = function () {
		if (self.alpha < 1) {
			self.alpha += 0.05;
		}
	};
	self.fadeOut = function () {
		if (self.alpha > 0) {
			self.alpha -= 0.05;
		} else {
			self.destroy();
		}
	};
});
var Enemy = Container.expand(function () {
	var self = Container.call(this);
	var enemyGraphics = self.attachAsset('enemy', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = -3;
	self._move_migrated = function () {};
});
var Hero = Container.expand(function () {
	var self = Container.call(this);
	self.createDashTrail = function () {
		var trailCount = 10;
		var flashDuration = 50; // Duration for each flash
		for (var i = 0; i < trailCount; i++) {
			LK.setTimeout(function () {
				var trailParticle = new Particle();
				trailParticle.x = self.x;
				trailParticle.y = self.y;
				game.addChild(trailParticle);
				var neonColors = [0x39ff14, 0xff073a, 0x00ffff, 0xffff00, 0xff00ff];
				var randomColor = neonColors[Math.floor(Math.random() * neonColors.length)];
				LK.effects.flashObject(trailParticle, randomColor, flashDuration);
			}, i * 50);
		}
	};
	var heroGraphics = self.attachAsset('hero', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 30;
	// Initialize jetfuel in the center of hero
	var jetfuel = self.attachAsset('jetfuel', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	jetfuel.x = -50;
	jetfuel.y = 50;
	self.addChildAt(jetfuel, 0);
	// Set interval to flip jetfuel's visual on the x alignment every 0.5 seconds
	self.jetfuelInterval = LK.setInterval(function () {
		jetfuel.scale.x *= -1;
	}, 250);
	self.on('destroy', function () {
		LK.clearInterval(self.jetfuelInterval);
	});
	self.dashSpeed = game.width / 2 / 30; // 1/2 of the screen over 0.5 seconds at 60FPS
	self.dashBackSpeed = self.dashSpeed / 2; // Accelerated return at half of the dash speed
	self.dashStartTime = 0; // Time when the dash started
	self.gravity = 1;
	self.isDashing = false;
	self.initialX = 200;
	self.animateToPosition = function () {
		var targetY = Math.max(2732 / 2, 300);
		var targetX = self.initialX;
		var animationSpeed = 10;
		if (!self.animationStarted) {
			self.animationDelay = LK.setTimeout(function () {
				self.animationStarted = true;
			}, 3000);
			self.animationStarted = false;
		}
		if (self.animationStarted) {
			if (self.y < targetY) {
				self.y += animationSpeed;
			}
			if (self.x < targetX) {
				self.x += animationSpeed;
			}
			if (self.y >= targetY && self.x >= targetX) {
				gameStarted = true; // Start the game once the hero reaches the initial position
				initializeScoreDisplay();
				startObstacleGeneration();
			}
		}
	};
	self.dash = function () {
		if (!self.isDashing && LK.ticks - self.holdStartTime >= 60 && self.x === self.initialX) {
			self.isDashing = true;
			self.dashStartTime = LK.ticks; // Save the start time of the dash
			self.savedX = self.x; // Save the current x position
			self.dashTargetX = self.x + game.width / 3 * 2; // Set the target X position for the dash, now twice as long
			// Apply dash effect
			self.createDashTrail();
			self.stopFlashing();
		}
	};
	self.isGravityFlipped = false;
	self.flipGravity = function () {
		if (!self.isDashing) {
			self.isGravityFlipped = !self.isGravityFlipped;
			self.gravity *= -1;
		}
	};
	self._move_migrated = function () {
		if (self.isHolding && LK.ticks - self.holdStartTime >= 60 && LK.ticks - self.dashStartTime > 6) {
			self.dash();
		}
		if (self.isDashing) {
			if (self.x < self.dashTargetX) {
				self.x += self.dashSpeed;
				// Check for collision with obstacles
				for (var i = obstacles.length - 1; i >= 0; i--) {
					if (self.intersects(obstacles[i])) {
						var explosion = new ParticleExplosion(obstacles[i].x, obstacles[i].y);
						game.addChild(explosion);
						if (obstacles[i] instanceof ObjGO) {
							heroGround.moveToCenterX();
							var explosion = new ParticleExplosion(obstacles[i].x, obstacles[i].y);
							game.addChild(explosion);
							var explosion = new ParticleExplosion(obstacles[i].x, obstacles[i].y);
							game.addChild(explosion);
						} else if (obstacles[i] instanceof ObjRALLY) {
							heroGround.moveToInitialPosition();
						}
						obstacles[i].destroy();
						obstacles.splice(i, 1);
					}
				}
			} else {
				self.isDashing = false;
				self.dashTargetX = null; // Clear the dash target position
				// Remove dash effect
				self.tint = 0xffffff;
			}
		}
		// Gradually move back to the initial position after dashing
		// Resume normal movement after reaching saved x position
		if (!self.isDashing && self.dashTargetX === null && self.x !== self.savedX) {
			var moveBack = self.savedX < self.x ? -self.dashBackSpeed : self.dashBackSpeed;
			self.x += moveBack;
			// Clamp the hero's x position to the savedX to prevent overshooting
			if (Math.abs(self.x - self.savedX) < Math.abs(moveBack)) {
				self.x = self.savedX;
			}
		}
		// Stop vertical movement while holding down
		if (!self.isHolding && !self.isDashing) {
			self.y += self.speed * self.gravity;
			var boundaryPadding = 300; // Adjust this value to set the top boundary padding
			if (self.y < boundaryPadding) {
				self.y = boundaryPadding;
			}
			if (self.y > game.height / 2 + 400) {
				self.y = game.height / 2 + 400;
			}
		}
		// Removed game over condition when hero leaves the screen horizontally
		// Generate particle trail
		if (LK.ticks % 5 == 0 && !self.isHolding) {
			var particle = new Particle();
			particle.x = self.x;
			particle.y = self.y;
			game.addChildAt(particle, 0);
		}
	};
	self.isHolding = false;
	self.holdStartTime = 0;
	self.startFlashing = function () {
		if (!self.flashInterval && !self.isDashing) {
			self.flashInterval = LK.setInterval(function () {
				self.scale.set(self.scale.x === 1 ? 1.5 : 1);
				self.tint = self.tint === 0x0000ff ? 0x00ffff : 0x0000ff; // Transition between blue and cyan
			}, 100); // Pulse every 100ms
		}
	};
	self.stopFlashing = function () {
		if (self.flashInterval) {
			LK.clearInterval(self.flashInterval);
			self.flashInterval = null;
			self.visible = true; // Ensure hero is visible after stopping flash
			self.tint = 0x9a3986; // Reset color to default
			self.scale.set(1); // Reset scale to default
		}
	};
	self.onHold = function () {
		if (!self.isHolding && !self.isDashing && !self.isDashing) {
			self.isHolding = true;
			self.holdStartTime = LK.ticks;
			self.startFlashing();
		}
	};
	self.onRelease = function () {
		if (self.isHolding && !self.isDashing) {
			self.dash();
		}
		self.isHolding = false;
		self.holdStartTime = 0;
		self.stopFlashing();
	};
});
var Hero_Ground = Container.expand(function () {
	var self = Container.call(this);
	var heroGroundGraphics = self.attachAsset('heroGround', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var heroGroundGraphicsB = self.attachAsset('heroGroundB', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	heroGroundGraphicsB.visible = false;
	self.addChild(heroGroundGraphicsB);
	// Set interval to switch between heroGround and heroGroundB every 0.5 seconds
	self.heroGroundInterval = LK.setInterval(function () {
		heroGroundGraphics.visible = !heroGroundGraphics.visible;
		heroGroundGraphicsB.visible = !heroGroundGraphicsB.visible;
	}, 250);
	self.on('destroy', function () {
		LK.clearInterval(self.heroGroundInterval);
		if (self.interpolationInterval) {
			LK.clearInterval(self.interpolationInterval);
		}
	});
	self.speed = 20;
	self.gravity = 1;
	self.isJumping = false;
	self.jumpSpeed = -20;
	self.jumpVelocity = 0;
	self.initialY = 200;
	self.jump = function () {
		if (!self.isJumping && self.y >= game.floorLevel) {
			self.isJumping = true;
			self.jumpSpeed = -30;
		}
	};
	self._update_migrated = function () {
		if (self.isJumping) {
			self.y += self.jumpSpeed;
			self.jumpSpeed += self.gravity;
		}
		if (self.y > game.floorLevel) {
			self.y = game.floorLevel;
			self.isJumping = false;
		}
	};
	self.moveToCenterX = function () {
		if (self.isMovingToCenter || self.isMovingToInitial) {
			return;
		} // Prevent multiple calls
		self.isMovingToCenter = true; // Set flag to indicate movement in progress
		var targetX = game.width / 2;
		var interpolationSpeed = 10; // Adjust this value to control the speed of interpolation
		self.interpolationInterval = LK.setInterval(function () {
			if (Math.abs(self.x - targetX) < interpolationSpeed) {
				self.x = targetX;
				LK.clearInterval(self.interpolationInterval);
				self.isMovingToCenter = false; // Reset flag when movement is complete
				// Replace movingSpeechBubble with idleSpeechBubble
				if (self.movingSpeechBubble) {
					self.movingSpeechBubble.destroy();
					self.movingSpeechBubble = null;
				}
				self.idleSpeechBubble = LK.getAsset('idleSpeechBubble', {
					anchorX: 0.5,
					anchorY: 0.5
				});
				self.addChild(self.idleSpeechBubble);
				self.idleSpeechBubble.x = self.width / 2 + 20;
				self.idleSpeechBubble.y = -self.idleSpeechBubble.height / 2 - 125;
			} else {
				self.x += self.x < targetX ? interpolationSpeed : -interpolationSpeed;
			}
		}, 16); // Approximately 60 FPS
		// Replace idleSpeechBubble with movingSpeechBubble
		if (self.idleSpeechBubble) {
			self.idleSpeechBubble.destroy();
			self.idleSpeechBubble = null;
		}
		// Ensure only one moving speech bubble is active at a time
		if (game.activeMovingSpeechBubble) {
			game.activeMovingSpeechBubble.destroy();
		}
		self.movingSpeechBubble = LK.getAsset('movingSpeechBubble', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		self.addChild(self.movingSpeechBubble);
		self.movingSpeechBubble.x = self.width / 2 + 20;
		self.movingSpeechBubble.y = -self.movingSpeechBubble.height / 2 - 125;
		game.activeMovingSpeechBubble = self.movingSpeechBubble;
	};
	self._move_migrated = function () {
		if (self.isJumping) {
			self.y += self.jumpVelocity;
			self.jumpVelocity += self.gravity;
			if (self.y >= self.initialY) {
				self.y = self.initialY;
				self.isJumping = false;
			}
		} else {
			self.y += self.gravity;
			if (self.y > game.height - self.height / 2) {
				self.y = game.height - self.height / 2;
			}
		}
	};
	self.moveToInitialPosition = function () {
		if (self.isMovingToInitial || self.isMovingToCenter) {
			return;
		} // Prevent multiple calls
		var targetX = heroGround.initialX;
		if (Math.abs(self.x - targetX) < interpolationSpeed) {
			return; // Already at the initial position, do nothing
		}
		self.isMovingToInitial = true; // Set flag to indicate movement in progress
		var interpolationSpeed = 10; // Adjust this value to control the speed of interpolation
		self.interpolationInterval = LK.setInterval(function () {
			if (Math.abs(self.x - targetX) < interpolationSpeed) {
				self.x = targetX;
				LK.clearInterval(self.interpolationInterval);
				self.isMovingToInitial = false; // Reset flag when movement is complete
				// Replace movingSpeechBubble with idleSpeechBubble
				if (self.movingSpeechBubble) {
					self.movingSpeechBubble.destroy();
					self.movingSpeechBubble = null;
				}
				self.idleSpeechBubble = LK.getAsset('idleSpeechBubble', {
					anchorX: 0.5,
					anchorY: 0.5
				});
				self.addChild(self.idleSpeechBubble);
				self.idleSpeechBubble.x = self.width / 2 + 20;
				self.idleSpeechBubble.y = -self.idleSpeechBubble.height / 2 - 125;
			} else {
				self.x += self.x < targetX ? interpolationSpeed : -interpolationSpeed;
			}
		}, 16); // Approximately 60 FPS
		// Replace idleSpeechBubble with movingSpeechBubble
		if (self.idleSpeechBubble) {
			self.idleSpeechBubble.destroy();
			self.idleSpeechBubble = null;
		}
		// Ensure only one moving speech bubble is active at a time
		if (game.activeMovingSpeechBubble) {
			game.activeMovingSpeechBubble.destroy();
		}
		self.movingSpeechBubble = LK.getAsset('movingSpeechBubble', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		self.addChild(self.movingSpeechBubble);
		self.movingSpeechBubble.x = self.width / 2 + 20;
		self.movingSpeechBubble.y = -self.movingSpeechBubble.height / 2 - 125;
		game.activeMovingSpeechBubble = self.movingSpeechBubble;
	};
});
var ObjGO = Container.expand(function () {
	var self = Container.call(this);
	var objGOGraphics = self.attachAsset('objGO', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = -5;
	self.spawnTime = LK.ticks;
	self.spawnTime = LK.ticks;
	self.spawnTime = LK.ticks;
	self.spawnTime = LK.ticks;
	self._move_migrated = function () {
		self.x += self.speed;
		if (self.x < -self.width) {
			self.x = game.width;
			var heroYMin = Math.max(hero.y - hero.height / 2, 0);
			var heroYMax = Math.min(hero.y + hero.height / 2, game.height);
			self.y = heroYMin + Math.random() * (heroYMax - heroYMin);
			return;
			return;
			return;
		}
	};
});
var ObjJUMP = Container.expand(function () {
	var self = Container.call(this);
	var objJUMPGraphics = self.attachAsset('objJUMP', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = -5;
	self._move_migrated = function () {
		self.x += self.speed;
		if (self.x < -self.width) {
			self.x = game.width;
			var heroYMin = Math.max(hero.y - hero.height / 2, 0);
			var heroYMax = Math.min(hero.y + hero.height / 2, game.height);
			self.y = heroYMin + Math.random() * (heroYMax - heroYMin);
		}
	};
});
var ObjRALLY = Container.expand(function () {
	var self = Container.call(this);
	var objRALLYGraphics = self.attachAsset('objRALLY', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = -5;
	self._move_migrated = function () {
		self.x += self.speed;
		if (self.x < -self.width) {
			self.x = game.width;
			var heroYMin = Math.max(hero.y - hero.height / 2, 0);
			var heroYMax = Math.min(hero.y + hero.height / 2, game.height);
			self.y = heroYMin + Math.random() * (heroYMax - heroYMin);
		}
	};
});
var Obstacle = Container.expand(function () {
	var self = Container.call(this);
	var obstacleGraphics = self.attachAsset('obstacle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = -5;
	self._move_migrated = function () {
		self.x += self.speed;
		if (self.x < -self.width) {
			self.x = game.width;
			var heroYMin = Math.max(hero.y - hero.height / 2, 0);
			var heroYMax = Math.min(hero.y + hero.height / 2, game.height);
			self.y = heroYMin + Math.random() * (heroYMax - heroYMin);
		}
	};
});
var Parallax = Container.expand(function () {
	var self = Container.call(this);
	var bgGraphics = self.attachAsset('background', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	bgGraphics.x = game.width / 2;
	bgGraphics.y = game.height - bgGraphics.height / 2;
	self.speed = -3;
	self._move_migrated = function () {
		bgGraphics.x += self.speed;
		if (!self.bgGraphics2) {
			self.bgGraphics2 = self.attachAsset('background', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			self.bgGraphics2.x = bgGraphics.x + bgGraphics.width;
			self.bgGraphics2.y = game.height - self.bgGraphics2.height / 2;
			self.addChildAt(self.bgGraphics2, 1); // Ensure bgGraphics2 is behind bgGraphics
		}
		self.bgGraphics2.x += self.speed;
		if (bgGraphics.x <= -bgGraphics.width / 2) {
			bgGraphics.x = self.bgGraphics2.x + bgGraphics.width;
		}
		if (self.bgGraphics2.x <= -self.bgGraphics2.width / 2) {
			self.bgGraphics2.x = bgGraphics.x + bgGraphics.width;
		}
	};
});
var Particle = Container.expand(function () {
	var self = Container.call(this);
	var particleGraphics = self.attachAsset('particle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var neonColors = [0x39ff14, 0xff073a, 0x00ffff, 0xffff00, 0xff00ff];
	particleGraphics.tint = neonColors[Math.floor(Math.random() * neonColors.length)];
	self.alpha = 1.0;
	self.fadeOut = function () {
		self.alpha -= 0.05;
		if (self.alpha <= 0) {
			self.destroy();
		}
	};
});
var Particle2 = Container.expand(function () {
	var self = Container.call(this);
	var particleGraphics = self.attachAsset('particle2', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var neonColors = [0x39ff14, 0xff073a, 0x00ffff, 0xffff00, 0xff00ff];
	particleGraphics.tint = neonColors[Math.floor(Math.random() * neonColors.length)];
	self.alpha = 1.0;
	self.fadeOut = function () {
		self.alpha -= 0.05;
		if (self.alpha <= 0) {
			self.destroy();
		}
	};
});
var ParticleExplosion = Container.expand(function (x, y) {
	var self = Container.call(this);
	var particles = [];
	var particleCount = 20;
	var speedRange = 20; // Further increased speed range for more exaggerated movement
	var neonColors = [0x39ff14, 0xff073a, 0x00ffff, 0xffff00, 0xff00ff];
	for (var i = 0; i < particleCount; i++) {
		var particle = new Particle2();
		particle.x = x;
		particle.y = y;
		particle.vx = (Math.random() - 0.5) * speedRange;
		particle.vy = (Math.random() - 0.5) * speedRange;
		particle.rotationSpeed = (Math.random() - 0.5) * 0.2; // Further increased rotation speed for more exaggerated movement
		particle.tint = neonColors[Math.floor(Math.random() * neonColors.length)];
		particles.push(particle);
		self.addChild(particle);
	}
	self.update = function () {
		for (var i = particles.length - 1; i >= 0; i--) {
			particles[i].x += particles[i].vx;
			particles[i].y += particles[i].vy;
			particles[i].rotation += particles[i].rotationSpeed; // Apply rotation
			particles[i].alpha -= 0.02;
			if (particles[i].alpha <= 0) {
				particles[i].destroy();
				particles.splice(i, 1);
			}
		}
		if (particles.length === 0) {
			self.destroy();
		}
	};
});

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

/**** 
* Game Code
****/ 
var generateObjJUMP = function generateObjJUMP() {
	if (obstacles.filter(function (obstacle) {
		return obstacle instanceof ObjJUMP;
	}).length >= 1) {
		return;
	}
	// Add delay to avoid two ObjJUMP spawning on top of each other
	if (obstacles.length > 0) {
		var lastObstacle = obstacles[obstacles.length - 1];
		if (LK.ticks - lastObstacle.spawnTime < 60) {
			return;
		}
	}
	var objJUMP = new ObjJUMP();
	objJUMP.x = game.width;
	objJUMP.y = Math.random() * game.height;
	obstacles.push(objJUMP);
	game.addChild(objJUMP);
};
function startBootSequence() {
	var bootTexts = ['Booting Core Systems...', 'Calibrating Enhancements...', 'All systems ready...'];
	var currentBootTextIndex = 0;
	var bootTextY = game.height / 2 - 100;
	var displayBootText = function displayBootText() {
		var bootText = new BootText(bootTexts[currentBootTextIndex]);
		bootText.x = game.width / 2 + 50;
		bootText.y = bootTextY + currentBootTextIndex * 120;
		game.addChild(bootText);
		var fadeInInterval = LK.setInterval(function () {
			bootText.fadeIn();
			if (bootText.alpha === 1) {
				LK.setTimeout(function () {
					bootText.fadeOut();
				}, 300);
			}
		}, 60);
		bootText.on('destroy', function () {
			LK.clearInterval(fadeInInterval);
		});
		currentBootTextIndex++;
		if (currentBootTextIndex < bootTexts.length) {
			LK.setTimeout(displayBootText, 1000);
		}
	};
	displayBootText();
}
var activeMovingSpeechBubble = null,
	enemies = [],
	obstacles = [],
	parallax,
	score = 0,
	distanceTraveled = 0,
	isGameOver = false,
	gameStarted = false;
var generateObstacle = function generateObstacle() {
	if (obstacles.filter(function (obstacle) {
		return obstacle instanceof Obstacle;
	}).length >= 1) {
		return;
	}
	// Add delay to avoid two Obstacle spawning on top of each other
	if (obstacles.length > 0) {
		var lastObstacle = obstacles[obstacles.length - 1];
		if (LK.ticks - lastObstacle.spawnTime < 60) {
			return;
		}
	}
	var obstacle = new Obstacle();
	obstacle.x = game.width;
	if (hero.x >= 0 && hero.x <= game.width) {
		var heroYMin = Math.max(hero.y - hero.height / 2, 0); // Ensure obstacle spawns within the top boundary of the hero
		var heroYMax = Math.min(hero.y + hero.height / 2, game.height); // Ensure obstacle spawns within the bottom boundary of the hero
		var randomOffset = (Math.random() - 0.5) * hero.height * 2; // Augmented random offset within 2 times the hero's height
		obstacle.y = hero.y + randomOffset;
		// Ensure obstacle stays within the game boundaries
		var obstacleHalfHeight = obstacle.height / 2;
		obstacle.y = Math.max(obstacleHalfHeight, Math.min(game.height - obstacleHalfHeight, obstacle.y));
	} else {
		obstacle.y = Math.random() * game.height; // Spawn obstacle anywhere if hero is off screen
	}
	obstacles.push(obstacle);
	game.addChild(obstacle);
};
var generateObjGO = function generateObjGO() {
	if (obstacles.filter(function (obstacle) {
		return obstacle instanceof ObjGO;
	}).length >= 2) {
		return;
	}
	// Add delay to avoid two ObjGO spawning on top of each other
	if (obstacles.length > 0) {
		var lastObstacle = obstacles[obstacles.length - 1];
		if (LK.ticks - lastObstacle.spawnTime < 60) {
			return;
		}
	}
	var objGO = new ObjGO();
	objGO.x = game.width;
	if (hero.x >= 0 && hero.x <= game.width) {
		var heroYMin = Math.max(hero.y - hero.height / 2, 0); // Ensure objGO spawns within the top boundary of the hero
		var heroYMax = Math.min(hero.y + hero.height / 2, game.height); // Ensure objGO spawns within the bottom boundary of the hero
		var randomOffset = (Math.random() - 0.5) * hero.height * 2; // Augmented random offset within 2 times the hero's height
		objGO.y = hero.y + randomOffset;
		// Ensure objGO stays within the game boundaries
		var objGOHalfHeight = objGO.height / 2;
		objGO.y = Math.max(objGOHalfHeight, Math.min(game.height - objGOHalfHeight, objGO.y));
	} else {
		objGO.y = Math.random() * game.height; // Spawn objGO anywhere if hero is off screen
	}
	// Ensure objGO does not spawn too close to objRALLY
	if (obstacles.length > 0) {
		var lastObstacle = obstacles[obstacles.length - 1];
		if (lastObstacle instanceof ObjRALLY && Math.abs(lastObstacle.x - objGO.x) < 600) {
			objGO.x = lastObstacle.x + 600;
		}
	}
	obstacles.push(objGO);
	game.addChild(objGO);
};
var generateObjJUMP = function generateObjJUMP() {
	if (obstacles.filter(function (obstacle) {
		return obstacle instanceof ObjJUMP;
	}).length >= 1) {
		return;
	}
	var objJUMP = new ObjJUMP();
	objJUMP.x = game.width;
	objJUMP.y = Math.random() * game.height;
	obstacles.push(objJUMP);
	game.addChild(objJUMP);
};
var generateObjRALLY = function generateObjRALLY() {
	if (obstacles.filter(function (obstacle) {
		return obstacle instanceof ObjRALLY;
	}).length >= 2) {
		return;
	}
	// Add delay to avoid two ObjRALLY spawning on top of each other
	if (obstacles.length > 0) {
		var lastObstacle = obstacles[obstacles.length - 1];
		if (LK.ticks - lastObstacle.spawnTime < 60) {
			return;
		}
	}
	var objRALLY = new ObjRALLY();
	objRALLY.x = game.width;
	if (hero.x >= 0 && hero.x <= game.width) {
		var heroYMin = Math.max(hero.y - hero.height / 2, 0); // Ensure objRALLY spawns within the top boundary of the hero
		var heroYMax = Math.min(hero.y + hero.height / 2, game.height); // Ensure objRALLY spawns within the bottom boundary of the hero
		var randomOffset = (Math.random() - 0.5) * hero.height * 2; // Augmented random offset within 2 times the hero's height
		objRALLY.y = hero.y + randomOffset;
		// Ensure objRALLY stays within the game boundaries
		var objRALLYHalfHeight = objRALLY.height / 2;
		objRALLY.y = Math.max(objRALLYHalfHeight, Math.min(game.height - objRALLYHalfHeight, objRALLY.y));
	} else {
		objRALLY.y = Math.random() * game.height; // Spawn objRALLY anywhere if hero is off screen
	}
	// Ensure objRALLY does not spawn too close to objGO
	if (obstacles.length > 0) {
		var lastObstacle = obstacles[obstacles.length - 1];
		if (lastObstacle instanceof ObjGO && Math.abs(lastObstacle.x - objRALLY.x) < 600) {
			objRALLY.x = lastObstacle.x + 600;
		}
	}
	obstacles.push(objRALLY);
	game.addChild(objRALLY);
};
var obstacleGenerationInterval;
function startObstacleGeneration() {
	obstacleGenerationInterval = LK.setInterval(generateObstacle, 2000);
	var objGOGenerationInterval = LK.setInterval(generateObjGO, 2000);
	var objRALLYGenerationInterval = LK.setInterval(generateObjRALLY, 2000);
	var objJUMPGenerationInterval = LK.setInterval(generateObjJUMP, 2000);
	var objJUMPGenerationInterval = LK.setInterval(generateObjJUMP, 2000);
	LK.on('gameOver', function () {
		LK.clearInterval(objJUMPGenerationInterval);
		LK.clearInterval(obstacleGenerationInterval);
		LK.clearInterval(objGOGenerationInterval);
		LK.clearInterval(objRALLYGenerationInterval);
		LK.clearInterval(objJUMPGenerationInterval);
	});
}
parallax = game.addChild(new Parallax());
var distanceTxt;
function initializeScoreDisplay() {
	// Remove BootText from the screen
	var bootTexts = game.children.filter(function (child) {
		return child instanceof BootText;
	});
	for (var i = 0; i < bootTexts.length; i++) {
		bootTexts[i].destroy();
	}
	// Initialize score display
	distanceTxt = new Text2('Distance: 0', {
		size: 75,
		// Reduced size
		fill: "#ffffff",
		stroke: "#000000",
		// Black outline
		strokeThickness: 5 // Thickness of the outline
	});
	distanceTxt.anchor.set(.5, 0);
	LK.gui.top.addChild(distanceTxt);
}
hero = game.addChild(new Hero());
var heroGround = game.addChild(new Hero_Ground());
heroGround.idleSpeechBubble = LK.getAsset('idleSpeechBubble', {
	anchorX: 0.5,
	anchorY: 0.5
});
heroGround.addChild(heroGround.idleSpeechBubble);
heroGround.idleSpeechBubble.x = heroGround.width / 2 + 20;
heroGround.idleSpeechBubble.y = -heroGround.idleSpeechBubble.height / 2 - 125;
heroGround.initialX = hero.x + 175;
heroGround.x = heroGround.initialX;
heroGround.y = game.height - heroGround.height / 2 - 100;
hero.x = -100;
hero.y = -100;
startBootSequence();
heroGround.moveToInitialPosition();
LK.on('tick', function () {
	if (!gameStarted) {
		hero.animateToPosition();
		return; // Skip the rest of the game logic until the animation is complete
	}
	parallax._move_migrated();
	if (hero.visible) {
		hero._move_migrated();
	} else if (heroGround.visible) {
		heroGround._move_migrated();
	}
	for (var i = 0; i < enemies.length; i++) {
		enemies[i]._move_migrated();
	}
	for (var i = obstacles.length - 1; i >= 0; i--) {
		obstacles[i]._move_migrated();
		if (obstacles[i].intersects(heroGround)) {
			if (obstacles[i] instanceof ObjJUMP) {
				console.log("ObjJUMP destroyed by hero, calling heroGround.jump()");
				heroGround.jump();
				// Replace ObjJUMP with okSpeechBubble
				var okSpeechBubble = LK.getAsset('okSpeechBubble', {
					anchorX: 0.5,
					anchorY: 0.5
				});
				okSpeechBubble.x = obstacles[i].x;
				okSpeechBubble.y = obstacles[i].y;
				game.addChild(okSpeechBubble);
			}
			obstacles[i].destroy();
			obstacles.splice(i, 1);
		}
	}
	var particles = game.children.filter(function (child) {
		return child instanceof Particle;
	});
	for (var i = 0; i < particles.length; i++) {
		if (particles[i] instanceof ParticleExplosion) {
			particles[i].update();
		} else {
			particles[i].fadeOut();
		}
	}
	if (!isGameOver) {
		distanceTraveled += 1 / 60;
		distanceTxt.setText('Distance: ' + Math.floor(distanceTraveled).toString());
	}
	if (isGameOver) {
		LK.effects.flashScreen(0xff0000, 1000);
		LK.showGameOver();
	}
});
game.on('down', function (x, y, obj) {
	if (hero.visible) {
		hero.flipGravity();
		hero.onHold();
	} else if (heroGround.visible) {
		// Removed redundant jump call in game down event
	}
});
game.on('up', function (x, y, obj) {
	hero.onRelease();
});
Hero_Ground.prototype.moveToInitialPosition = function () {
	if (this.isMovingToInitial) {
		return;
	} // Prevent multiple calls
	this.isMovingToInitial = true; // Set flag to indicate movement in progress
	var targetX = hero.x + 175;
	var interpolationSpeed = 10; // Adjust this value to control the speed of interpolation
	this.interpolationInterval = LK.setInterval(function () {
		if (Math.abs(this.x - targetX) < interpolationSpeed) {
			this.x = targetX;
			LK.clearInterval(this.interpolationInterval);
			this.isMovingToInitial = false; // Reset flag when movement is complete
			// Replace movingSpeechBubble with idleSpeechBubble
			if (this.movingSpeechBubble) {
				this.movingSpeechBubble.destroy();
				this.movingSpeechBubble = null;
			}
			this.idleSpeechBubble = LK.getAsset('idleSpeechBubble', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			this.addChild(this.idleSpeechBubble);
			this.idleSpeechBubble.x = this.width / 2 + 20;
			this.idleSpeechBubble.y = -this.idleSpeechBubble.height / 2 - 125;
		} else {
			this.x += this.x < targetX ? interpolationSpeed : -interpolationSpeed;
		}
	}.bind(this), 16); // Approximately 60 FPS
	// Replace idleSpeechBubble with movingSpeechBubble
	if (this.idleSpeechBubble) {
		this.idleSpeechBubble.destroy();
		this.idleSpeechBubble = null;
	}
	// Ensure only one moving speech bubble is active at a time
	if (game.activeMovingSpeechBubble) {
		game.activeMovingSpeechBubble.destroy();
	}
	this.movingSpeechBubble = LK.getAsset('movingSpeechBubble', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	this.addChild(this.movingSpeechBubble);
	this.movingSpeechBubble.x = this.width / 2 + 20;
	this.movingSpeechBubble.y = -this.movingSpeechBubble.height / 2 - 125;
	game.activeMovingSpeechBubble = this.movingSpeechBubble;
};

===================================================================
--- original.js
+++ change.js
@@ -246,26 +246,23 @@
 	self.jumpSpeed = -20;
 	self.jumpVelocity = 0;
 	self.initialY = 200;
 	self.jump = function () {
-		if (!self.isJumping) {
-			console.log("heroGround.jump() method called");
+		if (!self.isJumping && self.y >= game.floorLevel) {
 			self.isJumping = true;
-			self.jumpVelocity = self.jumpSpeed;
-			// Interpolation logic
-			var targetY = self.y + self.jumpSpeed * 10; // Adjust the multiplier for desired jump height
-			var interpolationSpeed = 5; // Adjust this value to control the speed of interpolation
-			self.interpolationInterval = LK.setInterval(function () {
-				if (Math.abs(self.y - targetY) < Math.abs(self.jumpSpeed)) {
-					self.y = targetY;
-					LK.clearInterval(self.interpolationInterval);
-					self.isJumping = false;
-				} else {
-					self.y += self.jumpSpeed;
-				}
-			}, 16); // Approximately 60 FPS
+			self.jumpSpeed = -30;
 		}
 	};
+	self._update_migrated = function () {
+		if (self.isJumping) {
+			self.y += self.jumpSpeed;
+			self.jumpSpeed += self.gravity;
+		}
+		if (self.y > game.floorLevel) {
+			self.y = game.floorLevel;
+			self.isJumping = false;
+		}
+	};
 	self.moveToCenterX = function () {
 		if (self.isMovingToCenter || self.isMovingToInitial) {
 			return;
 		} // Prevent multiple calls