/**** 
* Classes
****/ 
/****************************************************************************************** */ 
/**************************************** CLASSES ***************************************** */
/****************************************************************************************** */ 
/****************************************************************************************** */ 
/************************************* ATHLETE CLASS ************************************** */
/****************************************************************************************** */ 
var Athlete = Container.expand(function () {
	var self = Container.call(this);
	self.speedX = 5;
	self.jumpSpeed = -17;
	self.gravity = 0.5;
	self.isOnGround = true;
	self.isFalling = false; // Indicates if the athlete is currently falling
	self.currentPosture = ""; // Store the name of the current posture
	self.isChangingPosture = false; // 0 when idle or moving down, 1 when moving up
	self.nextPosture = null;
	self.tint = 0xc0d4FF;
	// BODY PARTS
	self.trunk = self.attachAsset('bodyPart', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 1,
		scaleY: 1,
		rotation: 0.125,
		tint: 0x000000 //self.tint // TEMP DEBUG
	});
	self.head = self.trunk.attachAsset('head', {
		anchorX: 0.5,
		anchorY: 2,
		scaleX: 1,
		scaleY: 1,
		tint: 0x000000 // self.tint
	});
	self.rightArm = self.trunk.attachAsset('bodyPart', {
		anchorX: 0.5,
		anchorY: 0,
		scaleX: 1,
		scaleY: 1,
		tint: self.tint
	});
	// Right hand asset attachment removed
	self.leftArm = self.trunk.attachAsset('bodyPart', {
		anchorX: 0.5,
		anchorY: 0,
		scaleX: 1,
		scaleY: 1,
		tint: self.tint
	});
	// Left hand asset attachment removed
	self.rightLeg = self.trunk.attachAsset('bodyPart', {
		anchorX: 0.5,
		anchorY: 0,
		scaleX: 1,
		scaleY: 1.0,
		tint: self.tint
	});
	// Right foot asset attachment removed
	self.leftLeg = self.trunk.attachAsset('bodyPart', {
		anchorX: 0.5,
		anchorY: 0,
		scaleX: 1,
		scaleY: 1.0,
		tint: self.tint
	});
	// Left foot asset attachment removed
	// FUNCTIONS
	self.updatePosture = function () {
		var speed = 0.2; //0.1; // Speed of transition
		if (!self.targetPosture) {
			return;
		}
		// Check if the target posture for hands and legs is reached
		//log("self.targetPosture: " + self.targetPosture.name + " :  self.rightHand.x: " + self.rightHand.x, " self.targetPosture.rightHand.x: " + self.targetPosture.rightHand.x);
		var handsAndLegsReached = Math.abs(self.rightLeg.x - self.targetPosture.rightLeg.x) < 1 && Math.abs(self.rightLeg.y - self.targetPosture.rightLeg.y) < 1 && Math.abs(self.leftLeg.x - self.targetPosture.leftLeg.x) < 1 && Math.abs(self.leftLeg.y - self.targetPosture.leftLeg.y) < 1 && Math.abs(self.head.x - self.targetPosture.head.x) < 1 && Math.abs(self.head.y - self.targetPosture.head.y) < 1;
		if (handsAndLegsReached) {
			//log("handsAndLegsReached !");
			// Update currentPosture to the name of the targetPosture when hands and legs posture is reached
			self.currentPosture = self.targetPosture.name;
			self.targetPosture = null;
			self.isChangingPosture = false;
			if (self.nextPosture) {
				self.setPosture(self.nextPosture);
			}
			return;
		} else {
			self.isChangingPosture = true;
		}
		if (self.targetPosture && self.targetPosture.head) {
			self.head.x += (self.targetPosture.head.x - self.head.x) * speed;
		}
		self.head.y += (self.targetPosture.head.y - self.head.y) * speed;
		self.rightArm.x += (self.targetPosture.rightArm.x - self.rightArm.x) * speed;
		self.rightArm.y += (self.targetPosture.rightArm.y - self.rightArm.y) * speed;
		self.rightArm.rotation += (self.targetPosture.rightArm.r - self.rightArm.rotation) * speed;
		// Right hand updates removed due to hand assets being removed
		self.leftArm.x += (self.targetPosture.leftArm.x - self.leftArm.x) * speed;
		self.leftArm.y += (self.targetPosture.leftArm.y - self.leftArm.y) * speed;
		self.leftArm.rotation += (self.targetPosture.leftArm.r - self.leftArm.rotation) * speed;
		// Left hand updates removed due to hand assets being removed
		self.trunk.x += (self.targetPosture.trunk.x - self.trunk.x) * speed;
		self.trunk.y += (self.targetPosture.trunk.y - self.trunk.y) * speed;
		self.rightLeg.x += (self.targetPosture.rightLeg.x - self.rightLeg.x) * speed;
		self.rightLeg.y += (self.targetPosture.rightLeg.y - self.rightLeg.y) * speed;
		// Right foot updates removed due to foot assets being removed
		self.leftLeg.x += (self.targetPosture.leftLeg.x - self.leftLeg.x) * speed;
		self.leftLeg.y += (self.targetPosture.leftLeg.y - self.leftLeg.y) * speed;
	};
	self.moveRight = function () {
		self.x += self.speedX;
	};
	self.jump = function () {
		if (self.isOnGround) {
			self.isOnGround = false;
			self.speedY = self.jumpSpeed;
		}
	};
	self.update = function () {
		if (self.isOnGround && !self.isFalling) {
			self.leftLeg.height = 200;
			self.leftArm.height = 200;
			self.trunk.rotation = 0.125;
			self.runAnim();
		}
		if (!self.isOnGround && !self.isFalling) {
			//log("self.leftArm.height", self.leftArm.height);
			self.jumpAnim();
		}
		if (!self.isOnGround && !self.isFalling) {
			self.y += self.speedY * Math.abs(globalSpeed / 10);
			self.speedY += self.gravity * Math.abs(globalSpeed / 10);
			var groundY = game.groundLevel - 200;
			if (self.y >= groundY) {
				self.y = groundY;
				self.isOnGround = true;
			}
		}
		if (self.isFalling) {
			self.y += 10; //self.speedY;
			//self.speedY += self.gravity;
			var groundY = game.groundLevel + 100;
			if (self.y >= groundY) {
				self.y = groundY;
				self.isOnGround = true;
			}
		}
	};
	self.runAnim = function () {
		var ocsilDelay = 5;
		var armsAmplitude = 0.5;
		var legsAmplitude = 0.5;
		// Simulate running by continuously balancing the arms and legs
		var runningArmAngle = Math.sin(LK.ticks / ocsilDelay) * armsAmplitude; // Oscillate arm angle to simulate running faster
		var runningLegAngle = Math.sin(LK.ticks / ocsilDelay) * legsAmplitude; // Oscillate leg angle to simulate running faster
		var armSwitchProgress = (Math.sin(LK.ticks / 5) + 0) / 2; // Normalize between 0 and 1
		self.rightArm.x = 10 * (1 - armSwitchProgress) - 5 * armSwitchProgress;
		self.leftArm.x = -15 * (1 - armSwitchProgress) + 20 * armSwitchProgress;
		self.rightLeg.x = 5 * (1 - armSwitchProgress) - 5 * armSwitchProgress;
		self.leftLeg.x = -10 * (1 - armSwitchProgress) + 10 * armSwitchProgress;
		self.rightArm.rotation = runningArmAngle; // - Math.PI * 0.5;
		self.leftArm.rotation = -runningArmAngle;
		self.rightLeg.rotation = -runningLegAngle;
		self.leftLeg.rotation = runningLegAngle;
		self.trunk.width = 30 - 10 * (runningArmAngle * Math.PI * 0.5); //armSwitchProgress; // + 10 * Math.abs(runningArmAngle);
		self.head.width = 50 - 10 * (runningArmAngle * Math.PI * 0.5); //armSwitchProgress; // + 10 * Math.abs(runningArmAngle);
		//self.rightArm.height = 180 * (0.5 + Math.abs(runningArmAngle));
		//self.leftArm.height = 150 * (0.7 + Math.abs(runningArmAngle));
		//self.rightLeg.height = 200 * (0.5 + Math.abs(runningArmAngle + Math.PI * 0.125));
		//self.leftLeg.height = 200 * (0.5 + Math.abs(runningArmAngle + Math.PI * 0.125));
	};
	self.jumpAnim = function () {
		var ocsilDelay = 50;
		var armsAmplitude = 1;
		// Simulate running by continuously balancing the arms and legs
		var runningArmAngle = Math.sin(LK.ticks / ocsilDelay) * armsAmplitude; // Oscillate arm angle to simulate running faster
		var armSwitchProgress = (Math.sin(LK.ticks / 5) + 0) / 2; // Normalize between 0 and 1
		self.rightArm.x = 10 * (1 - armSwitchProgress) - 5 * armSwitchProgress;
		self.leftArm.x = -15 * (1 - armSwitchProgress) + 20 * armSwitchProgress;
		self.rightLeg.x = 5 * (1 - armSwitchProgress) - 5 * armSwitchProgress;
		self.leftLeg.x = -10 * (1 - armSwitchProgress) + 10 * armSwitchProgress;
		self.trunk.width = 30 - 10 * (runningArmAngle * Math.PI * 0.5); //armSwitchProgress; // + 10 * Math.abs(runningArmAngle);
		self.trunk.rotation = 0.333; //armSwitchProgress; // + 10 * Math.abs(runningArmAngle);
		var rotationSpeed = 0.05; // Speed of rotation change
		if (self.speedY > 0) {
			self.rightArm.rotation += (0 - self.rightArm.rotation) * rotationSpeed;
			self.leftArm.rotation += (0 - self.leftArm.rotation) * rotationSpeed;
			// Return legs to initial rotation when descending
			self.rightLeg.rotation += (0 - self.rightLeg.rotation) * rotationSpeed;
			self.leftLeg.rotation += (0 - self.leftLeg.rotation) * rotationSpeed;
			self.leftLeg.height -= 30 * rotationSpeed;
			self.leftArm.height -= 20 * rotationSpeed;
		} else {
			self.rightArm.rotation += -Math.PI * 3 * rotationSpeed;
			self.leftArm.rotation += Math.PI * 1.75 * rotationSpeed;
			; //+= (1 - self.leftArm.rotation) * rotationSpeed;
			// Continue with jump animation adjustments
			self.rightLeg.rotation += (-2.3 - self.rightLeg.rotation) * rotationSpeed;
			self.leftLeg.rotation += (1 - self.leftLeg.rotation) * rotationSpeed;
			self.leftLeg.height -= 0 * rotationSpeed;
			self.leftArm.height -= 35 * rotationSpeed;
		}
		/* 
		if (self.speedY > 0) {
			self.rightArm.rotation += (0 - self.rightArm.rotation) * rotationSpeed;
			self.leftArm.rotation += (0 - self.leftArm.rotation) * rotationSpeed;
			// Return legs to initial rotation when descending
			self.rightLeg.rotation += (0 - self.rightLeg.rotation) * rotationSpeed;
			self.leftLeg.rotation += (0 - self.leftLeg.rotation) * rotationSpeed;
			self.leftLeg.height += 35 * rotationSpeed;
			self.leftArm.height += 35 * rotationSpeed;
		} else {
			self.rightArm.rotation += -Math.PI * 3 * rotationSpeed;
			self.leftArm.rotation += Math.PI * 1.75 * rotationSpeed;
			self.rightLeg.rotation += (2 - self.rightLeg.rotation) * rotationSpeed;
			self.leftLeg.rotation += (1.8 - self.leftLeg.rotation) * rotationSpeed;
			self.leftLeg.height -= 35 * rotationSpeed;
			self.leftArm.height -= 35 * rotationSpeed;
		}
		*/ 
	};
	self.fallAnim = function () {
		var fallSpeed = 0.1; // Speed of fall animation
		// Adjust body parts to simulate falling
		self.trunk.rotation += (Math.PI / 2 - self.trunk.rotation) * fallSpeed;
		//self.head.rotation += (Math.PI / 2 - self.head.rotation) * fallSpeed;
		self.rightArm.rotation += (Math.PI / 2 - self.rightArm.rotation) * fallSpeed;
		self.leftArm.rotation += (Math.PI / 2 - self.leftArm.rotation) * fallSpeed;
		self.rightLeg.rotation += (Math.PI / 2 - self.rightLeg.rotation) * fallSpeed;
		self.leftLeg.rotation += (Math.PI / 2 - self.leftLeg.rotation) * fallSpeed;
	};
	self.setPosture = function (newPosture) {
		log("Set posture: " + newPosture.name);
		if (self.isChangingPosture) {
			// Store next posture for when target one is reached
			self.nextPosture = newPosture;
			return;
		}
		if (self.nextPosture) {
			// If a next posture is set, use it as target
			newPosture = self.nextPosture;
			self.nextPosture = null;
		}
		if (newPosture && self.currentPosture != newPosture.name) {
			// Set new posture
			self.targetPosture = newPosture;
		}
	};
});
/****************************************************************************************** */ 
/************************************** OBSTACLE CLASS ************************************ */
/****************************************************************************************** */ 
// Obstacle class
var Obstacle = Container.expand(function (index) {
	var self = Container.call(this);
	self.index = index;
	self.leftRod = self.attachAsset('obstacle', {
		anchorX: 0.5,
		anchorY: 1.0 // Anchor at the bottom for collision detection
	});
	self.centralRod = self.attachAsset('obstacle', {
		anchorX: 0.5,
		anchorY: 1,
		y: -200,
		rotation: Math.PI * 0.125,
		tint: 0xffff00 // Apply a yellow tint for glow effect
	});
	self.rightRod = self.attachAsset('obstacle', {
		anchorX: 0.5,
		anchorY: 0.0,
		x: 95,
		y: -460
	});
	self.speedX = globalSpeed;
	self.update = function () {
		self.speedX = globalSpeed;
		self.x += self.speedX;
		// Remove obstacle if it moves off-screen
		if (self.x < -100) {
			self.destroy();
			obstacles.splice(self.index, 1);
		}
	};
});
/****************************************************************************************** */ 
/************************************** TRACK CLASS ************************************ */
/****************************************************************************************** */ 
var Track = Container.expand(function () {
	var self = Container.call(this);
	self.speedX = globalSpeed; // Use global speed for track movement
	// Attach track asset
	self.trackAsset = self.attachAsset('track', {
		anchorX: 0.0,
		anchorY: 0.0
	});
	// Method to update track position
	self.update = function () {
		self.x += self.speedX;
		// Reset position to create a continuous track effect
		if (self.x <= -2048 - self.speedX * 2) {
			self.x = 2048 + self.speedX * 2;
		}
	};
});

