/**** 
* Classes
****/
var Intro = Container.expand(function () {
	var self = Container.call(this);
	var introGraphics = self.attachAsset('intro', {
		anchorX: 0.5,
		anchorY: 1
	});
	self.x = 2048 / 2;
	self.y = 2732 - 450;
	self.show = function () {
		self.visible = true;
		LK.setTimeout(function () {
			self.visible = false;
		}, 3000);
	};
	self.show();
});
var Arrow = Container.expand(function () {
	var self = Container.call(this);
	var arrowGraphics = self.attachAsset('arrow', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0.3
	});
	self.setPosition = function (x, y) {
		self.x = x;
		self.y = y;
	};
	self.show = function () {
		self.visible = true;
		LK.setTimeout(function () {
			self.visible = false;
		}, 3000);
	};
});
// FenceLayer class
var FenceLayer = Container.expand(function () {
	var self = Container.call(this);
	self.fenceInstances = [];
	self.addFenceRow = function () {
		var fenceWidth = LK.getAsset('fence', {}).width;
		var totalFenceWidth = fenceWidth * Math.floor(2048 / fenceWidth);
		var spaceWidth = 2048 - totalFenceWidth;
		var spaceIndex = Math.floor(2048 / fenceWidth / 2);
		// Counter for the number of fence rows passed
		self.fenceRowCount = (self.fenceRowCount || 0) + 1;
		// Shorten the empty space in the center after 5 rows
		var spaceReduction = self.fenceRowCount > 5 ? 100 : 0;
		for (var i = 0; i < spaceIndex * 2 + 1; i++) {
			if (i < spaceIndex - 3 + spaceReduction || i > spaceIndex + 3 - spaceReduction) {
				var fence = new Fence();
				var positionX = i * fenceWidth + spaceWidth / 2;
				fence.setPosition(positionX, -fence.height);
				self.addChild(fence);
				self.fenceInstances.push(fence);
			}
		}
	};
	self.moveFences = function () {
		for (var i = self.fenceInstances.length - 1; i >= 0; i--) {
			var fence = self.fenceInstances[i];
			fence.y += 4; // Move down at the same speed as grass
			if (fence.y > 2732) {
				self.removeChild(fence);
				self.fenceInstances.splice(i, 1);
			}
		}
	};
	self.scheduleNextFenceRow = function () {
		var minInterval = 3000; // Minimum 3 seconds before a new row can appear
		var maxInterval = 7000; // Maximum 7 seconds before a new row can appear
		var interval = Math.random() * (maxInterval - minInterval) + minInterval;
		LK.setTimeout(function () {
			if (self.fenceInstances.length === 0) {
				self.addFenceRow();
			}
			self.scheduleNextFenceRow();
		}, interval);
	};
	self.scheduleNextFenceRow();
});
// Sheep class
var Sheep = Container.expand(function () {
	var self = Container.call(this);
	var sheepGraphics = self.attachAsset('sheep', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 2;
	self.direction = Math.random() * Math.PI * 2;
	self.move = function () {
		var deltaX = Math.cos(self.direction) * self.speed;
		var deltaY = Math.sin(self.direction) * self.speed;
		self.x += deltaX;
		self.y += deltaY;
		if (deltaX > 0) {
			self.rotation = 5 * (Math.PI / 180);
		} else if (deltaX < 0) {
			self.rotation = -5 * (Math.PI / 180);
		}
	};
	self.avoidWalls = function () {
		if (self.x < 300 || self.x > 1748 || self.y < 300 || self.y > 2432) {
			self.direction += Math.PI;
		}
	};
	self.avoidDog = function (dog, targetPosition) {
		if (self.intersects(dog)) {
			var dx = targetPosition.x - self.x;
			var dy = targetPosition.y - self.y;
			self.direction = Math.atan2(dy, dx);
		}
	};
	self.avoidSheep = function (sheepArray, stoneArray, fenceArray) {
		var personalSpace = 150; // Define a personal space radius for each sheep
		for (var i = 0; i < sheepArray.length; i++) {
			var otherSheep = sheepArray[i];
			if (self !== otherSheep) {
				var dx = otherSheep.x - self.x;
				var dy = otherSheep.y - self.y;
				var distance = Math.sqrt(dx * dx + dy * dy);
				if (distance < personalSpace) {
					var avoidanceForce = 1;
					var avoidanceAngle = Math.atan2(dy, dx) + Math.PI; // Opposite direction
					self.direction = avoidanceAngle;
					self.x += Math.cos(self.direction) * self.speed * avoidanceForce;
					self.y += Math.sin(self.direction) * self.speed * avoidanceForce;
				}
			}
		}
		// Avoid stones
		for (var j = 0; j < stoneArray.length; j++) {
			var stone = stoneArray[j];
			var dx = stone.x - self.x;
			var dy = stone.y - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance < personalSpace) {
				var avoidanceForce = 1;
				var avoidanceAngle = Math.atan2(dy, dx) + Math.PI; // Opposite direction
				self.direction = avoidanceAngle;
				self.x += Math.cos(self.direction) * self.speed * avoidanceForce;
				self.y += Math.sin(self.direction) * self.speed * avoidanceForce;
			}
		}
		// Avoid fences
		for (var k = 0; k < fenceArray.length; k++) {
			var fence = fenceArray[k];
			var dx = fence.x - self.x;
			var dy = fence.y - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance < personalSpace) {
				var avoidanceForce = 1;
				var avoidanceAngle = Math.atan2(dy, dx) + Math.PI; // Opposite direction
				self.direction = avoidanceAngle;
				self.x += Math.cos(self.direction) * self.speed * avoidanceForce;
				self.y += Math.sin(self.direction) * self.speed * avoidanceForce;
			}
		}
	};
});
// Baa class
var Baa = Container.expand(function () {
	var self = Container.call(this);
	var baaGraphics = self.attachAsset('baa', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.visible = false;
	self.currentSheep = null;
	self.show = function (sheep) {
		if (!self.currentSheep) {
			self.currentSheep = [];
		}
		self.currentSheep.push(sheep);
		self.visible = true;
		LK.setTimeout(function () {
			self.currentSheep.splice(self.currentSheep.indexOf(sheep), 1);
			if (self.currentSheep.length === 0) {
				self.visible = false;
			}
		}, 1000);
	};
	self.tick = function () {
		if (self.visible && self.currentSheep && self.currentSheep.length > 0) {
			for (var i = 0; i < self.currentSheep.length; i++) {
				var sheep = self.currentSheep[i];
				self.x = sheep.x;
				self.y = sheep.y - sheep.height / 2 - self.height / 2;
			}
		}
	};
});
// Shepherd dog class with two states
var Dog = Container.expand(function () {
	var self = Container.call(this);
	var dogGraphics = self.attachAsset('dog', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var dog2Graphics = self.attachAsset('dog2', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	dog2Graphics.visible = false; // Initially hide the dog2
	self.targetPosition = {
		x: 1024,
		y: 1366
	}; // Default target position in the middle
	self.move = function (pos, lastPos) {
		self.x = pos.x;
		self.y = pos.y;
		if (pos.x > lastPos.x) {
			dogGraphics.visible = true;
			dog2Graphics.visible = false;
		} else if (pos.x < lastPos.x) {
			dogGraphics.visible = false;
			dog2Graphics.visible = true;
		}
	};
	self.lastPos = {
		x: self.x,
		y: self.y
	}; // Store the last position
	self.setTargetPosition = function (pos) {
		self.targetPosition = pos;
	};
});
// GrassLayer class
var GrassLayer = Container.expand(function () {
	var self = Container.call(this);
	GrassLayer.prototype.addGrassWithLimitedNumber = function () {
		var interval = 1000; // Interval of 1 second
		LK.setInterval(function () {
			if (self.grassInstances.length < 20) {
				self.addGrass();
			}
			if (self.stoneInstances.length < 3) {
				self.addStone();
			}
		}, interval);
	};
	self.stoneInstances = [];
	self.addStone = function () {
		var stone = new Stone();
		self.addChild(stone);
		self.stoneInstances.push(stone);
		self.avoidStoneGrassCollision(stone);
	};
	self.avoidStoneGrassCollision = function (stone) {
		for (var i = 0; i < self.grassInstances.length; i++) {
			var grass = self.grassInstances[i];
			if (stone.intersects(grass)) {
				stone.resetPosition();
				i = -1; // Restart the loop to check for collisions again
			}
		}
	};
	self.moveStones = function () {
		for (var j = 0; j < self.stoneInstances.length; j++) {
			self.stoneInstances[j].move();
		}
	};
	self.grassInstances = [];
	self.addGrass = function () {
		var grass = new Grass();
		self.addChild(grass);
		self.grassInstances.push(grass);
		self.avoidGrassStoneCollision(grass);
	};
	self.avoidGrassStoneCollision = function (grass) {
		for (var i = 0; i < self.stoneInstances.length; i++) {
			var stone = self.stoneInstances[i];
			if (grass.intersects(stone)) {
				grass.resetPosition();
				i = -1; // Restart the loop to check for collisions again
			}
		}
	};
	self.moveGrass = function () {
		for (var j = 0; j < self.grassInstances.length; j++) {
			self.grassInstances[j].move();
		}
	};
	self.addGrassWithUniformInterval = function () {
		self.addGrass();
		var interval = 1000; // Uniform interval of 1 second
		LK.setInterval(self.addGrass, interval);
	};
	self.addGrassWithLimitedNumber(); // Initialize the process with a limited number of grass instances
});
// Grass class
var Grass = Container.expand(function () {
	var self = Container.call(this);
	var grassGraphics = self.attachAsset('grass', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.resetPosition = function () {
		self.x = Math.random() * 2048;
		self.y = -self.height;
	};
	self.move = function () {
		self.y += 4; // Move down at a constant speed
		// Check for collision with any fence
		for (var i = 0; i < fenceLayer.fenceInstances.length; i++) {
			if (self.intersects(fenceLayer.fenceInstances[i])) {
				self.destroy(); // Destroy the grass
				return; // Exit the function to prevent further movement
			}
		}
		if (self.y > 2732) {
			// If grass is below the screen
			self.resetPosition(); // Reset to the top
		}
	};
	self.resetPosition(); // Initialize position
});
// Stone class
var Stone = Container.expand(function () {
	var self = Container.call(this);
	var stoneGraphics = self.attachAsset('rock', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.resetPosition = function () {
		self.x = Math.random() * 2048;
		self.y = -self.height;
	};
	self.move = function () {
		self.y += 4; // Move down at the same speed as grass
		// Check for collision with any fence
		for (var i = 0; i < fenceLayer.fenceInstances.length; i++) {
			if (self.intersects(fenceLayer.fenceInstances[i])) {
				self.destroy(); // Destroy the stone
				return; // Exit the function to prevent further movement
			}
		}
		if (self.y > 2732) {
			// If stone is below the screen
			self.resetPosition(); // Reset to the top
		}
	};
	self.resetPosition(); // Initialize position
});
// Fence class
var Fence = Container.expand(function () {
	var self = Container.call(this);
	var fenceGraphics = self.attachAsset('fence', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.setPosition = function (x, y) {
		self.x = x;
		self.y = y;
	};
});
// Mouse class
var Mouse = Container.expand(function () {
	var self = Container.call(this);
	var mouseGraphics = self.attachAsset('mouse', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.setPosition = function (x, y) {
		self.x = x;
		self.y = y;
	};
	self.show = function () {
		self.visible = true;
		LK.setTimeout(function () {
			self.visible = false;
		}, 3000);
	};
});
// Instructions class
var Instructions = Container.expand(function () {
	var self = Container.call(this);
	var instructionsText = new Text2('Use circular mouse movements to gather the sheep into a flock', {
		size: 70,
		fill: "#ffffff",
		align: 'center'
	});
	self.addChild(instructionsText);
	instructionsText.anchor.set(0.5, 1);
	instructionsText.x = 2048 / 2;
	instructionsText.y = 2732 - 200;
	self.show = function () {
		self.visible = true;
		LK.setTimeout(function () {
			self.visible = false;
		}, 4000);
	};
});

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

/**** 
* Game Code
****/
var instructions = game.addChild(new Instructions());
instructions.show();
// Initialize and display the Arrow
// Intro instance creation moved below Sheep instances
// Arrow instance creation moved below Sheep instances
// Initialize and display the Mouse
// Mouse instance creation moved below Sheep instances
// Initialize grass layer and add it to the game
var grassLayer = game.addChild(new GrassLayer());
// Initialize fence layer and add it to the game
var fenceLayer = game.addChild(new FenceLayer());
// Initialize sheep array
// Sheep asset
// Shepherd dog asset
var sheepArray = []; // Place fences in a line across the screen with a space in the center
// Create 20 sheep and add them to the game and sheepArray
for (var i = 0; i < 20; i++) {
	var sheep = new Sheep();
	sheep.x = 300 + Math.random() * (2048 - 600);
	sheep.y = 300 + Math.random() * (2732 - 600);
	game.addChild(sheep);
	sheepArray.push(sheep);
} // Create Intro, Arrow, and Mouse instances to appear above the sheep layer
var intro = game.addChild(new Intro());
var arrow = new Arrow();
arrow.setPosition(2048 / 2, 2732 - arrow.height / 2 - 300);
game.addChild(arrow);
arrow.show();
var mouse = new Mouse();
mouse.setPosition(2048 / 2, 2732 - mouse.height / 2 - 300);
game.addChild(mouse);
mouse.show();
// Create shepherd dog and add it to the game
var shepherdDog = new Dog();
shepherdDog.x = 1024; // Start in the middle of the game area
shepherdDog.y = 1366;
game.addChild(shepherdDog);
// Event listener for touch move to move the shepherd dog and handle direction
game.on('move', function (obj) {
	var pos = obj.event.getLocalPosition(game);
	shepherdDog.move(pos, shepherdDog.lastPos);
	shepherdDog.lastPos = pos; // Update the last position
});
// Main game tick event
var baaInstance = game.addChild(new Baa());
LK.setInterval(function () {
	for (var i = 0; i < 3; i++) {
		var randomSheepIndex = Math.floor(Math.random() * sheepArray.length);
		var randomSheep = sheepArray[randomSheepIndex];
		baaInstance.show(randomSheep);
	}
}, 500);
LK.on('tick', function () {
	// Move each sheep, handle collisions, update Baa position, move grass instances, move stones, and move fences
	baaInstance.tick();
	grassLayer.moveGrass();
	grassLayer.moveStones(); // Move the stones
	fenceLayer.moveFences(); // Move the fences
	for (var i = sheepArray.length - 1; i >= 0; i--) {
		var sheep = sheepArray[i];
		sheep.move();
		sheep.avoidWalls();
		sheep.avoidDog(shepherdDog, shepherdDog.targetPosition);
		sheep.avoidSheep(sheepArray, grassLayer.stoneInstances, fenceLayer.fenceInstances);
		if (sheep.y > 2732) {
			game.removeChild(sheep);
			sheepArray.splice(i, 1);
		}
	}
	// Check if there are no sheep left and end the game if true
	if (sheepArray.length === 0) {
		LK.showGameOver();
	}
});
// Ensure the game is touchscreen compatible
game.on('down', function (obj) {
	var pos = obj.event.getLocalPosition(game);
	shepherdDog.setTargetPosition(pos);
	shepherdDog.move(pos, shepherdDog.lastPos);
	shepherdDog.lastPos = pos; // Update the last position
});
game.on('up', function (obj) {
	var pos = obj.event.getLocalPosition(game);
	shepherdDog.setTargetPosition(pos);
});

===================================================================
--- original.js
+++ change.js
@@ -38,25 +38,26 @@
 // FenceLayer class
 var FenceLayer = Container.expand(function () {
 	var self = Container.call(this);
 	self.fenceInstances = [];
-	self.fenceRowCount = 0;
 	self.addFenceRow = function () {
 		var fenceWidth = LK.getAsset('fence', {}).width;
 		var totalFenceWidth = fenceWidth * Math.floor(2048 / fenceWidth);
 		var spaceWidth = 2048 - totalFenceWidth;
 		var spaceIndex = Math.floor(2048 / fenceWidth / 2);
-		var spaceAdjustment = self.fenceRowCount >= 5 ? 1 : 0; // Adjust space after 5 rows
+		// Counter for the number of fence rows passed
+		self.fenceRowCount = (self.fenceRowCount || 0) + 1;
+		// Shorten the empty space in the center after 5 rows
+		var spaceReduction = self.fenceRowCount > 5 ? 100 : 0;
 		for (var i = 0; i < spaceIndex * 2 + 1; i++) {
-			if (i < spaceIndex - (3 + spaceAdjustment) || i > spaceIndex + (3 - spaceAdjustment)) {
+			if (i < spaceIndex - 3 + spaceReduction || i > spaceIndex + 3 - spaceReduction) {
 				var fence = new Fence();
 				var positionX = i * fenceWidth + spaceWidth / 2;
 				fence.setPosition(positionX, -fence.height);
 				self.addChild(fence);
 				self.fenceInstances.push(fence);
 			}
 		}
-		self.fenceRowCount++;
 	};
 	self.moveFences = function () {
 		for (var i = self.fenceInstances.length - 1; i >= 0; i--) {
 			var fence = self.fenceInstances[i];