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

/**** 
* Classes
****/ 
var Dog = Container.expand(function () {
	var self = Container.call(this);
	var dogGraphics = self.attachAsset('dog', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 6;
	self.targetX = 0;
	self.targetY = 0;
	self.moving = false;
	self.setTarget = function (x, y) {
		self.targetX = x;
		self.targetY = y;
		self.moving = true;
	};
	self.bark = function () {
		LK.getSound('bark').play();
		LK.effects.flashObject(self, 0xA52A2A, 300);
	};
	self.update = function () {
		if (self.moving) {
			var dx = self.targetX - self.x;
			var dy = self.targetY - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance > self.speed) {
				// Store previous position to detect movement
				var prevX = self.x;
				var prevY = self.y;
				// Move the dog
				self.x += dx / distance * self.speed;
				self.y += dy / distance * self.speed;
				// Create grass trampling effect with dog footsteps
				if (LK.ticks % 15 === 0 && game.grassField) {
					// Add small particle effect at dog's feet
					var stepX = self.x - dx / distance * 20;
					var stepY = self.y - dy / distance * 20;
					// Highlight grass under the dog's feet
					if (Math.random() > 0.5) {
						LK.effects.flashObject(self, 0xFFFFFF, 100);
					}
				}
			} else {
				self.x = self.targetX;
				self.y = self.targetY;
				self.moving = false;
			}
		}
	};
	return self;
});
var Goal = Container.expand(function () {
	var self = Container.call(this);
	var goalGraphics = self.attachAsset('goal', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0.6
	});
	return self;
});
var GrassField = Container.expand(function () {
	var self = Container.call(this);
	var blades = [];
	var bladesCount = 100; // Number of grass blades
	// Create grass blades
	for (var i = 0; i < bladesCount; i++) {
		var blade = LK.getAsset('goal', {
			anchorX: 0.5,
			anchorY: 1.0,
			// Bottom anchor so it can wave from bottom
			scaleX: 0.05 + Math.random() * 0.1,
			// Thin blades
			scaleY: 0.3 + Math.random() * 0.4,
			// Different heights
			tint: 0x4CAF50 + Math.floor(Math.random() * 0x2F2F2F),
			// Different shades of green
			alpha: 0.7 + Math.random() * 0.3
		});
		// Randomize positions throughout the field
		blade.x = Math.random() * 2048;
		blade.y = Math.random() * 2732;
		// Create unique wave pattern for each blade
		blade.waveSpeed = 0.01 + Math.random() * 0.02;
		blade.waveAmount = 0.05 + Math.random() * 0.1;
		blade.waveOffset = Math.random() * Math.PI * 2;
		blade.baseRotation = -0.1 + Math.random() * 0.2;
		blades.push(blade);
		self.addChild(blade);
	}
	// Animate grass blades
	self.update = function () {
		for (var i = 0; i < blades.length; i++) {
			var blade = blades[i];
			// Gentle waving motion based on sine wave
			blade.rotation = blade.baseRotation + Math.sin(LK.ticks * blade.waveSpeed + blade.waveOffset) * blade.waveAmount;
		}
	};
	// Method to create visual effect when dog moves through grass
	self.createRipple = function (x, y) {
		// Find blades near the position and create ripple effect
		for (var i = 0; i < blades.length; i++) {
			var blade = blades[i];
			var dx = blade.x - x;
			var dy = blade.y - y;
			var dist = Math.sqrt(dx * dx + dy * dy);
			// Only affect nearby blades
			if (dist < 100) {
				// Calculate delay based on distance
				var delay = dist * 3;
				// Stop any existing tween on this blade
				tween.stop(blade);
				// Initial bend away
				var targetRotation = Math.atan2(dy, dx) * 0.5;
				// Apply tween for bending effect
				tween(blade, {
					rotation: targetRotation
				}, {
					duration: 200,
					onFinish: function (blade) {
						return function () {
							// Return to gentle swaying
							tween(blade, {
								rotation: blade.baseRotation
							}, {
								duration: 500,
								easing: tween.elasticOut
							});
						};
					}(blade)
				});
			}
		}
	};
	return self;
});
var Obstacle = Container.expand(function () {
	var self = Container.call(this);
	var obstacleGraphics = self.attachAsset('rock', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	return self;
});
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.wanderSpeed = 0.5;
	self.flockingDistance = 150;
	self.dogAvoidDistance = 200;
	self.wanderDirection = Math.random() * Math.PI * 2;
	self.wanderTimer = 0;
	self.wanderInterval = 60 + Math.random() * 120;
	self.scared = false;
	self.goalReached = false; // Track if sheep has reached the goal area
	self.update = function () {
		// Check if sheep is in goal area
		if (activeGoal && !self.goalReached) {
			var goalDist = Math.sqrt(Math.pow(self.x - activeGoal.x, 2) + Math.pow(self.y - activeGoal.y, 2));
			if (goalDist < 150) {
				self.goalReached = true;
				// Celebration effects when sheep reaches goal
				LK.effects.flashObject(self, 0x228b22, 500);
				LK.getSound('baa').play();
				// Add a little jump animation
				var originalY = self.y;
				tween(self, {
					y: originalY - 30
				}, {
					duration: 300,
					easing: tween.bounceOut,
					onFinish: function onFinish() {
						tween(self, {
							y: originalY
						}, {
							duration: 200,
							easing: tween.bounceOut
						});
					}
				});
			}
		}
		// If sheep reached the goal, make it stay there with small wandering
		if (self.goalReached) {
			// Small random movement within goal
			self.wanderTimer++;
			if (self.wanderTimer > self.wanderInterval) {
				self.wanderDirection = Math.random() * Math.PI * 2;
				self.wanderTimer = 0;
				self.wanderInterval = 120 + Math.random() * 180;
			}
			// Apply very small movement
			var slowSpeed = 0.2;
			self.x += Math.cos(self.wanderDirection) * slowSpeed;
			self.y += Math.sin(self.wanderDirection) * slowSpeed;
			// Ensure sheep stays in goal area
			if (activeGoal) {
				var goalDist = Math.sqrt(Math.pow(self.x - activeGoal.x, 2) + Math.pow(self.y - activeGoal.y, 2));
				if (goalDist > 140) {
					// Pull back toward center of goal
					var pullX = activeGoal.x - self.x;
					var pullY = activeGoal.y - self.y;
					var pullDist = Math.sqrt(pullX * pullX + pullY * pullY);
					self.x += pullX / pullDist * 1.0;
					self.y += pullY / pullDist * 1.0;
				}
			}
			return; // Skip normal movement behaviors
		}
		var vx = 0;
		var vy = 0;
		// Dog avoidance behavior
		var dog = game.dog;
		var dogDx = self.x - dog.x;
		var dogDy = self.y - dog.y;
		var dogDistance = Math.sqrt(dogDx * dogDx + dogDy * dogDy);
		if (dogDistance < self.dogAvoidDistance) {
			var dogFactor = 1 - dogDistance / self.dogAvoidDistance;
			vx += dogDx / dogDistance * dogFactor * 3;
			vy += dogDy / dogDistance * dogFactor * 3;
			self.scared = dogDistance < self.dogAvoidDistance * 0.5;
			if (self.scared && Math.random() < 0.01) {
				LK.getSound('baa').play();
			}
		} else {
			self.scared = false;
		}
		// Flocking behavior
		var cohesionX = 0;
		var cohesionY = 0;
		var alignmentX = 0;
		var alignmentY = 0;
		var separationX = 0;
		var separationY = 0;
		var flockCount = 0;
		for (var i = 0; i < game.sheep.length; i++) {
			var otherSheep = game.sheep[i];
			if (otherSheep !== self) {
				var otherDx = otherSheep.x - self.x;
				var otherDy = otherSheep.y - self.y;
				var otherDistance = Math.sqrt(otherDx * otherDx + otherDy * otherDy);
				if (otherDistance < self.flockingDistance) {
					// Cohesion - move toward center of flock
					cohesionX += otherSheep.x;
					cohesionY += otherSheep.y;
					// Alignment - align with flock direction
					alignmentX += Math.cos(otherSheep.wanderDirection);
					alignmentY += Math.sin(otherSheep.wanderDirection);
					// Separation - avoid crowding
					if (otherDistance < 60) {
						separationX -= otherDx / otherDistance;
						separationY -= otherDy / otherDistance;
					}
					flockCount++;
				}
			}
		}
		// Apply flocking behaviors if there are nearby sheep
		if (flockCount > 0) {
			// Cohesion
			cohesionX = cohesionX / flockCount - self.x;
			cohesionY = cohesionY / flockCount - self.y;
			var cohesionDist = Math.sqrt(cohesionX * cohesionX + cohesionY * cohesionY);
			if (cohesionDist > 0) {
				vx += cohesionX / cohesionDist * 0.1;
				vy += cohesionY / cohesionDist * 0.1;
			}
			// Alignment
			alignmentX /= flockCount;
			alignmentY /= flockCount;
			var alignmentDist = Math.sqrt(alignmentX * alignmentX + alignmentY * alignmentY);
			if (alignmentDist > 0) {
				vx += alignmentX / alignmentDist * 0.2;
				vy += alignmentY / alignmentDist * 0.2;
			}
			// Separation
			vx += separationX * 0.3;
			vy += separationY * 0.3;
		} else {
			// Wandering behavior when alone
			self.wanderTimer++;
			if (self.wanderTimer > self.wanderInterval) {
				self.wanderDirection = Math.random() * Math.PI * 2;
				self.wanderTimer = 0;
				self.wanderInterval = 60 + Math.random() * 120;
			}
			vx += Math.cos(self.wanderDirection) * self.wanderSpeed;
			vy += Math.sin(self.wanderDirection) * self.wanderSpeed;
		}
		// Obstacle avoidance
		for (var i = 0; i < game.obstacles.length; i++) {
			var obstacle = game.obstacles[i];
			var obsDx = self.x - obstacle.x;
			var obsDy = self.y - obstacle.y;
			var obsDistance = Math.sqrt(obsDx * obsDx + obsDy * obsDy);
			if (obsDistance < 120) {
				var obsFactor = 1 - obsDistance / 120;
				vx += obsDx / obsDistance * obsFactor * 2;
				vy += obsDy / obsDistance * obsFactor * 2;
			}
		}
		// Boundary avoidance
		if (self.x < 100) {
			vx += (100 - self.x) * 0.05;
		}
		if (self.x > 1948) {
			vx += (1948 - self.x) * 0.05;
		}
		if (self.y < 100) {
			vy += (100 - self.y) * 0.05;
		}
		if (self.y > 2632) {
			vy += (2632 - self.y) * 0.05;
		}
		// Normalize and apply movement
		var velocity = Math.sqrt(vx * vx + vy * vy);
		if (velocity > 0) {
			var moveSpeed = self.scared ? self.speed * 1.5 : self.speed;
			self.x += vx / velocity * moveSpeed;
			self.y += vy / velocity * moveSpeed;
			self.wanderDirection = Math.atan2(vy, vx);
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Game state variables
var Level = function Level(sheepCount, obstacleCount, goalX, goalY) {
	this.sheepCount = sheepCount;
	this.obstacleCount = obstacleCount;
	this.goalX = goalX;
	this.goalY = goalY;
	this.timeLimit = 60 + sheepCount * 10;
};
var currentLevel = 1;
var maxLevels = 5;
var levels = [];
var timeLeft = 0;
var timerInterval = null;
var activeGoal = null;
var levelCompleted = false;
var sheepInGoal = 0;
// Game elements
game.grassField = null;
game.sheep = [];
game.obstacles = [];
game.dog = null;
// Set up levels
function setupLevels() {
	levels = [new Level(3, 3, 1700, 500), new Level(5, 5, 1600, 1800), new Level(7, 8, 500, 2200), new Level(10, 10, 300, 1200), new Level(12, 15, 1700, 1300)];
}
// Initialize UI
var levelText = new Text2('Level 1', {
	size: 80,
	fill: 0xFFFFFF
});
levelText.anchor.set(0.5, 0);
LK.gui.top.addChild(levelText);
var scoreText = new Text2('Sheep: 0/0', {
	size: 60,
	fill: 0xFFFFFF
});
scoreText.anchor.set(1, 0);
scoreText.x = -50;
LK.gui.topRight.addChild(scoreText);
var timerText = new Text2('Time: 0', {
	size: 60,
	fill: 0xFFFFFF
});
timerText.anchor.set(0, 0);
timerText.x = 50;
LK.gui.topLeft.addChild(timerText);
var instructionText = new Text2('Tap to move your dog\nHerd the sheep to the green area', {
	size: 60,
	fill: 0xFFFFFF
});
instructionText.anchor.set(0.5, 0);
instructionText.y = 100;
LK.gui.top.addChild(instructionText);
// Show the instruction text for a limited time
LK.setTimeout(function () {
	tween(instructionText, {
		alpha: 0
	}, {
		duration: 1000,
		onFinish: function onFinish() {
			LK.gui.top.removeChild(instructionText);
		}
	});
}, 5000);
// Start the game
function startGame() {
	setupLevels();
	startLevel(currentLevel);
	LK.playMusic('countryside');
}
// Setup and start a level
function startLevel(levelNum) {
	clearLevel();
	var level = levels[levelNum - 1];
	levelText.setText('Level ' + levelNum);
	// Set timer
	timeLeft = level.timeLimit;
	timerText.setText('Time: ' + timeLeft);
	if (timerInterval) {
		LK.clearInterval(timerInterval);
	}
	timerInterval = LK.setInterval(updateTimer, 1000);
	// Create grass field first (so it appears behind everything)
	if (!game.grassField) {
		game.grassField = new GrassField();
		game.addChild(game.grassField);
	}
	// Create goal area
	activeGoal = new Goal();
	activeGoal.x = level.goalX;
	activeGoal.y = level.goalY;
	game.addChild(activeGoal);
	// Create dog
	game.dog = new Dog();
	game.dog.x = 1024;
	game.dog.y = 1366;
	game.addChild(game.dog);
	// Create obstacles
	for (var i = 0; i < level.obstacleCount; i++) {
		var obstacle = new Obstacle();
		var validPosition = false;
		// Ensure obstacles don't overlap with the goal
		while (!validPosition) {
			obstacle.x = 200 + Math.random() * 1648;
			obstacle.y = 200 + Math.random() * 2332;
			var goalDist = Math.sqrt(Math.pow(obstacle.x - activeGoal.x, 2) + Math.pow(obstacle.y - activeGoal.y, 2));
			if (goalDist > 300) {
				validPosition = true;
			}
		}
		game.obstacles.push(obstacle);
		game.addChild(obstacle);
	}
	// Create sheep
	for (var i = 0; i < level.sheepCount; i++) {
		var sheep = new Sheep();
		var validPosition = false;
		// Place sheep away from goal and obstacles
		while (!validPosition) {
			sheep.x = 200 + Math.random() * 1648;
			sheep.y = 200 + Math.random() * 2332;
			var goalDist = Math.sqrt(Math.pow(sheep.x - activeGoal.x, 2) + Math.pow(sheep.y - activeGoal.y, 2));
			if (goalDist > 500) {
				validPosition = true;
				// Check distance from obstacles
				for (var j = 0; j < game.obstacles.length; j++) {
					var obstacleDist = Math.sqrt(Math.pow(sheep.x - game.obstacles[j].x, 2) + Math.pow(sheep.y - game.obstacles[j].y, 2));
					if (obstacleDist < 120) {
						validPosition = false;
						break;
					}
				}
			}
		}
		game.sheep.push(sheep);
		game.addChild(sheep);
	}
	// Update UI
	sheepInGoal = 0;
	levelCompleted = false;
	updateScoreText();
}
// Clear all game elements from the current level
function clearLevel() {
	// Remove sheep
	for (var i = 0; i < game.sheep.length; i++) {
		game.removeChild(game.sheep[i]);
	}
	game.sheep = [];
	// Remove obstacles
	for (var i = 0; i < game.obstacles.length; i++) {
		game.removeChild(game.obstacles[i]);
	}
	game.obstacles = [];
	// Remove dog
	if (game.dog) {
		game.removeChild(game.dog);
		game.dog = null;
	}
	// Remove goal
	if (activeGoal) {
		game.removeChild(activeGoal);
		activeGoal = null;
	}
	// Keep grass field between levels but refresh it
	if (game.grassField) {
		// Add subtle animation to grass when changing levels
		tween(game.grassField, {
			alpha: 0.7
		}, {
			duration: 300,
			onFinish: function onFinish() {
				tween(game.grassField, {
					alpha: 1
				}, {
					duration: 300
				});
			}
		});
	}
}
// Update the timer
function updateTimer() {
	timeLeft--;
	timerText.setText('Time: ' + timeLeft);
	if (timeLeft <= 0) {
		LK.clearInterval(timerInterval);
		endLevel(false);
	}
}
// Update the score display
function updateScoreText() {
	var level = levels[currentLevel - 1];
	scoreText.setText('Sheep: ' + sheepInGoal + '/' + level.sheepCount);
}
// End the current level
function endLevel(success) {
	LK.clearInterval(timerInterval);
	if (success) {
		LK.getSound('success').play();
		LK.setScore(LK.getScore() + sheepInGoal * 100 + timeLeft * 10);
		if (currentLevel < maxLevels) {
			currentLevel++;
			LK.setTimeout(function () {
				startLevel(currentLevel);
			}, 1500);
		} else {
			// Game completed
			LK.showYouWin();
		}
	} else {
		LK.showGameOver();
	}
}
// Control the dog with tap/click
game.down = function (x, y) {
	if (game.dog && !levelCompleted) {
		game.dog.setTarget(x, y);
		game.dog.bark();
	}
};
// Main game update loop
game.update = function () {
	if (levelCompleted) {
		return;
	}
	// Update grass field
	if (game.grassField) {
		game.grassField.update();
		// Create ripple effects when dog moves
		if (game.dog && game.dog.moving) {
			// Only create ripple occasionally to avoid overwhelming effects
			if (LK.ticks % 10 === 0) {
				game.grassField.createRipple(game.dog.x, game.dog.y);
			}
		}
	}
	// Update all sheep
	for (var i = 0; i < game.sheep.length; i++) {
		game.sheep[i].update();
	}
	// Update dog
	if (game.dog) {
		game.dog.update();
	}
	// Check for sheep in goal area
	if (activeGoal) {
		sheepInGoal = 0;
		for (var i = 0; i < game.sheep.length; i++) {
			var sheep = game.sheep[i];
			var goalDist = Math.sqrt(Math.pow(sheep.x - activeGoal.x, 2) + Math.pow(sheep.y - activeGoal.y, 2));
			if (goalDist < 150) {
				sheepInGoal++;
			}
		}
		updateScoreText();
		// Check for level completion
		var level = levels[currentLevel - 1];
		if (sheepInGoal >= level.sheepCount && !levelCompleted) {
			levelCompleted = true;
			endLevel(true);
		}
	}
};
// Start the game
startGame();

===================================================================
--- original.js
+++ change.js
@@ -31,10 +31,24 @@
 			var dx = self.targetX - self.x;
 			var dy = self.targetY - self.y;
 			var distance = Math.sqrt(dx * dx + dy * dy);
 			if (distance > self.speed) {
+				// Store previous position to detect movement
+				var prevX = self.x;
+				var prevY = self.y;
+				// Move the dog
 				self.x += dx / distance * self.speed;
 				self.y += dy / distance * self.speed;
+				// Create grass trampling effect with dog footsteps
+				if (LK.ticks % 15 === 0 && game.grassField) {
+					// Add small particle effect at dog's feet
+					var stepX = self.x - dx / distance * 20;
+					var stepY = self.y - dy / distance * 20;
+					// Highlight grass under the dog's feet
+					if (Math.random() > 0.5) {
+						LK.effects.flashObject(self, 0xFFFFFF, 100);
+					}
+				}
 			} else {
 				self.x = self.targetX;
 				self.y = self.targetY;
 				self.moving = false;
@@ -51,8 +65,83 @@
 		alpha: 0.6
 	});
 	return self;
 });
