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

/**** 
* Classes
****/ 
var Enemy = Container.expand(function (spawnFromLeft) {
	var self = Container.call(this);
	var enemyGraphics = self.attachAsset('enemy01', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speedX = Math.random() * 4 + 2; // Random speed between 2 and 6
	// Flip visual and set direction based on spawn side
	if (spawnFromLeft) {
		self.x = -enemyGraphics.width / 2; // start offscreen left
		self.speedX = Math.random() * 4 + 2; // Random speed between 2 and 6
		enemyGraphics.scaleX = -1; // default facing right
	} else {
		self.x = 2048 + enemyGraphics.width / 2; // start offscreen right
		self.speedX = -(Math.random() * 4 + 2); // Random speed between -2 and -6
		enemyGraphics.scaleX = 1 * Math.abs(enemyGraphics.scaleX); // ensure correct flip to face left
	}
	self.y = 2732 - 225;
	self.update = function () {
		self.x += self.speedX;
		if (self.x < -enemyGraphics.width / 2 || self.x > 2048 + enemyGraphics.width / 2) {
			self.destroy();
		}
	};
	// Add a bouncing animation to the enemy
	var originalY = self.y; // Store the original y-coordinate
	tween(self, {
		y: originalY - 50 // Move enemy up by 50 pixels
	}, {
		duration: 500,
		// Duration of 500ms
		easing: tween.bounceInOut,
		// Bouncy easing function
		onFinish: function bounce() {
			// Reverse the tween to create a continuous bounce effect
			tween(self, {
				y: originalY // Move enemy back to original y-coordinate
			}, {
				duration: 500,
				// Duration of 500ms
				easing: tween.bounceInOut,
				// Bouncy easing function
				onFinish: function onFinish() {
					// Repeat the bounce function
					tween(self, {
						y: originalY - 50 // Move enemy up by 50 pixels again
					}, {
						duration: 500,
						// Duration of 500ms
						easing: tween.bounceInOut,
						// Bouncy easing function
						onFinish: bounce
					});
				}
			});
		}
	});
});
var Petal = Container.expand(function () {
	var self = Container.call(this);
	var petalGraphics = self.attachAsset('petals', {
		anchorX: 0.5,
		anchorY: 0.5,
		rotation: Math.random() * Math.PI * 2 // Random rotation for each petal
	});
	self.speedY = Math.random() * 2 + 1; // Random speed for falling
	self.speedX = Math.random() * 2 - 1; // Random horizontal drift
	self.update = function () {
		self.y += self.speedY;
		self.x += self.speedX;
		// Reset position if petal goes off screen
		if (self.y > 2732) {
			self.y = -50;
			self.x = Math.random() * 2048;
		}
	};
});
// Create a new class for the player_attackf01 asset
var PlayerAttack = Container.expand(function () {
	var self = Container.call(this);
	// Attach the player_attackf01 asset to the PlayerAttack class
	var playerAttackGraphics = self.attachAsset('player_attackf01', {
		anchorX: 0.5,
		anchorY: 0.5
	});
});

/**** 
* Initialize Game
****/ 
// Mouse or touch down on the game object
var game = new LK.Game({
	backgroundColor: 0x000000
});

/**** 
* Game Code
****/ 
function createScoreText(value) {
	var shadow = new Text2(String(value), {
		size: 300,
		fill: 0x000000,
		fontFamily: "Arial"
	});
	shadow.anchor.set(0.5, 0);
	shadow.x = 1;
	shadow.y = 1;
	var text = new Text2(String(value), {
		size: 300,
		fill: 0xFF69B4,
		fontFamily: "Arial"
	});
	text.anchor.set(0.5, 0);
	var container = new Container();
	container.addChild(shadow);
	container.addChild(text);
	return container;
}
function updateScoreText(value) {
	// Remove old text from GUI
	LK.gui.top.removeChild(scoreTxt);
	// Create a new score text container with shadow
	scoreTxt = createScoreText(value);
	LK.gui.top.addChild(scoreTxt);
	// Apply a pop and scale effect to the score text
	tween(scoreTxt, {
		scaleX: 1.5,
		scaleY: 1.5
	}, {
		duration: 100,
		easing: tween.easeOut,
		onFinish: function onFinish() {
			tween(scoreTxt, {
				scaleX: 1.0,
				scaleY: 1.0
			}, {
				duration: 100,
				easing: tween.easeIn
			});
		}
	});
}
// Declare attackCol in the global scope
var attackCol = null;
var enemies = [];
// Function to spawn a new enemy
function spawnEnemy() {
	var spawnFromLeft = Math.random() < 0.5; // 50/50 chance
	var enemy = new Enemy(spawnFromLeft);
	enemies.push(enemy);
	game.addChild(enemy);
}
// Set an interval to spawn enemies with random frequency between 1 and 3 seconds
LK.setInterval(spawnEnemy, Math.random() * 2000 + 1000);
// Update function to move enemies
game.update = function () {
	for (var i = enemies.length - 1; i >= 0; i--) {
		enemies[i].update();
		// Check for intersection between enemy and attackCol
		if (attackCol && enemies[i].intersects(attackCol)) {
			var enemy = enemies[i];
			enemies.splice(i, 1); // Remove from array first to avoid duplicate checks 
			// Optional: freeze movement before effect 
			enemy.update = function () {}; // Stop movement 
			LK.getSound('slimedeath').play();
			// Apply red tint 
			enemy.tint = 0xFF0000;
			// Fade out over 0.1 seconds (100 ms), then destroy 
			tween(enemy, {
				scaleX: 1.3,
				scaleY: 1.3
			}, {
				duration: 50,
				onFinish: function onFinish() {
					// Shrink and fade out
					tween(enemy, {
						scaleX: 0.5,
						scaleY: 0.5,
						alpha: 0
					}, {
						duration: 100,
						onFinish: function onFinish() {
							enemy.destroy();
						}
					});
				}
			});
			LK.setScore(LK.getScore() + 1);
			updateScoreText(LK.getScore());
			continue;
		}
		// Check for intersection between enemy and player_idle
		if (enemies[i].intersects(player)) {
			// Trigger game over
			LK.showGameOver();
			// Show score
			updateScoreText(LK.getScore());
		}
		// Remove enemy from array if destroyed
		if (enemies[i].destroyed) {
			enemies.splice(i, 1);
		}
	}
};
// Create a score text object and set its initial value to 0
var scoreTxt = new Text2('0', {
	size: 300,
	fill: 0xFF69B4,
	// Bright flashy pink
	stroke: 0x000000,
	// Ensure black linestroke
	strokeThickness: 5 // Set thickness of the linestroke
});
// Center the score text horizontally, anchor point set at the middle of its top edge
scoreTxt.anchor.set(0.5, 0); // Sets anchor to the center of the top edge of the text
// Add the score text to the GUI overlay at the top-center of the screen
LK.gui.top.addChild(scoreTxt);
LK.playMusic('bgm', {
	loop: true
});
// Create and place bg01 on the playspace at gamestart behind player
var bg01 = LK.getAsset('bg01', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 2048 / 2,
	y: 2732 / 2
});
game.addChild(bg01);
// Create a new instance of the player_idle asset
var player = new Container();
var playerSprite = player.attachAsset('player_idle', {
	anchorX: 0.5,
	anchorY: 0.5
});
player.x = 2048 / 2;
player.y = 2732 - 250;
game.addChild(player);
// Boolean to track if the sequence is running
var isSequenceRunning = false;
// Variable to track the player's current state
var playerState = 'idle'; // Possible states: 'idle', 'jumping', 'attacking'
// Boolean to track if the player is jumping
var isJumping = false;
// Boolean to track if player_idle is on screen
var isPlayerIdleOnScreen = false;
// Add the player to the game
game.addChild(player);
isPlayerIdleOnScreen = true;
// Create a new instance of the enemy01 asset
var enemy = LK.getAsset('enemy01', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 2048 / 2 + 300,
	// Position enemy next to player_idle
	y: 2732 - 225 // Align enemy with player_idle vertically
});
// Destroy the enemy immediately to remove it from the playspace
enemy.destroy();
// Add a bouncy tween effect to enemy01
var originalY = enemy.y; // Store the original y-coordinate
tween(enemy, {
	y: originalY - 50 // Move enemy up by 50 pixels
}, {
	duration: 500,
	// Duration of 500ms
	easing: tween.bounceInOut,
	// Bouncy easing function
	onFinish: function bounce() {
		// Reverse the tween to create a continuous bounce effect
		tween(enemy, {
			y: originalY // Move enemy back to original y-coordinate
		}, {
			duration: 500,
			// Duration of 500ms
			easing: tween.bounceInOut,
			// Bouncy easing function
			onFinish: function onFinish() {
				// Repeat the bounce effect
				tween(enemy, {
					y: originalY - 50
				}, {
					duration: 500,
					easing: tween.bounceInOut,
					onFinish: bounce // Repeat the bounce function
				});
			}
		});
	}
});
// Create a shower of petals
var petals = [];
for (var i = 0; i < 50; i++) {
	var petal = new Petal();
	petal.x = Math.random() * 2048;
	petal.y = Math.random() * 2732;
	petals.push(petal);
	game.addChild(petal);
}
// Import the tween plugin
// Simulate breathing with player_idle by scaling it up and down
tween(player, {
	scaleX: 1.05,
	scaleY: 1.05
}, {
	duration: 1000,
	easing: tween.easeInOut,
	onFinish: function onFinish() {
		tween(player, {
			scaleX: 1.0,
			scaleY: 1.0
		}, {
			duration: 1000,
			easing: tween.easeInOut,
			onFinish: function onFinish() {
				// Repeat the animation
				tween(player, {
					scaleX: 1.05,
					scaleY: 1.05
				}, {
					duration: 1000,
					easing: tween.easeInOut,
					onFinish: function onFinish() {
						// Repeat the animation
						tween(player, {
							scaleX: 1.0,
							scaleY: 1.0
						}, {
							duration: 1000,
							easing: tween.easeInOut,
							onFinish: onFinish
						});
					}
				});
			}
		});
	}
});
// Add a simple animation to the player to make it feel less stiff
tween(player, {
	rotation: Math.PI / 16 // Slight tilt
}, {
	duration: 500,
	easing: tween.easeInOut,
	onFinish: function onFinish() {
		tween(player, {
			rotation: -Math.PI / 16 // Tilt to the opposite side
		}, {
			duration: 500,
			easing: tween.easeInOut,
			onFinish: function onFinish() {
				tween(player, {
					rotation: 0 // Return to original position
				}, {
					duration: 500,
					easing: tween.easeInOut,
					onFinish: onFinish
				});
			}
		});
	}
});
// Update petals
for (var i = 0; i < petals.length; i++) {
	petals[i].update();
}
// Mouse or touch down on the game object
game.down = function (x, y, obj) {
	// Check if the sequence is already running or if the player is jumping or landing
	if (isSequenceRunning || playerState === 'jumping' || playerState === 'landing') {
		return; // Exit if the sequence is already running or if the player is jumping or landing
	}
	// Check if the tap is in the upper 2/3 of the screen
	if (y < 2732 * 2 / 3) {
		// Prevent multiple jumps
		if (!isJumping) {
			isJumping = true;
			// Play 'hup' sound when player jumps
			LK.getSound('hup').play();
			// Switch to player_jump image
			swapPlayerVisual('player_jump', 2048 / 2, player.y);
			// Add visual effect for jump
			LK.effects.flashObject(player, 0xFFFFFF, 100); // Flash white for 100ms
			// Add enhanced particle effect for jump
			for (var i = 0; i < 10; i++) {
				var jumpParticle = LK.getAsset('dust', {
					anchorX: 0.5,
					anchorY: 0.5,
					x: player.x + Math.random() * 100 - 50,
					y: player.y + Math.random() * 100 - 50
				});
				game.addChild(jumpParticle);
				tween(jumpParticle, {
					alpha: 0,
					x: jumpParticle.x + Math.random() * 200 - 100,
					y: jumpParticle.y - Math.random() * 200
				}, {
					duration: 500,
					onFinish: function onFinish() {
						jumpParticle.destroy();
					}
				});
			}
			tween(player, {
				y: player.y - 600 // Increased jump height
			}, {
				duration: 500,
				//{3p} // Slower jump speed
				easing: tween.easeOut,
				onFinish: function onFinish() {
					// Fall down
					tween(player, {
						y: 2732 - 250 // Back to ground level
					}, {
						duration: 300,
						easing: tween.bounceOut,
						onFinish: function onFinish() {
							// Update playerState to 'landing'
							playerState = 'landing';
							// Add visual effect for landing
							LK.effects.flashObject(player, 0xFFFFFF, 100); // Flash white for 100ms
							// Add enhanced particle effect for landing
							for (var i = 0; i < 10; i++) {
								var landParticle = LK.getAsset('dust', {
									anchorX: 0.5,
									anchorY: 0.5,
									x: player.x + Math.random() * 100 - 50,
									y: player.y + Math.random() * 100 - 50
								});
								game.addChild(landParticle);
								tween(landParticle, {
									alpha: 0,
									x: landParticle.x + Math.random() * 200 - 100,
									y: landParticle.y + Math.random() * 200
								}, {
									duration: 500,
									onFinish: function onFinish() {
										landParticle.destroy();
									}
								});
							}
							// Revert back to player_idle image
							player.destroy();
							player = LK.getAsset('player_idle', {
								anchorX: 0.5,
								anchorY: 0.5,
								x: 2048 / 2,
								y: 2732 - 250
							});
							game.addChild(player);
							isJumping = false;
							// Reset playerState to 'idle' after landing
							playerState = 'idle';
						}
					});
				}
			});
		}
		return; // Exit so we don’t trigger attack when jumping
	}
	// Set the sequence running flag to true
	isSequenceRunning = true;
	// Function to swap the player's visual
	function swapPlayerVisual(newVisualId, x, y) {
		// Destroy the current player visual if it exists
		if (player) {
			player.destroy();
		}
		// Create a new player visual
		player = LK.getAsset(newVisualId, {
			anchorX: 0.5,
			anchorY: 0.5,
			x: x,
			y: y
		});
		game.addChild(player);
		// Attach jumpcol to the bottom of player_jump
		if (newVisualId === 'player_jump') {
			var jumpCol = LK.getAsset('jumpcol', {
				anchorX: 0.5,
				anchorY: 0.5,
				x: x,
				y: y + player.height / 2
			});
			jumpCol.alpha = 0;
			game.addChild(jumpCol);
			// Ensure jumpcol follows the player during the jump animation
			tween(jumpCol, {
				y: jumpCol.y - 600 // Match the player's jump height
			}, {
				duration: 500,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					// Fall down with the player
					tween(jumpCol, {
						y: 2732 - 250 + player.height / 2 // Back to ground level
					}, {
						duration: 300,
						easing: tween.bounceOut,
						onFinish: function onFinish() {
							jumpCol.destroy(); // Clean up after landing
						}
					});
				}
			});
		}
	}
	// Destroy the player_idle asset if it exists
	if (player) {
		player.destroy();
		isPlayerIdleOnScreen = false;
	}
	// Determine if the click is on the left or right portion of the playspace
	var isLeftClick = x < 2048 / 2;
	// Create a new instance of the PlayerAttack class
	var playerAttack = new PlayerAttack();
	// Play the 'retroslash' sound
	LK.getSound('retroslash').play();
	// Flip the player visuals if clicked on the left portion
	if (isLeftClick) {
		playerAttack.scaleX = -1;
	}
	// Position the player_attackf01 asset at the same position as player_idle
	playerAttack.x = 2048 / 2;
	playerAttack.y = 2732 - 250; // Set player_attackf01 coordinates to match player_idle
	// Add the player_attackf01 asset to the game
	game.addChild(playerAttack);
	// After 0.15 seconds, replace player_attackf01 with player_attackf02
	LK.setTimeout(function () {
		// Destroy player_attackf01
		playerAttack.destroy();
		// Create a new instance of player_attackf02 at the same position as player_idle
		var playerAttack2 = LK.getAsset('player_attackf02', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: 2048 / 2,
			y: 2732 - 250 // Set player_attackf02 coordinates to match player_idle
		});
		// Instantiate attackcol over player_attackf02
		attackCol = LK.getAsset('attackcol', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: isLeftClick ? playerAttack2.x - 150 : playerAttack2.x + 150,
			y: playerAttack2.y
		});
		// Set attackCol invisible by adjusting its alpha property
		attackCol.alpha = 0;
		// Add attackCol to the game to ensure intersection checks are valid
		game.addChild(attackCol);
		// Flip the player visuals if clicked on the left portion for player_attackf02
		if (isLeftClick) {
			playerAttack2.scaleX = -1;
			attackCol.scaleX = -1;
		}
		// Add player_attackf02 to the game
		game.addChild(playerAttack2);
		// After 0.15 seconds, replace player_attackf02 with player_idle
		LK.setTimeout(function () {
			// Destroy player_attackf02
			playerAttack2.destroy();
			// Destroy attackCol when player_attackf02 is destroyed
			if (attackCol) {
				attackCol.destroy();
				attackCol = null;
			}
			// Remove existing player before spawning new idle version
			if (player && !player.destroyed) {
				player.destroy();
			}
			swapPlayerVisual('player_idle', 2048 / 2, 2732 - 250);
			isPlayerIdleOnScreen = true;
			// Define the breathing animation function
			var startBreathingAnimation = function startBreathingAnimation() {
				tween(player, {
					scaleX: 1.05,
					scaleY: 1.05
				}, {
					duration: 1000,
					easing: tween.easeInOut,
					onFinish: function onFinish() {
						tween(player, {
							scaleX: 1.0,
							scaleY: 1.0
						}, {
							duration: 1000,
							easing: tween.easeInOut,
							onFinish: startBreathingAnimation
						});
					}
				});
			};
			// Start the breathing animation
			startBreathingAnimation();
			// Simulate breathing with player_idle by scaling it up and down
			var startBreathingAnimation = function startBreathingAnimation() {
				tween(player, {
					scaleX: 1.05,
					scaleY: 1.05
				}, {
					duration: 1000,
					easing: tween.easeInOut,
					onFinish: function onFinish() {
						tween(player, {
							scaleX: 1.0,
							scaleY: 1.0
						}, {
							duration: 1000,
							easing: tween.easeInOut,
							onFinish: startBreathingAnimation
						});
					}
				});
			};
			startBreathingAnimation();
			// Set the sequence running flag to false
			isSequenceRunning = false;
			isPlayerIdleOnScreen = true;
		}, 250);
	}, 250);
};

