/**** 
* 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.isBlinking) {
				self.alpha = self.immune > 0 ? 0.5 : 1;
			}
			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;
			}
			// Removed game over check in the player update method
			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.isBlinking = false; // Add a new property to manage the blinking state
	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++; // Increment immunity to spikes after jumping
			LK.setTimeout(function () {
				// Set a timeout to remove the immunity after half a second
				self.immune--;
			}, 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 = 0; // 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 coins instead of obstacles
function spawnObstacle() {
	if (gameStarted) {
		var coin = new Coin();
		coin.x = Math.random() * (2048 - 800) + 400; // Add padding to the coin spawner
		coin.y = -coin.height / 2;
		coins.push(coin);
		game.addChild(coin);
	}
}
// 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 extra coin to a random spot every 5 coin array generations
	if (coinArrayCounter % 5 === 0) {
		var extraCoin = new Coin();
		// Find an empty spot for the extra coin
		var emptySpots = spots.slice(numCoins); // Get the remaining spots after placing coins
		var randomEmptySpot = Math.floor(Math.random() * emptySpots.length);
		extraCoin.x = emptySpots[randomEmptySpot].x;
		extraCoin.y = emptySpots[randomEmptySpot].y;
		coins.push(extraCoin);
		game.addChild(extraCoin);
	}
}
// Function to spawn coins instead of spikes
function spawnSpike() {
	var coin = new Coin();
	coin.x = spikePlacementFlag ? 150 : 2048 - 150; // Place coin near walls
	coin.y = -coin.height / 2;
	coins.push(coin);
	game.addChild(coin);
	spikePlacementFlag = !spikePlacementFlag; // Flip the flag after each coin placement
}
// Initialize score text
var scoreTxt = new Text2('0', {
	size: 150,
	fill: 0xFFFFFF,
	stroke: 0x000000,
	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();
	LK.getSound('jumping').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();
		}
		// Obstacles converted to coins - no collision detection needed
		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])) {
				LK.setScore(LK.getScore() + 1);
				scoreTxt.setText(LK.getScore());
				LK.getSound('coin').play();
				coins[i].destroy();
				coins.splice(i, 1);
				spawnObstacle();
				checkAndStartSpikes();
			}
		}
		// Spikes converted to coins - no collision detection needed
	}
};
var spikeSpeed = 3;

===================================================================
--- original.js
+++ change.js
@@ -339,16 +339,16 @@
 player.x = 2048 / 2;
 player.y = 2732 - 430;
 // Initialize obstacles array
 var obstacles = [];
-// Function to spawn obstacles
+// Function to spawn coins instead of 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);
+		var coin = new Coin();
+		coin.x = Math.random() * (2048 - 800) + 400; // Add padding to the coin spawner
+		coin.y = -coin.height / 2;
+		coins.push(coin);
+		game.addChild(coin);
 	}
 }
 // Function to spawn coins
 function spawnCoins() {
@@ -379,38 +379,34 @@
 		game.addChild(coin);
 	}
 	// Increment the coin array counter
 	coinArrayCounter++;
-	// Add booster to a random spot every 5 coin array generations
+	// Add extra coin to a random spot every 5 coin array generations
 	if (coinArrayCounter % 5 === 0) {
-		var booster = new Booster();
-		// Find an empty spot for the booster
+		var extraCoin = new Coin();
+		// Find an empty spot for the extra coin
 		var emptySpots = spots.slice(numCoins); // Get the remaining spots after placing coins
 		var randomEmptySpot = Math.floor(Math.random() * emptySpots.length);
-		booster.x = emptySpots[randomEmptySpot].x;
-		booster.y = emptySpots[randomEmptySpot].y;
-		coins.push(booster);
-		game.addChild(booster);
+		extraCoin.x = emptySpots[randomEmptySpot].x;
+		extraCoin.y = emptySpots[randomEmptySpot].y;
+		coins.push(extraCoin);
+		game.addChild(extraCoin);
 	}
 }
-// Function to spawn spikes
+// Function to spawn coins instead of 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
+	var coin = new Coin();
+	coin.x = spikePlacementFlag ? 150 : 2048 - 150; // Place coin near walls
+	coin.y = -coin.height / 2;
+	coins.push(coin);
+	game.addChild(coin);
+	spikePlacementFlag = !spikePlacementFlag; // Flip the flag after each coin placement
 }
 // Initialize score text
 var scoreTxt = new Text2('0', {
 	size: 150,
-	fill: "#ffffff",
-	stroke: "#000000",
+	fill: 0xFFFFFF,
+	stroke: 0x000000,
 	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
@@ -453,62 +449,25 @@
 		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]) && player.immune <= 0) {
-				LK.effects.flashScreen(0xff0000, 1000);
-				LK.showGameOver();
-			}
-		}
+		// Obstacles converted to coins - no collision detection needed
 		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++;
-					player.alpha = 0.5;
-					player.isBlinking = false;
-					LK.getSound('booster').play(); // Play booster sound effect
-					LK.getSound('invisible').play(); // Play invisible sound effect
-					// Start the immunity and blinking timer
-					var immunityDuration = 4600; // 5 seconds of transparency
-					var blinkingDuration = 2400; // 2 seconds of blinking
-					var blinkingInterval = 200; // Toggle alpha every 200 ms
-					// Set timeout for the transparency period
-					LK.setTimeout(function () {
-						player.isBlinking = true;
-						var blinkTimer = LK.setInterval(function () {
-							player.alpha = player.alpha === 0.5 ? 1 : 0.5;
-						}, blinkingInterval);
-						// Set timeout for the blinking period
-						LK.setTimeout(function () {
-							LK.clearInterval(blinkTimer);
-							player.immune--;
-							player.alpha = 1;
-							player.isBlinking = false;
-						}, blinkingDuration);
-					}, immunityDuration);
-				} else {
-					LK.setScore(LK.getScore() + 1);
-					scoreTxt.setText(LK.getScore());
-					LK.getSound('coin').play();
-				}
+				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 <= 0) {
-				LK.effects.flashScreen(0xff0000, 1000);
-				LK.showGameOver();
-			}
-		}
+		// Spikes converted to coins - no collision detection needed
 	}
 };
 var spikeSpeed = 3;
\ No newline at end of file