/**** 
* Classes
****/ 
var Cloud = Container.expand(function () {
	var self = Container.call(this);
	var cloudGraphics = self.attachAsset('cloud', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = Math.random() * 1 + 0.5; // Random speed between 0.5 and 1.5
	self.update = function () {
		self.x -= self.speed;
	};
	return self;
});
var Dinosaur = Container.expand(function () {
	var self = Container.call(this);
	var dinoGraphics = self.attachAsset('dino', {
		anchorX: 0.5,
		anchorY: 1.0
	});
	self.velocityY = 0;
	self.gravity = 1;
	self.jumpPower = -30;
	self.isGrounded = false;
	self.groundY = 0;
	self.jump = function () {
		if (self.isGrounded) {
			self.velocityY = self.jumpPower;
			self.isGrounded = false;
			LK.getSound('jump').play();
		}
	};
	self.update = function () {
		// Apply gravity
		self.velocityY += self.gravity;
		self.y += self.velocityY;
		// Check ground collision
		if (self.y >= self.groundY) {
			self.y = self.groundY;
			self.velocityY = 0;
			self.isGrounded = true;
		}
		// Check if fallen off screen (game over condition)
		if (self.y > 2732 + 100) {
			LK.showGameOver();
		}
	};
	return self;
});
var FlyingObstacle = Container.expand(function () {
	var self = Container.call(this);
	var flyingGraphics = self.attachAsset('flying_obstacle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.update = function () {
		self.x += -gameSpeed * 2;
	};
	return self;
});
var GroundTile = Container.expand(function () {
	var self = Container.call(this);
	var groundGraphics = self.attachAsset('ground', {
		anchorX: 0,
		anchorY: 0
	});
	self.update = function () {
		self.x += -gameSpeed;
	};
	return self;
});
var Obstacle = Container.expand(function (size) {
	var self = Container.call(this);
	// Determine which asset to use based on size parameter
	var assetId = size === 'large' ? 'obstacle_large' : 'obstacle_small';
	var obstacleGraphics = self.attachAsset(assetId, {
		anchorX: 0.5,
		anchorY: 1.0
	});
	self.size = size;
	self.update = function () {
		self.x += -gameSpeed;
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Game variables
var dinosaur;
var groundTiles = [];
var obstacles = [];
var flyingObstacle = null;
var flyingObstacleSpawnTimer = 0;
var flyingObstacleHeight = 2000; // Just above ground obstacles (flying obstacle height is 60)
var groundY = 2732 - 200; // Ground level
var gameSpeed = 6;
var distanceScore = 0;
var obstacleSpawnTimer = 0;
var minObstacleSpacing = 600;
var maxObstacles = 3;
var clouds = [];
var cloudSpawnTimer = 0;
// Create score display
var scoreTxt = new Text2('0', {
	size: 80,
	fill: 0x333333
});
scoreTxt.anchor.set(1, 0);
LK.gui.topRight.addChild(scoreTxt);
// Create dinosaur
dinosaur = game.addChild(new Dinosaur());
dinosaur.x = 400;
dinosaur.y = groundY;
dinosaur.groundY = groundY;
// Create initial ground tiles
function createGroundTile(x) {
	var tile = new GroundTile();
	tile.x = x;
	tile.y = groundY;
	return tile;
}
// Create obstacle function
function createObstacle(x) {
	var sizes = ['small', 'large'];
	var randomSize = sizes[Math.floor(Math.random() * sizes.length)];
	var obstacle = new Obstacle(randomSize);
	obstacle.x = x;
	obstacle.y = groundY;
	return obstacle;
}
// Create flying obstacle function
function createFlyingObstacle(x) {
	var obstacle = new FlyingObstacle();
	obstacle.x = x;
	obstacle.y = flyingObstacleHeight;
	return obstacle;
}
// Create cloud function
function createCloud(x, y) {
	var cloud = new Cloud();
	cloud.x = x;
	cloud.y = y;
	cloud.scaleX = 1; // Random scale between 0.6 and 1.4
	cloud.scaleY = 1;
	return cloud;
}
// Create initial ground tiles to cover screen width plus extra for scrolling
for (var i = 0; i < 15; i++) {
	var tile = game.addChild(createGroundTile(i * 200));
	groundTiles.push(tile);
}
// Create initial background clouds
for (var c = 0; c < 8; c++) {
	var cloudX = Math.random() * (2048 + 400) - 200; // Spread across screen width
	var cloudY = Math.random() * 800 + 200; // Upper portion of screen
	var cloud = game.addChild(createCloud(cloudX, cloudY));
	clouds.push(cloud);
}
// Game input handling
game.down = function (x, y, obj) {
	dinosaur.jump();
};
// Main game update loop
game.update = function () {
	// Update distance score
	distanceScore += gameSpeed;
	var displayScore = Math.floor(distanceScore / 10);
	LK.setScore(displayScore);
	scoreTxt.setText(displayScore);
	// Manage ground tiles
	for (var i = groundTiles.length - 1; i >= 0; i--) {
		var tile = groundTiles[i];
		// Remove tiles that have scrolled off screen
		if (tile.x < -250) {
			tile.destroy();
			groundTiles.splice(i, 1);
		}
	}
	// Add new ground tiles as needed
	var lastTile = groundTiles[groundTiles.length - 1];
	if (lastTile && lastTile.x + 200 < 2048 + 200) {
		var newTile = game.addChild(createGroundTile(lastTile.x + 200));
		groundTiles.push(newTile);
	}
	// Manage obstacles
	for (var k = obstacles.length - 1; k >= 0; k--) {
		var obstacle = obstacles[k];
		// Remove obstacles that have scrolled off screen
		if (obstacle.x < -200) {
			obstacle.destroy();
			obstacles.splice(k, 1);
		}
	}
	// Manage flying obstacle
	if (flyingObstacle) {
		// Remove flying obstacle if it's off screen
		if (flyingObstacle.x < -200) {
			flyingObstacle.destroy();
			flyingObstacle = null;
		}
	}
	// Spawn flying obstacle
	flyingObstacleSpawnTimer++;
	if (!flyingObstacle && flyingObstacleSpawnTimer > 300) {
		// Spawn every 5 seconds
		flyingObstacle = game.addChild(createFlyingObstacle(2048 + 100));
		flyingObstacleSpawnTimer = 0;
	}
	// Spawn new obstacles
	obstacleSpawnTimer++;
	var baseSpawnTime = 120; // Base spawn time (2 seconds at 60fps)
	var spawnVariation = 120; // ±2 second variation for more varied spacing
	var currentSpawnTime = baseSpawnTime + Math.floor(Math.random() * spawnVariation * 2) - spawnVariation;
	if (obstacles.length < maxObstacles && obstacleSpawnTimer > currentSpawnTime) {
		var canSpawn = true;
		var spawnX = 2048 + 200; // Spawn well off-screen to the right
		// Check if there's enough space from last obstacle
		if (obstacles.length > 0) {
			var lastObstacle = obstacles[obstacles.length - 1];
			if (lastObstacle.x > spawnX - 600) {
				// Ensure minimum 600px spacing
				canSpawn = false;
			}
		}
		if (canSpawn) {
			// Add random horizontal offset while maintaining minimum spacing
			var offsetRange = 100; // Reduced range to ensure proper spacing
			var horizontalOffset = Math.floor(Math.random() * offsetRange);
			var newObstacle = game.addChild(createObstacle(spawnX + horizontalOffset));
			obstacles.push(newObstacle);
			// Reset timer with additional random offset for next spawn
			obstacleSpawnTimer = -Math.floor(Math.random() * 60); // Start next timer with up to 1 second head start
		}
	}
	// Collision detection with ground obstacles
	for (var o = 0; o < obstacles.length; o++) {
		var obstacle = obstacles[o];
		if (dinosaur.intersects(obstacle)) {
			LK.showGameOver();
			return; // Stop processing other collisions
		}
	}
	// Collision detection with flying obstacle
	if (flyingObstacle && dinosaur.intersects(flyingObstacle)) {
		LK.showGameOver();
		return; // Stop processing other collisions
	}
	// Gradually increase game speed for difficulty progression
	if (LK.ticks % 600 === 0) {
		// Every 10 seconds at 60fps
		gameSpeed += 0.5;
		for (var j = 0; j < groundTiles.length; j++) {
			groundTiles[j].scrollSpeed = -gameSpeed;
		}
	}
	// Manage clouds
	for (var c = clouds.length - 1; c >= 0; c--) {
		var cloud = clouds[c];
		// Remove clouds that have scrolled off screen
		if (cloud.x < -200) {
			cloud.destroy();
			clouds.splice(c, 1);
		}
	}
	// Spawn new clouds
	cloudSpawnTimer++;
	if (cloudSpawnTimer > 180) {
		// Spawn new cloud every 3 seconds
		var cloudY = Math.random() * 800 + 200; // Upper portion of screen
		var newCloud = game.addChild(createCloud(2048 + 150, cloudY));
		clouds.push(newCloud);
		cloudSpawnTimer = 0;
	}
};

===================================================================
--- original.js
+++ change.js
@@ -105,9 +105,9 @@
 var groundY = 2732 - 200; // Ground level
 var gameSpeed = 6;
 var distanceScore = 0;
 var obstacleSpawnTimer = 0;
-var minObstacleSpacing = 360;
+var minObstacleSpacing = 600;
 var maxObstacles = 3;
 var clouds = [];
 var cloudSpawnTimer = 0;
 // Create score display
@@ -226,10 +226,10 @@
 		var spawnX = 2048 + 200; // Spawn well off-screen to the right
 		// Check if there's enough space from last obstacle
 		if (obstacles.length > 0) {
 			var lastObstacle = obstacles[obstacles.length - 1];
-			if (lastObstacle.x > spawnX - 360) {
-				// Ensure minimum 360px spacing
+			if (lastObstacle.x > spawnX - 600) {
+				// Ensure minimum 600px spacing
 				canSpawn = false;
 			}
 		}
 		if (canSpawn) {