/**** 
* Initialize Game
****/ 
var game = new LK.Game({
	backgroundColor: 0x87CEEB // Light blue background to represent the sky
});

/**** 
* Game Code
****/ 
// Enumeration for game states
/****************************************************************************************** */ 
/************************************** GLOBAL VARIABLES ********************************** */
/****************************************************************************************** */ 
var GAME_STATE = {
	INIT: 'INIT',
	MENU: 'MENU',
	HELP: 'HELP',
	STARTING: 'STARTING',
	NEW_ROUND: 'NEW_ROUND',
	PLAYING: 'PLAYING',
	SCORE: 'SCORE'
};
var gameState = GAME_STATE.INIT;
var athlete;
var obstacles = [];
var groundLevel = 2732 - 200; // Ground level set 200px from the bottom
var obstacleSpawnTicker = 0;
var obstacleSpawnRate = 180; // Spawn an obstacle every 2 seconds
var isDebug = true;
var track;
var track2;
var track3;
var scoreTxt;
var globalSpeed = -10; //-10; // Global speed for tracks and obstacles min = -4
var globalSpeedIncreaseStep = 5;
/****************************************************************************************** */ 
/************************************** POSTURES ****************************************** */
/****************************************************************************************** */ 
var idlePosture = {
	name: "idlePosture",
	trunk: {
		x: 0,
		y: 0
	},
	head: {
		x: 0,
		y: 0
	},
	rightArm: {
		x: 20,
		y: -80,
		r: 0 //Math.PI * 2 * 0.0
	},
	leftArm: {
		x: -20,
		y: -80,
		r: 0 //Math.PI * 2 * 0.125
	},
	rightLeg: {
		x: 5,
		y: 100
	},
	leftLeg: {
		x: -5,
		y: 100
	}
};
/****************************************************************************************** */ 
/*********************************** UTILITY FUNCTIONS ************************************ */
/****************************************************************************************** */ 
function log() {
	if (isDebug) {
		var _console;
		(_console = console).log.apply(_console, arguments);
	}
}
/****************************************************************************************** */ 
/************************************** INPUT HANDLERS ************************************ */
/****************************************************************************************** */ 
// Touch event to make the athlete jump
game.on('down', function () {
	athlete.jump();
});
/****************************************************************************************** */ 
/************************************* AI FUNCTIONS *************************************** */
/****************************************************************************************** */ 
/****************************************************************************************** */ 
/************************************* GAME STATES **************************************** */
/****************************************************************************************** */ 
function gameInitialize() {
	log("Game initialize...");
	// Add background asset
	scoreTxt = new Text2('0', {
		size: 150,
		fill: "#ffffff" // White color for better visibility
	});
	scoreTxt.anchor.set(0.5, 0); // Center the score text horizontally
	LK.gui.top.addChild(scoreTxt); // Add the score text to the GUI overlay at the top center
	var background = LK.getAsset('background', {
		anchorX: 0.0,
		anchorY: 0.0,
		visible: false // TEMP DEBUG
	});
	game.addChild(background);
	// Initialize track using Track class
	track = game.addChild(new Track());
	track.x = 0;
	track.y = 2732 - 512;
	// Second track instance for continuous effect
	track2 = game.addChild(new Track());
	track2.x = 2048; // Position the second track right after the first one
	track2.y = 2732 - 512;
	// Second track instance for continuous effect
	track3 = game.addChild(new Track());
	track3.x = 2048 * 2; // Position the second track right after the first one
	track3.y = 2732 - 512;
	track3.visible = false;
	// Initialize athlete
	athlete = game.addChild(new Athlete());
	athlete.x = 400;
	athlete.y = groundLevel - 200;
	athlete.setPosture(idlePosture);
	// Set the ground level globally accessible within the game instance
	game.groundLevel = groundLevel;
	gameState = GAME_STATE.PLAYING;
}
function gamePlaying() {
	log("Game playing...");
	athlete.update();
	athlete.updatePosture();
	// Move obstacles and check for off-screen
	/* 
	for (var i = obstacles.length - 1; i >= 0; i--) {
	obstacles[i].move();
	// Remove obstacle if it moves off-screen and increase global speed
	if (obstacles[i].x < -100 && !athlete.isFalling) {
	// Assuming obstacle width is less than 100px
	obstacles[i].destroy();
	obstacles.splice(i, 1);
	}
	}
	*/ 
	// Spawn obstacles
	spawnObstacles();
	// Update obstacles
	updateObstacles();
	/* update Progress
			// Increase global speed after each obstacle passed and add 1 to score only if not falling
			globalSpeed -= globalSpeedIncreaseStep; // Increase the speed
			track.speedX = globalSpeed; // Update track speed
			track2.speedX = globalSpeed; // Update track2 speed
			LK.setScore(LK.getScore() + 1); // Add 1 to score for each hurdle passed only if not falling
			scoreTxt.setText(LK.getScore()); // Update score text with prefix
			obstacles.forEach(function (obstacle) {
					// Update all obstacles speed
					obstacle.speedX = globalSpeed;
			});
	*/ 
	/* 
	obstacleSpawnTicker++;
	if (obstacleSpawnTicker >= obstacleSpawnRate) {
	obstacleSpawnTicker = 0;
	var newObstacle = new Obstacle(obstacles.length);
	newObstacle.x = 2048; // Start from the right edge
	newObstacle.y = groundLevel + 200;
	obstacles.push(newObstacle);
	game.addChild(newObstacle);
	}
	if (!(athlete.isFalling && athlete.isOnGround)) {
	track.update();
	track2.update();
	track3.update();
	} else {
	// Stop obstacles movement when athlete is falling and on ground
	obstacles.forEach(function (obstacle) {
	obstacle.speedX = 0;
	});
	}
	*/ 
	game.addChild(athlete);
	// Check for collisions
	obstacles.forEach(function (obstacle) {
		if (athlete.intersects(obstacle.centralRod)) {
			athlete.isFalling = true;
			athlete.isOnGround = false;
			athlete.fallAnim(); // Call fall animation before game over
			if (!athlete.hasFlashed) {
				LK.effects.flashScreen(0xaaaaaa, 500); // Flash screen red for half a second
				athlete.hasFlashed = true;
			}
			LK.setTimeout(function () {
				LK.showGameOver(); // Show game over screen
			}, 600); // Delay game over to allow fall animation to be seen
		}
	});
	if (athlete.hasFlashed && athlete.isFalling && athlete.isOnGround) {
		LK.effects.flashScreen(0xff0000, 100); // Flash screen red for half a second
		athlete.hasFlashedGround = true;
	}
}
/****************************************************************************************** */ 
/************************************** GAME FUNCTIONS ************************************ */
/****************************************************************************************** */ 
function spawnObstacles() {
	// Spawn obstacles
	obstacleSpawnTicker++;
	if (obstacleSpawnTicker >= obstacleSpawnRate) {
		obstacleSpawnTicker = 0;
		var newObstacle = new Obstacle(obstacles.length);
		newObstacle.x = 2048; // Start from the right edge
		newObstacle.y = groundLevel + 200;
		obstacles.push(newObstacle);
		game.addChild(newObstacle);
	}
}
function updateObstacles() {
	// Update obstacles
	obstacles.forEach(function (obstacle) {
		obstacle.update();
	});
}
/****************************************************************************************** */ 
/************************************** MAIN GAME LOOP ************************************ */
/****************************************************************************************** */ 
LK.on('tick', function () {
	switch (gameState) {
		case GAME_STATE.MENU:
			// Handle menu logic here
			break;
		case GAME_STATE.STARTING:
			// Handle game starting logic here
			break;
		case GAME_STATE.PLAYING:
			gamePlaying();
			break;
		case GAME_STATE.SCORE:
			// Handle score display logic here
			break;
	}
});
gameInitialize();

