/**** 
* Classes
****/ 
// Define the BackgroundContainer class
var BackgroundContainer = Container.expand(function () {
	var self = Container.call(this);
	var backgroundGraphics1 = self.attachAsset('background', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 2048 / 2732,
		scaleY: 2732 / 2732
	});
	backgroundGraphics1.x = 2048 / 2;
	backgroundGraphics1.y = 2732 / 2;
	var backgroundGraphics2 = self.attachAsset('background', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 2048 / 2732,
		scaleY: 2732 / 2732
	});
	backgroundGraphics2.x = 2048 / 2;
	backgroundGraphics2.y = -2732 / 2;
	self.backgroundGraphics1 = backgroundGraphics1;
	self.backgroundGraphics2 = backgroundGraphics2;
	self.update = function () {
		if (gameStarted) {
			self.backgroundGraphics1.y -= backgroundSpeed;
			self.backgroundGraphics2.y -= backgroundSpeed;
			backgroundSpeed += backgroundAcceleration;
		}
		// Ensure backgrounds stay within bounds after jump movement
		if (self.backgroundGraphics1.y > 2732 / 2) {
			self.backgroundGraphics1.y = self.backgroundGraphics2.y - 2732;
		}
		if (self.backgroundGraphics2.y > 2732 / 2) {
			self.backgroundGraphics2.y = self.backgroundGraphics1.y - 2732;
		}
		if (self.backgroundGraphics1.y <= -2732 / 2) {
			self.backgroundGraphics1.y = self.backgroundGraphics2.y + 2732;
		}
		if (self.backgroundGraphics2.y <= -2732 / 2) {
			self.backgroundGraphics2.y = self.backgroundGraphics1.y + 2732;
		}
	};
	return self;
});
var Booster = Container.expand(function () {
	var self = Container.call(this);
	var boosterGraphics = self.attachAsset('booster', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.width = boosterGraphics.width;
	self.height = boosterGraphics.height;
	self.speed = 2;
	self.update = function () {
		self.speed += 0.05; // Acceleration
		self.y += self.speed;
		if (self.y > 2732 + self.height / 2) {
			self.destroy();
		}
	};
	return self;
});
// Define the Coin class
var Coin = Container.expand(function () {
	var self = Container.call(this);
	var coinGraphics = self.attachAsset('coin', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.width = coinGraphics.width;
	self.height = coinGraphics.height;
	self.speed = 2;
	self.animationFrames = [LK.getAsset('coin', {
		anchorX: 0.5,
		anchorY: 0.5
	}), LK.getAsset('coin_2', {
		anchorX: 0.5,
		anchorY: 0.5
	}), LK.getAsset('coin_3', {
		anchorX: 0.5,
		anchorY: 0.5
	}), LK.getAsset('coin_2', {
		anchorX: 0.5,
		anchorY: 0.5
	})];
	self.currentFrame = 0;
	self.frameDuration = 144; // 300 milliseconds per frame
	self.lastFrameChange = Date.now();
	self.update = function () {
		self.speed += 0.05; // Acceleration
		self.y += self.speed;
		// Handle animation frame change
		if (Date.now() - self.lastFrameChange >= self.frameDuration) {
			self.currentFrame = (self.currentFrame + 1) % self.animationFrames.length;
			self.removeChildAt(0);
			self.addChild(self.animationFrames[self.currentFrame]);
			self.lastFrameChange = Date.now();
		}
		if (self.y > 2732 + self.height / 2) {
			self.destroy();
		}
	};
	return self;
});
// Define the ForegroundContainer class
var ForegroundContainer = Container.expand(function () {
	var self = Container.call(this);
	return self;
});
// Define the MidgroundContainer class
var MidgroundContainer = Container.expand(function () {
	var self = Container.call(this);
	return self;
});
// Define the Obstacle class
var Obstacle = Container.expand(function () {
	var self = Container.call(this);
	var obstacleGraphics = self.attachAsset('obstacle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.width = obstacleGraphics.width;
	self.height = obstacleGraphics.height;
	self.speed = 5;
	self.rotationSpeed = Math.random() < 0.5 ? 0.03 : -0.03; // Randomly decide rotation direction
	self.update = function () {
		self.speed += 0.2; // Acceleration
		self.y += self.speed;
		self.rotation += self.rotationSpeed; // Add rotation
		if (self.y > 2732 + self.height / 2) {
			self.destroy();
		}
	};
	return self;
});
var Platform = Container.expand(function () {
	var self = Container.call(this);
	var platformGraphics = self.attachAsset('platform', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.width = platformGraphics.width;
	self.height = platformGraphics.height;
	self.update = function () {
		if (gameStarted) {
			self.y += 30;
			if (self.y > 2732 + self.height / 2) {
				self.destroy();
			}
		}
	};
	return self;
});
//<Assets used in the game will automatically appear here>
// Define the Player class
var Player = Container.expand(function () {
	var self = Container.call(this);
	var playerGraphics = self.attachAsset('player', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	playerGraphics.visible = false;
	var playerIdleGraphics = self.attachAsset('player_idle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	playerIdleGraphics.visible = true;
	self.playerWidth = playerGraphics.width;
	self.playerHeight = playerGraphics.height;
	self.playerIdleWidth = playerIdleGraphics.width;
	self.playerIdleHeight = playerIdleGraphics.height;
	self.speed = playerHorizontalSpeed;
	self.slidingSpeed = playerSlidingSpeed; // Add sliding speed property
	self.direction = 1; // 1: right, -1: left
	self.isTouchingWall = true; // true: player is touching a wall, false: player is in mid air
	self.update = function () {
		if (gameStarted) {
			if (self.direction === -1 && self.x > self.playerWidth / 2 - 60) {
				self.x -= self.speed;
				if (self.x <= self.playerWidth / 2 - 60) {
					self.x = self.playerWidth / 2 - 60; // Prevent the player from going past the left edge of the screen
					self.isTouchingWall = true;
					playerGraphics.scale.x = -1; // Flip the player's x axis
				}
			} else if (self.direction === 1 && self.x < 2048 - self.playerWidth / 2 + 60) {
				self.x += self.speed;
				if (self.x >= 2048 - self.playerWidth / 2 + 60) {
					self.x = 2048 - self.playerWidth / 2 + 60; // Prevent the player from going past the right edge of the screen
					self.isTouchingWall = true;
					playerGraphics.scale.x = 1; // Flip the player's x axis back to its original state
				}
			}
			self.y += self.verticalSpeed; // Apply the vertical speed to the player's position
			if (self.y < 0) {
				// Prevent the player from going off the top of the screen
				self.y = 0;
				self.verticalSpeed = 0;
			}
			if (self.y > 2732 - (playerGraphics.visible ? self.playerHeight : self.playerIdleHeight) / 2) {
				// Trigger game over if the player hits the bottom edge of the screen
				LK.effects.flashScreen(0xff0000, 1000);
				LK.showGameOver();
			}
			if (self.isTouchingWall) {
				// Reset the vertical speed and apply the sliding speed when the player touches a wall
				self.verticalSpeed = 0;
				self.slidingSpeed += playerSlidingAcceleration;
				self.y += self.slidingSpeed;
			}
		}
	};
	self.immune = false; // Add a new property to the player to make it immune to spikes
	self.jump = function () {
		if (self.isTouchingWall) {
			if (!gameStarted) {
				gameStarted = true;
				firstJump = true; // Set the firstJump flag to true after the first jump
			}
			self.direction *= -1;
			self.verticalSpeed = -playerVerticalJumpSpeed; // Set the vertical speed when jumping
			self.slidingSpeed = playerSlidingSpeed; // Reset the sliding speed
			self.isTouchingWall = false;
			playerGraphics.visible = true;
			playerIdleGraphics.visible = false;
			// Move backgrounds down by 200 pixels
			backgroundContainer.backgroundGraphics1.y += 300;
			backgroundContainer.backgroundGraphics2.y += 300;
			// Move forest down by 100 pixels
			forest.y += 300;
			// Reset background speed
			backgroundSpeed = initialBackgroundSpeed;
			// Move all spikes down by 500 pixels
			for (var i = 0; i < spikes.length; i++) {
				spikes[i].y += spikeMovement;
			}
			// Reset the spikes' upwards movement speed
			spikeUpwardsMovement = spikeSpeed;
			self.immune = true; // Make the player immune to spikes after jumping
			LK.setTimeout(function () {
				// Set a timeout to remove the immunity after half a second
				self.immune = false;
			}, 100);
			spawnObstacle(); // Spawn a new obstacle whenever the player jumps
		}
	};
	return self;
});
// Define the Spike class
var Spike = Container.expand(function () {
	var self = Container.call(this);
	var spikeGraphics = self.attachAsset('spikes', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.width = spikeGraphics.width;
	self.height = spikeGraphics.height;
	self.hasMoved = false; // Add hasMoved flag
	self.update = function () {
		if (self.y > 2732 + self.height / 2 + 500) {
			self.destroy();
		}
		if (player.isTouchingWall) {
			self.y -= spikeSpeed;
		}
	};
	return self;
});

/**** 
* Initialize Game
****/ 
var game = new LK.Game({
	backgroundColor: 0x7abde6 //Init game with new background color
});

/**** 
* Game Code
****/ 
// Function to check score and start spike intervals
function checkAndStartSpikes() {
	if (LK.getScore() >= scoreThreshold && !spikeInterval && gameStarted) {
		spikeInterval = LK.setInterval(spawnSpike, spikeIntervalTime);
	}
}
// Declare global variables for background speed and acceleration
var initialBackgroundSpeed = 1;
var backgroundSpeed = initialBackgroundSpeed;
var backgroundAcceleration = 0.02;
var firstJump = false; // Flag to track the first jump
// Declare a global variable to track if the game has started
var gameStarted = false;
// Initialize BackgroundContainer, MidgroundContainer, and ForegroundContainer
var backgroundContainer = game.addChild(new BackgroundContainer());
var midgroundContainer = game.addChild(new MidgroundContainer());
var foregroundContainer = game.addChild(new ForegroundContainer());
var playerVerticalJumpSpeed = 20;
// Declare global variables for player's horizontal, vertical and sliding speed
var playerHorizontalSpeed = 80;
var playerSlidingSpeed = 1;
var playerSlidingAcceleration = 0.02;
// Declare a global variable to track if the game has started
var gameStarted = false;
// Declare global variables for the spikes movement, their upwards movement and their acceleration
var spikeMovement = 500;
var spikeUpwardsMovement = 10;
var spikeAcceleration = 0.02;
// Declare global variables for spike interval and score threshold
var spikeIntervalTime = 15000;
var scoreThreshold = 10;
// Initialize player
var player = foregroundContainer.addChild(new Player());
player.immune = false; // Add a new property to the player to make it immune to spikes
// Add forest asset to the midground container
var forest = LK.getAsset('forest', {
	anchorX: 0.5,
	anchorY: 0,
	scaleX: 1,
	scaleY: 1,
	x: 2048 / 2,
	y: 2732 / 2
});
midgroundContainer.addChild(forest);
// Initialize platform and place it below the player_idle
var platform = midgroundContainer.addChild(new Platform());
platform.x = 2048 / 2;
platform.y = 2732 - 500 + player.playerIdleHeight / 2 + platform.height / 2;
// Initialize coins array
var coins = [];
// Track the number of coin arrays generated
var coinArrayCounter = 0;
// Initialize spikes array
var spikes = [];
// Set the direction at the start of the game
var spikePlacementFlag = Math.random() < 0.5 ? true : false;
// Initialize the first spike (Removed initial spike generation)
player.verticalSpeed = 0;
player.x = 2048 / 2;
player.y = 2732 - 430;
// Initialize obstacles array
var obstacles = [];
// Function to spawn obstacles
function spawnObstacle() {
	if (gameStarted) {
		var obstacle = new Obstacle();
		obstacle.x = Math.random() * (2048 - 800) + 400; // Add padding to the enemy spawner
		obstacle.y = -obstacle.height / 2;
		obstacles.push(obstacle);
		game.addChild(obstacle);
	}
}
// Function to spawn coins
function spawnCoins() {
	// Define the 18 available spots
	var spots = [];
	for (var i = 0; i < 3; i++) {
		for (var j = 0; j < 6; j++) {
			spots.push({
				x: j * (150 + 100) + 400,
				y: i * (150 + 50) - 500
			});
		}
	}
	// Shuffle the spots array
	for (var i = spots.length - 1; i > 0; i--) {
		var j = Math.floor(Math.random() * (i + 1));
		var temp = spots[i];
		spots[i] = spots[j];
		spots[j] = temp;
	}
	// Generate a random number of coins (between 4 and 9) in random spots
	var numCoins = Math.floor(Math.random() * 8) + 5;
	for (var i = 0; i < numCoins; i++) {
		var coin = new Coin();
		coin.x = spots[i].x;
		coin.y = spots[i].y;
		coins.push(coin);
		game.addChild(coin);
	}
	// Increment the coin array counter
	coinArrayCounter++;
	// Add booster to a random spot every 2nd coin array generation
	if (coinArrayCounter % 2 === 0) {
		var booster = new Booster();
		var boosterSpot;
		do {
			boosterSpot = Math.floor(Math.random() * spots.length);
		} while (coins.some(function (coin) {
			return coin.x === spots[boosterSpot].x && coin.y === spots[boosterSpot].y;
		}));
		booster.x = spots[boosterSpot].x;
		booster.y = spots[boosterSpot].y;
		game.addChild(booster);
	}
}
// Function to spawn spikes
function spawnSpike() {
	var spike = new Spike();
	spike.x = spikePlacementFlag ? spike.width / 2 : 2048 - spike.width / 2; // Attach to the wall based on the flag
	spike.y = -spike.height / 2;
	if (spike.x === 2048 - spike.width / 2) {
		// If the spike is on the right wall
		spike.scale.x = -1; // Flip the spike on its x axis
	}
	spikes.push(spike);
	game.addChild(spike);
	spikePlacementFlag = !spikePlacementFlag; // Flip the flag after each spike placement
}
// Initialize score text
var scoreTxt = new Text2('0', {
	size: 150,
	fill: "#ffffff",
	stroke: "#000000",
	strokeThickness: 15
});
scoreTxt.anchor.set(0.5, 0); // Sets anchor to the center of the top edge of the text.
scoreTxt.y -= 950; // Move the score 500 pixels higher
LK.gui.center.addChild(scoreTxt); // Add the score text to the GUI overlay.
// Set interval to spawn spikes and coins
var coinInterval;
var spikeInterval;
checkAndStartSpikes();
// Handle touch events
game.down = function (x, y, obj) {
	if (!gameStarted) {
		gameStarted = true;
		player.direction = Math.random() < 0.5 ? -1 : 1;
		LK.playMusic('background_music');
		// Spawn coins immediately after the first jump
		spawnCoins();
		// Start generating coins after the set interval
		coinInterval = LK.setInterval(spawnCoins, 3500);
		// Start generating spikes after the score threshold
		checkAndStartSpikes();
	}
	player.jump();
	// Play a sound effect when the player jumps
	LK.getSound('jump').play();
};
game.up = function (x, y, obj) {
	// No operations needed here
};
// Update game logic
game.update = function () {
	if (gameStarted) {
		backgroundContainer.update();
		player.update();
		if (player.y > 2732 - player.height / 2) {
			LK.effects.flashScreen(0xff0000, 1000);
			LK.showGameOver();
		}
		platform.update();
		forest.y -= 2; // Move the forest upwards by 1 pixel
		if (forest.y < -forest.height) {
			forest.destroy();
		}
		for (var i = obstacles.length - 1; i >= 0; i--) {
			obstacles[i].update();
			if (player.intersects(obstacles[i])) {
				LK.effects.flashScreen(0xff0000, 1000);
				LK.showGameOver();
			}
		}
		for (var i = coins.length - 1; i >= 0; i--) {
			coins[i].update();
			if (coins[i].y > 2732 + coins[i].height / 2) {
				coins[i].destroy();
				coins.splice(i, 1);
			}
			if (player.intersects(coins[i])) {
				if (coins[i] instanceof Booster) {
					player.immune = true;
					player.alpha = 0.5; // Set transparency to 50%
					LK.setTimeout(function () {
						player.immune = false;
						player.alpha = 1; // Reset transparency to 100%
					}, 5000); // Immunity lasts for 5 seconds
				} else {
					LK.setScore(LK.getScore() + 1);
					scoreTxt.setText(LK.getScore());
					LK.getSound('coin').play();
				}
				coins[i].destroy();
				coins.splice(i, 1);
				spawnObstacle();
				checkAndStartSpikes();
			}
		}
		for (var i = spikes.length - 1; i >= 0; i--) {
			if (player.intersects(spikes[i]) && !player.immune) {
				LK.effects.flashScreen(0xff0000, 1000);
				LK.showGameOver();
			}
		}
	}
};
var spikeSpeed = 3;

===================================================================
--- original.js
+++ change.js
@@ -382,12 +382,16 @@
 	coinArrayCounter++;
 	// Add booster to a random spot every 2nd coin array generation
 	if (coinArrayCounter % 2 === 0) {
 		var booster = new Booster();
-		var randomSpot = Math.floor(Math.random() * spots.length);
-		booster.x = spots[randomSpot].x;
-		booster.y = spots[randomSpot].y;
-		coins.push(booster);
+		var boosterSpot;
+		do {
+			boosterSpot = Math.floor(Math.random() * spots.length);
+		} while (coins.some(function (coin) {
+			return coin.x === spots[boosterSpot].x && coin.y === spots[boosterSpot].y;
+		}));
+		booster.x = spots[boosterSpot].x;
+		booster.y = spots[boosterSpot].y;
 		game.addChild(booster);
 	}
 }
 // Function to spawn spikes