===================================================================
--- original.js
+++ change.js
@@ -372,11 +372,11 @@
 	petals[i].update();
 }
 // Mouse or touch down on the game object
 game.down = function (x, y, obj) {
-	// Check if the sequence is already running or if the player is jumping
-	if (isSequenceRunning || playerState === 'jumping') {
-		return; // Exit if the sequence is already running or if the player is jumping
+	// Check if the sequence is already running or if the player is jumping or landing
+	if (isSequenceRunning || playerState === 'jumping' || playerState === 'landing') {
+		return; // Exit if the sequence is already running or if the player is jumping or landing
 	}
 	// Check if the tap is in the upper 2/3 of the screen
 	if (y < 2732 * 2 / 3) {
 		// Prevent multiple jumps
@@ -421,8 +421,10 @@
 					}, {
 						duration: 300,
 						easing: tween.bounceOut,
 						onFinish: function onFinish() {
+							// Update playerState to 'landing'
+							playerState = 'landing';
 							// Add visual effect for landing
 							LK.effects.flashObject(player, 0xFFFFFF, 100); // Flash white for 100ms
 							// Add enhanced particle effect for landing
 							for (var i = 0; i < 10; i++) {
@@ -453,8 +455,10 @@
 								y: 2732 - 250
 							});
 							game.addChild(player);
 							isJumping = false;
+							// Reset playerState to 'idle' after landing
+							playerState = 'idle';
 						}
 					});
 				}
 			});