+var GrassField = Container.expand(function () {
+	var self = Container.call(this);
+	var blades = [];
+	var bladesCount = 100; // Number of grass blades
+	// Create grass blades
+	for (var i = 0; i < bladesCount; i++) {
+		var blade = LK.getAsset('goal', {
+			anchorX: 0.5,
+			anchorY: 1.0,
+			// Bottom anchor so it can wave from bottom
+			scaleX: 0.05 + Math.random() * 0.1,
+			// Thin blades
+			scaleY: 0.3 + Math.random() * 0.4,
+			// Different heights
+			tint: 0x4CAF50 + Math.floor(Math.random() * 0x2F2F2F),
+			// Different shades of green
+			alpha: 0.7 + Math.random() * 0.3
+		});
+		// Randomize positions throughout the field
+		blade.x = Math.random() * 2048;
+		blade.y = Math.random() * 2732;
+		// Create unique wave pattern for each blade
+		blade.waveSpeed = 0.01 + Math.random() * 0.02;
+		blade.waveAmount = 0.05 + Math.random() * 0.1;
+		blade.waveOffset = Math.random() * Math.PI * 2;
+		blade.baseRotation = -0.1 + Math.random() * 0.2;
+		blades.push(blade);
+		self.addChild(blade);
+	}
+	// Animate grass blades
+	self.update = function () {
+		for (var i = 0; i < blades.length; i++) {
+			var blade = blades[i];
+			// Gentle waving motion based on sine wave
+			blade.rotation = blade.baseRotation + Math.sin(LK.ticks * blade.waveSpeed + blade.waveOffset) * blade.waveAmount;
+		}
+	};
+	// Method to create visual effect when dog moves through grass
+	self.createRipple = function (x, y) {
+		// Find blades near the position and create ripple effect
+		for (var i = 0; i < blades.length; i++) {
+			var blade = blades[i];
+			var dx = blade.x - x;
+			var dy = blade.y - y;
+			var dist = Math.sqrt(dx * dx + dy * dy);
+			// Only affect nearby blades
+			if (dist < 100) {
+				// Calculate delay based on distance
+				var delay = dist * 3;
+				// Stop any existing tween on this blade
+				tween.stop(blade);
+				// Initial bend away
+				var targetRotation = Math.atan2(dy, dx) * 0.5;
+				// Apply tween for bending effect
+				tween(blade, {
+					rotation: targetRotation
+				}, {
+					duration: 200,
+					onFinish: function (blade) {
+						return function () {
+							// Return to gentle swaying
+							tween(blade, {
+								rotation: blade.baseRotation
+							}, {
+								duration: 500,
+								easing: tween.elasticOut
+							});
+						};
+					}(blade)
+				});
+			}
+		}
+	};
+	return self;
+});
 var Obstacle = Container.expand(function () {
 	var self = Container.call(this);
 	var obstacleGraphics = self.attachAsset('rock', {
 		anchorX: 0.5,
@@ -80,10 +169,27 @@
 		if (activeGoal && !self.goalReached) {
 			var goalDist = Math.sqrt(Math.pow(self.x - activeGoal.x, 2) + Math.pow(self.y - activeGoal.y, 2));
 			if (goalDist < 150) {
 				self.goalReached = true;
+				// Celebration effects when sheep reaches goal
 				LK.effects.flashObject(self, 0x228b22, 500);
 				LK.getSound('baa').play();
+				// Add a little jump animation
+				var originalY = self.y;
+				tween(self, {
+					y: originalY - 30
+				}, {
+					duration: 300,
+					easing: tween.bounceOut,
+					onFinish: function onFinish() {
+						tween(self, {
+							y: originalY
+						}, {
+							duration: 200,
+							easing: tween.bounceOut
+						});
+					}
+				});
 			}
 		}
 		// If sheep reached the goal, make it stay there with small wandering
 		if (self.goalReached) {
@@ -255,8 +361,9 @@
 var activeGoal = null;
 var levelCompleted = false;
 var sheepInGoal = 0;
 // Game elements
+game.grassField = null;
 game.sheep = [];
 game.obstacles = [];
 game.dog = null;
 // Set up levels
@@ -319,8 +426,13 @@
 	if (timerInterval) {
 		LK.clearInterval(timerInterval);
 	}
 	timerInterval = LK.setInterval(updateTimer, 1000);
+	// Create grass field first (so it appears behind everything)
+	if (!game.grassField) {
+		game.grassField = new GrassField();
+		game.addChild(game.grassField);
+	}
 	// Create goal area
 	activeGoal = new Goal();
 	activeGoal.x = level.goalX;
 	activeGoal.y = level.goalY;
@@ -396,8 +508,24 @@
 	if (activeGoal) {
 		game.removeChild(activeGoal);
 		activeGoal = null;
 	}
+	// Keep grass field between levels but refresh it
+	if (game.grassField) {
+		// Add subtle animation to grass when changing levels
+		tween(game.grassField, {
+			alpha: 0.7
+		}, {
+			duration: 300,
+			onFinish: function onFinish() {
+				tween(game.grassField, {
+					alpha: 1
+				}, {
+					duration: 300
+				});
+			}
+		});
+	}
 }
 // Update the timer
 function updateTimer() {
 	timeLeft--;
@@ -442,8 +570,19 @@
 game.update = function () {
 	if (levelCompleted) {
 		return;
 	}
+	// Update grass field
+	if (game.grassField) {
+		game.grassField.update();
+		// Create ripple effects when dog moves
+		if (game.dog && game.dog.moving) {
+			// Only create ripple occasionally to avoid overwhelming effects
+			if (LK.ticks % 10 === 0) {
+				game.grassField.createRipple(game.dog.x, game.dog.y);
+			}
+		}
+	}
 	// Update all sheep
 	for (var i = 0; i < game.sheep.length; i++) {
 		game.sheep[i].update();
 	}