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

/**** 
* Classes
****/ 
// Enemy class
var Enemy = Container.expand(function () {
	var self = Container.call(this);
	var gfx = self.attachAsset('enemy_dino', {
		anchorX: 0.5,
		anchorY: 1,
		scaleX: 2,
		scaleY: 2
	});
	self.vx = -2;
	self.visualWidth = gfx.width;
	self.visualHeight = gfx.height;
	self.lastX = 0;
	self.lastY = 0;
	self.update = function () {
		self.lastX = self.x;
		self.lastY = self.y;
		// Simple left-right movement
		self.x += self.vx;
	};
	return self;
});
// LevelGate class
var LevelGate = Container.expand(function () {
	var self = Container.call(this);
	var gfx = self.attachAsset('level_gate', {
		anchorX: 0.5,
		anchorY: 1,
		scaleX: 2,
		scaleY: 2
	});
	self.active = false;
	return self;
});
// Initialize player
// Meteor class
var Meteor = Container.expand(function () {
	var self = Container.call(this);
	var gfx = self.attachAsset('meteor', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.vy = 8;
	self.lastY = 0;
	self.update = function () {
		self.lastY = self.y;
		self.y += self.vy;
	};
	return self;
});
// Mushroom class
var Mushroom = Container.expand(function () {
	var self = Container.call(this);
	var gfx = self.attachAsset('mushroom', {
		anchorX: 0.5,
		anchorY: 1,
		scaleX: 1,
		scaleY: 1
	});
	self.collected = false;
	return self;
});
// Platform class
var Platform = Container.expand(function () {
	var self = Container.call(this);
	var gfx = self.attachAsset('platform', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	return self;
});
// Player class
var Player = Container.expand(function () {
	var self = Container.call(this);
	var gfx = self.attachAsset('dino_player', {
		anchorX: 0.5,
		anchorY: 1,
		scaleX: 2,
		scaleY: 2
	});
	self.vx = 0;
	self.vy = 0;
	self.isJumping = false;
	self.lastX = 0;
	self.lastY = 0;
	self.update = function () {
		self.lastX = self.x;
		self.lastY = self.y;
		// Rotate player to face direction of movement
		if (self.vx > 0) {
			// Face right
			if (gfx.scaleX < 0) {
				gfx.scaleX = Math.abs(gfx.scaleX);
			}
		} else if (self.vx < 0) {
			// Face left (flip horizontally)
			if (gfx.scaleX > 0) {
				gfx.scaleX = -Math.abs(gfx.scaleX);
			}
		}
		// Movement and gravity will be handled in game.update
		// Player position is updated in game.update, so nothing to do here
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Play background music at game start
LK.playMusic('musicId');
// Import tween plugin for animations
// Global game objects and state
var player = null;
var platforms = [];
var mushrooms = [];
var enemies = [];
var meteors = [];
var levelGate = null;
var score = 0;
var mushroomsToNextLevel = 10;
var canLevelUp = false;
// Enemy spawning variables
var ENEMY_SPAWN_INTERVAL_MIN_TICKS = 360; // Approx 6 seconds at 60 FPS
var ENEMY_SPAWN_INTERVAL_MAX_TICKS = 600; // Approx 10 seconds at 60 FPS
var MAX_ENEMIES_ON_SCREEN = 3;
var nextEnemySpawnTick = ENEMY_SPAWN_INTERVAL_MIN_TICKS; // Time for the first enemy spawn
// Initialize player
player = new Player();
player.x = 300;
player.y = 2200;
// Create a seamless row of platforms spanning the screen horizontally
var platformAsset = LK.getAsset('platform', {
	anchorX: 0.5,
	anchorY: 0.5
});
var platformWidth = platformAsset.width;
var yBase = 2300;
for (var px = 0; px < 2048; px += platformWidth) {
	var plat = new Platform();
	plat.x = px + platformWidth / 2;
	plat.y = yBase;
	game.addChild(plat);
	platforms.push(plat);
}
// Add player after platforms so player is in front of platforms
game.addChild(player);
// Mushrooms will now spawn dynamically with platforms
// Enemies will now spawn dynamically
// Example meteor (will be dropped randomly in game.update)
// Touch controls
var jumpQueued = false;
var isTouching = false;
var swipeThreshold = 80;
// New variables for revised touch/swipe logic
var touchStartX = 0;
var touchStartY = 0;
var touchStartTimeTicks = 0;
var verticalSwipeForJumpRegistered = false;
var playerMovementDirection = 0; // -1 for left, 0 for still, 1 for right
// Track both horizontal touch and swipe for jump independently
game.down = function (x, y, obj) {
	isTouching = true;
	touchStartX = x;
	touchStartY = y;
	touchStartTimeTicks = LK.ticks;
	verticalSwipeForJumpRegistered = false;
	playerMovementDirection = 0; // Reset direction, will be set by game.move
};
game.move = function (x, y, obj) {
	if (isTouching) {
		// Detect upward swipe for jump
		// Only allow one jump per upward swipe gesture
		if (!verticalSwipeForJumpRegistered && touchStartY - y > swipeThreshold && player.jumpCount < 0.5) {
			jumpQueued = true;
			verticalSwipeForJumpRegistered = true;
			// Reduce jump power by half for swipe jump
			player._swipeJump = true;
		}
		// Update player movement direction based on horizontal swipe
		if (x > player.x + 10) {
			playerMovementDirection = 1; // right
		} else if (x < player.x - 10) {
			playerMovementDirection = -1; // left
		} else {
			playerMovementDirection = 0; // still
		}
	}
};
game.up = function (x, y, obj) {
	if (isTouching) {
		// Ensure this logic runs only once per touch end
		var tapDurationTicks = LK.ticks - touchStartTimeTicks;
		var dx = x - touchStartX;
		var dy = y - touchStartY;
		var tapDistance = Math.sqrt(dx * dx + dy * dy);
		var maxTapDurationTicks = 15; // Approx 250ms at 60fps
		var maxTapDistance = swipeThreshold * 0.75; // Allow some small movement for a tap
		if (!verticalSwipeForJumpRegistered && tapDurationTicks < maxTapDurationTicks && tapDistance < maxTapDistance && player.jumpCount < 0.5) {
			jumpQueued = true;
			player._swipeJump = false; // Full power jump for tap
		}
		isTouching = false;
		playerMovementDirection = 0; // Stop player movement when touch is released
		// verticalSwipeForJumpRegistered is reset on next game.down
	}
};
game.update = function () {
	// Player movement
	var speed = 16;
	var gravity = 7.5; // Softer gravity for more natural jump arc
	var jumpPower = -90; // Jump power
	var maxFallSpeed = 60; // Terminal velocity
	// Horizontal movement based on swipe direction
	if (isTouching && playerMovementDirection === 1) {
		player.vx = speed;
	} else if (isTouching && playerMovementDirection === -1) {
		player.vx = -speed;
	} else {
		player.vx = 0;
	}
	player.x += player.vx;
	// Prevent player from moving outside the left and right screen boundaries
	var playerHalfWidth = player.width ? player.width / 2 : 50;
	if (player.x - playerHalfWidth < 0) {
		player.x = playerHalfWidth;
	}
	if (player.x + playerHalfWidth > 2048) {
		player.x = 2048 - playerHalfWidth;
	}
	// --- Clean, Natural Jump Physics ---
	// Track jump state
	if (typeof player.jumpCount === "undefined") {
		player.jumpCount = 0;
	}
	if (typeof player.isJumping === "undefined") {
		player.isJumping = false;
	}
	if (typeof player.wasOnGround === "undefined") {
		player.wasOnGround = false;
	}
	if (typeof player.wasOnPlatform === "undefined") {
		player.wasOnPlatform = false;
	}
	// Detect platform and ground contact (for landing)
	var onPlatform = false;
	var onGround = false;
	var platformY = null;
	for (var i = 0; i < platforms.length; i++) {
		var plat = platforms[i];
		// Check if player feet cross platform top (falling)
		var platTop = plat.y - plat.height / 2;
		var playerFeetLast = player.lastY + 10;
		var playerFeetNow = player.y + 10;
		if (playerFeetLast <= platTop && playerFeetNow >= platTop && player.x > plat.x - plat.width / 2 && player.x < plat.x + plat.width / 2 && player.vy >= 0) {
			onPlatform = true;
			platformY = platTop - 10;
			break;
		}
	}
	if (player.lastY < 2300 && player.y >= 2300) {
		onGround = true;
	}
	// Reset jump count and state if landed
	if ((onPlatform || onGround) && player.vy >= 0) {
		player.jumpCount = 0;
		player.isJumping = false;
	}
	// Allow jump if jumpQueued and jumpCount < 0.5 (half the previous max, disables double jump)
	if (jumpQueued && player.jumpCount < 0.5) {
		if (player._swipeJump) {
			player.vy = jumpPower / 2;
			player._swipeJump = false;
		} else {
			player.vy = jumpPower;
		}
		player.isJumping = true;
		player.jumpCount = 0.5; // Always set to 0.5, never allow more than 0.5 jumps
		jumpQueued = false;
	}
	// Variable jump height: if player releases touch while rising, cut jump short
	if (!isTouching && player.vy < 0) {
		player.vy += gravity * 1.2; // Slightly faster fall if jump released early
	}
	// Gravity: smooth, natural arc
	if (player.vy < 0) {
		// Rising: gentle gravity for floaty apex
		player.vy += gravity * 0.18;
	} else {
		// Falling: normal gravity
		player.vy += gravity;
	}
	if (player.vy > maxFallSpeed) {
		player.vy = maxFallSpeed;
	}
	// Apply vertical movement
	player.y += player.vy;
	// Snap to platform if landed
	if (onPlatform) {
		player.y = platformY;
		player.vy = 0;
		player.isJumping = false;
		player.jumpCount = 0;
	}
	// Snap to ground if landed
	if (player.y > 2300) {
		player.y = 2300;
		player.vy = 0;
		player.isJumping = false;
		player.jumpCount = 0;
	}
	// Update player lastX/lastY for event logic
	player.update();
	// Mushroom collection
	for (var i = 0; i < mushrooms.length; i++) {
		var mush = mushrooms[i];
		if (!mush.collected && player.intersects(mush)) {
			mush.collected = true;
			mush.visible = false;
			// Delay the collect effects and score increment
			LK.setTimeout(function () {
				score += 1;
				// Play collect sound (elma ısırma sesi)
				LK.getSound('collect').play();
				// Flash whole screen white for 350ms
				LK.effects.flashScreen(0xffffff, 350);
				if (score >= mushroomsToNextLevel) {
					canLevelUp = true;
					if (levelGate) {
						levelGate.active = true;
					}
				}
			}, 100); // shorter delay before collect effects
		}
	}
	// Enemy Spawning Logic
	if (LK.ticks >= nextEnemySpawnTick && enemies.length < MAX_ENEMIES_ON_SCREEN) {
		var newEnemy = new Enemy();
		// Spawn off-screen to the right. visualWidth is set in Enemy class constructor.
		newEnemy.x = 2048 + newEnemy.visualWidth / 2 + 50; // Start a bit further off-screen
		newEnemy.y = 2300; // Ground level (consistent with player and platform base)
		// Add enemy behind player but in front of far background elements if any.
		// Find player's index or add it generally if z-ordering isn't complex.
		// For now, let's add it generally. If z-order issues arise, we can refine.
		game.addChild(newEnemy);
		enemies.push(newEnemy);
		// Schedule next enemy spawn
		var spawnInterval = ENEMY_SPAWN_INTERVAL_MIN_TICKS + Math.random() * (ENEMY_SPAWN_INTERVAL_MAX_TICKS - ENEMY_SPAWN_INTERVAL_MIN_TICKS);
		nextEnemySpawnTick = LK.ticks + Math.floor(spawnInterval);
	}
	// Enemy Update, Collision, and Despawning
	for (var i = enemies.length - 1; i >= 0; i--) {
		// Iterate backwards for safe removal
		var enemy = enemies[i];
		enemy.update(); // Handles enemy movement
		// Despawn if off-screen to the left
		// Ensure enemy.visualWidth is available and correctly represents scaled width
		if (enemy.x + enemy.visualWidth / 2 < leftEdge) {
			enemy.destroy();
			enemies.splice(i, 1);
			continue; // Skip further checks for this removed enemy
		}
		// Collision with player
		if (player.intersects(enemy)) {
			LK.getSound('warn').play();
			LK.effects.flashScreen(0xff0000, 1000);
			LK.showGameOver();
			return; // Exit game.update early on game over
		}
	}
	// Define edges for element removal and spawning trigger
	var rightEdge = 2048; // Right edge of the screen
	var spawnTriggerEdge = 2048 + 200; // Start spawning new platforms when the rightmost is beyond the screen edge
	var leftEdge = -200; // Left edge for despawning elements
	// Get asset dimensions for positioning. These calls are lightweight.
	var platformAsset = LK.getAsset('platform', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var platformWidth = platformAsset.width;
	var platformHeight = platformAsset.height;
	var mushroomAsset = LK.getAsset('mushroom', {
		anchorX: 0.5,
		anchorY: 1
	}); // anchorY:1 for bottom
	var mushroomHeight = mushroomAsset.height;
	// Move existing platforms
	var platformMoveSpeed = 3; // Platforms are now slower
	for (var i = platforms.length - 1; i >= 0; i--) {
		var plat = platforms[i];
		plat.x -= platformMoveSpeed;
		if (plat.x + platformWidth / 2 < leftEdge) {
			// Check if entire platform is off-screen
			plat.destroy();
			platforms.splice(i, 1);
		}
	}
	// Move existing mushrooms
	for (var i = mushrooms.length - 1; i >= 0; i--) {
		var mush = mushrooms[i];
		if (mush.collected) continue; // Already collected, will be invisible
		mush.x -= platformMoveSpeed;
		if (mush.x + mushroomAsset.width / 2 < leftEdge) {
			// Using mushroomAsset.width for consistency
			mush.destroy();
			mushrooms.splice(i, 1);
		}
	}
	// Move existing level gate
	if (levelGate) {
		levelGate.x -= platformMoveSpeed;
		var levelGateAsset = LK.getAsset('level_gate', {
			anchorX: 0.5,
			anchorY: 1
		}); // anchorY:1 for bottom
		if (levelGate.x + levelGateAsset.width / 2 < leftEdge) {
			levelGate.destroy();
			levelGate = null; // Allow a new one to spawn if conditions met again
		}
	}
	// Find the rightmost platform's x position (its right edge)
	var rightmostPlatformEdge = 0; // Default to 0 if no platforms exist
	if (platforms.length > 0) {
		var currentRightmostX = -Infinity;
		for (var i = 0; i < platforms.length; i++) {
			if (platforms[i].x > currentRightmostX) {
				currentRightmostX = platforms[i].x;
			}
		}
		rightmostPlatformEdge = currentRightmostX + platformWidth / 2;
	}
	// Mushroom spawn control variables (persist across calls)
	if (typeof game._mushroomNextX === "undefined") {
		game._mushroomNextX = 0;
	}
	var mushroomHorizontalSpacing = 350 + Math.floor(Math.random() * 120); // 350-470px between mushrooms
	// Spawn new platforms if there's space on the right
	while (rightmostPlatformEdge < spawnTriggerEdge) {
		var newPlat = new Platform();
		newPlat.x = rightmostPlatformEdge === 0 ? platformWidth / 2 : rightmostPlatformEdge + platformWidth / 2;
		newPlat.y = 2300; // Base Y for platforms
		game.addChildAt(newPlat, 0); // Add new platforms at the back
		platforms.push(newPlat);
		rightmostPlatformEdge = newPlat.x + platformWidth / 2;
		var platformTopY = newPlat.y - platformHeight / 2;
		// Only spawn a mushroom if we've passed the next scheduled X
		if (newPlat.x >= game._mushroomNextX) {
			var mush = new Mushroom();
			mush.x = newPlat.x;
			// Get player height (scaled)
			var playerAsset = LK.getAsset('dino_player', {
				anchorX: 0.5,
				anchorY: 1,
				scaleX: 2,
				scaleY: 2
			});
			var playerHeight = playerAsset.height;
			// Always spawn at one of 3 levels: lowest is above player, each level spaced by player height
			var levelIndex = Math.floor(Math.random() * 3); // 0, 1, or 2
			var mushHeight = mushroomAsset.height;
			var yOffset = Math.random() * 20 - 10; // small random offset for variety
			mush.y = platformTopY - playerHeight - mushHeight / 2 - levelIndex * playerHeight + yOffset;
			game.addChild(mush); // Add mushroom on top of layers
			mushrooms.push(mush);
			// Schedule next mushroom X position
			game._mushroomNextX = newPlat.x + mushroomHorizontalSpacing + Math.floor(Math.random() * 120);
		}
		// Spawn level gate on this new platform if conditions are met and no gate exists
		if (canLevelUp && !levelGate) {
			levelGate = new LevelGate();
			levelGate.x = newPlat.x;
			levelGate.y = platformTopY; // Place bottom of the gate on the platform surface
			levelGate.active = true;
			game.addChild(levelGate); // Add gate on top of layers
		}
	}
	// Meteor drop (randomly every 120 ticks)
	if (LK.ticks % 120 === 0) {
		var meteor = new Meteor();
		meteor.x = 400 + Math.floor(Math.random() * 1200);
		meteor.y = -100;
		game.addChild(meteor);
		meteors.push(meteor);
	}
	// Meteor update and collision
	for (var i = meteors.length - 1; i >= 0; i--) {
		var meteor = meteors[i];
		meteor.update();
		if (player.intersects(meteor)) {
			LK.getSound('warn').play();
			LK.effects.flashScreen(0xff0000, 1000);
			LK.showGameOver();
			return;
		}
		if (meteor.y > 2800) {
			meteor.destroy();
			meteors.splice(i, 1);
		}
	}
	// Level gate will now spawn dynamically on a platform when canLevelUp is true
	if (levelGate && player.intersects(levelGate)) {
		// Check if levelGate exists before intersecting
		if (canLevelUp) {
			LK.showYouWin();
		} else {
			// Play warning sound
			LK.getSound('warn').play();
		}
	}
};
// Score display
var scoreTxt = new Text2('0', {
	size: 120,
	fill: "#fff"
});
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
// Update score display in game.update
var oldGameUpdate = game.update;
game.update = function () {
	scoreTxt.setText(score);
	oldGameUpdate();
};

===================================================================
--- original.js
+++ change.js
@@ -135,10 +135,10 @@
 var score = 0;
 var mushroomsToNextLevel = 10;
 var canLevelUp = false;
 // Enemy spawning variables
-var ENEMY_SPAWN_INTERVAL_MIN_TICKS = 180; // Approx 3 seconds at 60 FPS
-var ENEMY_SPAWN_INTERVAL_MAX_TICKS = 300; // Approx 5 seconds at 60 FPS
+var ENEMY_SPAWN_INTERVAL_MIN_TICKS = 360; // Approx 6 seconds at 60 FPS
+var ENEMY_SPAWN_INTERVAL_MAX_TICKS = 600; // Approx 10 seconds at 60 FPS
 var MAX_ENEMIES_ON_SCREEN = 3;
 var nextEnemySpawnTick = ENEMY_SPAWN_INTERVAL_MIN_TICKS; // Time for the first enemy spawn
 // Initialize player
 player = new Player();
@@ -443,8 +443,13 @@
 			}
 		}
 		rightmostPlatformEdge = currentRightmostX + platformWidth / 2;
 	}
+	// Mushroom spawn control variables (persist across calls)
+	if (typeof game._mushroomNextX === "undefined") {
+		game._mushroomNextX = 0;
+	}
+	var mushroomHorizontalSpacing = 350 + Math.floor(Math.random() * 120); // 350-470px between mushrooms
 	// Spawn new platforms if there's space on the right
 	while (rightmostPlatformEdge < spawnTriggerEdge) {
 		var newPlat = new Platform();
 		newPlat.x = rightmostPlatformEdge === 0 ? platformWidth / 2 : rightmostPlatformEdge + platformWidth / 2;
@@ -452,11 +457,10 @@
 		game.addChildAt(newPlat, 0); // Add new platforms at the back
 		platforms.push(newPlat);
 		rightmostPlatformEdge = newPlat.x + platformWidth / 2;
 		var platformTopY = newPlat.y - platformHeight / 2;
-		// Chance to spawn a mushroom on this new platform
-		if (Math.random() < 0.25) {
-			// 25% chance for a mushroom
+		// Only spawn a mushroom if we've passed the next scheduled X
+		if (newPlat.x >= game._mushroomNextX) {
 			var mush = new Mushroom();
 			mush.x = newPlat.x;
 			// Get player height (scaled)
 			var playerAsset = LK.getAsset('dino_player', {
@@ -466,17 +470,16 @@
 				scaleY: 2
 			});
 			var playerHeight = playerAsset.height;
 			// Always spawn at one of 3 levels: lowest is above player, each level spaced by player height
-			// Level 0: just above player, Level 1: playerHeight above, Level 2: 2*playerHeight above
 			var levelIndex = Math.floor(Math.random() * 3); // 0, 1, or 2
-			// The base Y for lowest mushroom is platformTopY - playerHeight - (mushroomHeight/2)
-			// Each next level is playerHeight higher
 			var mushHeight = mushroomAsset.height;
 			var yOffset = Math.random() * 20 - 10; // small random offset for variety
 			mush.y = platformTopY - playerHeight - mushHeight / 2 - levelIndex * playerHeight + yOffset;
 			game.addChild(mush); // Add mushroom on top of layers
 			mushrooms.push(mush);
+			// Schedule next mushroom X position
+			game._mushroomNextX = newPlat.x + mushroomHorizontalSpacing + Math.floor(Math.random() * 120);
 		}
 		// Spawn level gate on this new platform if conditions are met and no gate exists
 		if (canLevelUp && !levelGate) {
 			levelGate = new LevelGate();