===================================================================
--- original.js
+++ change.js
@@ -200,9 +200,9 @@
 			self.leftLeg.rotation += (1 - self.leftLeg.rotation) * rotationSpeed;
 			self.leftLeg.height -= 0 * rotationSpeed;
 			self.leftArm.height -= 35 * rotationSpeed;
 		}
-		/*
+		/* 
 		if (self.speedY > 0) {
 			self.rightArm.rotation += (0 - self.rightArm.rotation) * rotationSpeed;
 			self.leftArm.rotation += (0 - self.leftArm.rotation) * rotationSpeed;
 			// Return legs to initial rotation when descending
@@ -217,9 +217,9 @@
 			self.leftLeg.rotation += (1.8 - self.leftLeg.rotation) * rotationSpeed;
 			self.leftLeg.height -= 35 * rotationSpeed;
 			self.leftArm.height -= 35 * rotationSpeed;
 		}
-		*/
+		*/ 
 	};
 	self.fallAnim = function () {
 		var fallSpeed = 0.1; // Speed of fall animation
 		// Adjust body parts to simulate falling
@@ -251,10 +251,11 @@
 /****************************************************************************************** */ 
 /************************************** OBSTACLE CLASS ************************************ */
 /****************************************************************************************** */ 
 // Obstacle class
-var Obstacle = Container.expand(function () {
+var Obstacle = Container.expand(function (index) {
 	var self = Container.call(this);
+	self.index = index;
 	self.leftRod = self.attachAsset('obstacle', {
 		anchorX: 0.5,
 		anchorY: 1.0 // Anchor at the bottom for collision detection
 	});
@@ -271,10 +272,16 @@
 		x: 95,
 		y: -460
 	});
 	self.speedX = globalSpeed;
-	self.move = function () {
-		self.x += self.speedX; // * 0; // TEMP DEBUG !!!
+	self.update = function () {
+		self.speedX = globalSpeed;
+		self.x += self.speedX;
+		// Remove obstacle if it moves off-screen
+		if (self.x < -100) {
+			self.destroy();
+			obstacles.splice(self.index, 1);
+		}
 	};
 });
 /****************************************************************************************** */ 
 /************************************** TRACK CLASS ************************************ */
@@ -423,12 +430,103 @@
 	// Set the ground level globally accessible within the game instance
 	game.groundLevel = groundLevel;
 	gameState = GAME_STATE.PLAYING;
 }
-// This function has been moved to a separate function for better organization
+function gamePlaying() {
+	log("Game playing...");
+	athlete.update();
+	athlete.updatePosture();
+	// Move obstacles and check for off-screen
+	/* 
+	for (var i = obstacles.length - 1; i >= 0; i--) {
+	obstacles[i].move();
+	// Remove obstacle if it moves off-screen and increase global speed
+	if (obstacles[i].x < -100 && !athlete.isFalling) {
+	// Assuming obstacle width is less than 100px
+	obstacles[i].destroy();
+	obstacles.splice(i, 1);
+	}
+	}
+	*/ 
+	// Spawn obstacles
+	spawnObstacles();
+	// Update obstacles
+	updateObstacles();
+	/* update Progress
+			// Increase global speed after each obstacle passed and add 1 to score only if not falling
+			globalSpeed -= globalSpeedIncreaseStep; // Increase the speed
+			track.speedX = globalSpeed; // Update track speed
+			track2.speedX = globalSpeed; // Update track2 speed
+			LK.setScore(LK.getScore() + 1); // Add 1 to score for each hurdle passed only if not falling
+			scoreTxt.setText(LK.getScore()); // Update score text with prefix
+			obstacles.forEach(function (obstacle) {
+					// Update all obstacles speed
+					obstacle.speedX = globalSpeed;
+			});
+	*/ 
+	/* 
+	obstacleSpawnTicker++;
+	if (obstacleSpawnTicker >= obstacleSpawnRate) {
+	obstacleSpawnTicker = 0;
+	var newObstacle = new Obstacle(obstacles.length);
+	newObstacle.x = 2048; // Start from the right edge
+	newObstacle.y = groundLevel + 200;
+	obstacles.push(newObstacle);
+	game.addChild(newObstacle);
+	}
+	if (!(athlete.isFalling && athlete.isOnGround)) {
+	track.update();
+	track2.update();
+	track3.update();
+	} else {
+	// Stop obstacles movement when athlete is falling and on ground
+	obstacles.forEach(function (obstacle) {
+	obstacle.speedX = 0;
+	});
+	}
+	*/ 
+	game.addChild(athlete);
+	// Check for collisions
+	obstacles.forEach(function (obstacle) {
+		if (athlete.intersects(obstacle.centralRod)) {
+			athlete.isFalling = true;
+			athlete.isOnGround = false;
+			athlete.fallAnim(); // Call fall animation before game over
+			if (!athlete.hasFlashed) {
+				LK.effects.flashScreen(0xaaaaaa, 500); // Flash screen red for half a second
+				athlete.hasFlashed = true;
+			}
+			LK.setTimeout(function () {
+				LK.showGameOver(); // Show game over screen
+			}, 600); // Delay game over to allow fall animation to be seen
+		}
+	});
+	if (athlete.hasFlashed && athlete.isFalling && athlete.isOnGround) {
+		LK.effects.flashScreen(0xff0000, 100); // Flash screen red for half a second
+		athlete.hasFlashedGround = true;
+	}
+}
 /****************************************************************************************** */ 
 /************************************** GAME FUNCTIONS ************************************ */
 /****************************************************************************************** */ 
+function spawnObstacles() {
+	// Spawn obstacles
+	obstacleSpawnTicker++;
+	if (obstacleSpawnTicker >= obstacleSpawnRate) {
+		obstacleSpawnTicker = 0;
+		var newObstacle = new Obstacle(obstacles.length);
+		newObstacle.x = 2048; // Start from the right edge
+		newObstacle.y = groundLevel + 200;
+		obstacles.push(newObstacle);
+		game.addChild(newObstacle);
+	}
+}
+function updateObstacles() {
+	// Update obstacles
+	obstacles.forEach(function (obstacle) {
+		obstacle.update();
+	});
+}
 /****************************************************************************************** */ 
 /************************************** MAIN GAME LOOP ************************************ */
 /****************************************************************************************** */ 
 LK.on('tick', function () {