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

/**** 
* Classes
****/ 
var Arrow = Container.expand(function (targetType) {
	var self = Container.call(this);
	var arrowGraphics = self.attachAsset('arrow', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Set color based on target type
	if (targetType === 'pickup') {
		arrowGraphics.tint = 0x00ff00; // Green for package pickup
	} else if (targetType === 'delivery') {
		arrowGraphics.tint = 0xff0000; // Red for delivery house
	}
	self.targetType = targetType;
	self.target = null;
	self.update = function () {
		if (self.target && player) {
			// Calculate direction to target
			var dx = self.target.x - player.x;
			var dy = self.target.y - player.y;
			var angle = Math.atan2(dy, dx);
			// Position arrow around player
			var radius = 80;
			self.x = player.x + Math.cos(angle) * radius;
			self.y = player.y + Math.sin(angle) * radius;
			// Rotate arrow to point towards target
			arrowGraphics.rotation = angle + Math.PI / 2;
			// Pulse animation using tween
			if (!self.tweening) {
				self.tweening = true;
				tween(self, {
					scaleX: 1.3,
					scaleY: 1.3
				}, {
					duration: 500,
					easing: tween.easeInOut,
					onFinish: function onFinish() {
						tween(self, {
							scaleX: 1,
							scaleY: 1
						}, {
							duration: 500,
							easing: tween.easeInOut,
							onFinish: function onFinish() {
								self.tweening = false;
							}
						});
					}
				});
			}
		}
	};
	return self;
});
var Car = Container.expand(function () {
	var self = Container.call(this);
	var carGraphics = self.attachAsset('car', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speedX = (Math.random() - 0.5) * 4;
	self.speedY = (Math.random() - 0.5) * 4;
	self.update = function () {
		var oldX = self.x;
		var oldY = self.y;
		self.x += self.speedX;
		self.y += self.speedY;
		// Calculate rotation based on movement direction
		// Front of sprite is left side, so 0 rotation = moving left
		var targetRotation = Math.atan2(self.speedY, self.speedX) + Math.PI;
		// Smooth rotation using tween
		tween.stop(carGraphics, {
			rotation: true
		});
		tween(carGraphics, {
			rotation: targetRotation
		}, {
			duration: 200,
			easing: tween.easeOut
		});
		// Check collision with houses
		var hitHouse = false;
		for (var h = 0; h < houses.length; h++) {
			if (self.intersects(houses[h])) {
				hitHouse = true;
				break;
			}
		}
		// Check if trying to enter a block (non-street area)
		var enteringBlock = !isOnStreet(self.x, self.y);
		// If hit house or entering block, revert movement and bounce
		if (hitHouse || enteringBlock) {
			self.x = oldX;
			self.y = oldY;
			self.speedX *= -1;
			self.speedY *= -1;
		}
		// Bounce off edges
		if (self.x < 40 || self.x > 2008) {
			self.speedX *= -1;
		}
		if (self.y < 40 || self.y > 2692) {
			self.speedY *= -1;
		}
		// Keep in bounds
		self.x = Math.max(40, Math.min(2008, self.x));
		self.y = Math.max(40, Math.min(2692, self.y));
	};
	return self;
});
var Dog = Container.expand(function () {
	var self = Container.call(this);
	var dogGraphics = self.attachAsset('dog', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 2;
	self.direction = Math.random() * Math.PI * 2;
	self.update = function () {
		// Check distance to player
		var dx = player.x - self.x;
		var dy = player.y - self.y;
		var distanceToPlayer = Math.sqrt(dx * dx + dy * dy);
		var detectionRange = 150;
		if (distanceToPlayer < detectionRange && player) {
			// Follow player behavior
			var angleToPlayer = Math.atan2(dy, dx);
			self.direction = angleToPlayer;
			self.speed = 2.5; // Slightly faster when chasing
		} else {
			// Simple AI - change direction occasionally
			if (Math.random() < 0.02) {
				self.direction = Math.random() * Math.PI * 2;
			}
			self.speed = 2; // Normal speed when wandering
		}
		var oldX = self.x;
		var oldY = self.y;
		self.x += Math.cos(self.direction) * self.speed;
		self.y += Math.sin(self.direction) * self.speed;
		// Check collision with houses
		var hitHouse = false;
		for (var h = 0; h < houses.length; h++) {
			if (self.intersects(houses[h])) {
				hitHouse = true;
				break;
			}
		}
		// If hit house, revert movement and change direction
		if (hitHouse) {
			self.x = oldX;
			self.y = oldY;
			self.direction = Math.random() * Math.PI * 2;
		}
		// Bounce off edges
		if (self.x < 15 || self.x > 2033) {
			self.direction = Math.PI - self.direction;
		}
		if (self.y < 15 || self.y > 2717) {
			self.direction = -self.direction;
		}
		// Keep in bounds
		self.x = Math.max(15, Math.min(2033, self.x));
		self.y = Math.max(15, Math.min(2717, self.y));
	};
	return self;
});
var House = Container.expand(function (houseId) {
	var self = Container.call(this);
	var houseGraphics = self.attachAsset('house', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.houseId = houseId;
	self.hasDelivery = false;
	self.down = function (x, y, obj) {
		if (player.hasPackage && self.distanceTo(player) < 80) {
			if (player.targetHouse === self.houseId) {
				// Correct delivery
				LK.setScore(LK.getScore() + 100);
				player.hasPackage = false;
				player.targetHouse = null;
				self.hasDelivery = true;
				packagesDelivered++;
				// Visual feedback
				tween(self, {
					scaleX: 1.3,
					scaleY: 1.3
				}, {
					duration: 200,
					onFinish: function onFinish() {
						tween(self, {
							scaleX: 1,
							scaleY: 1
						}, {
							duration: 200
						});
					}
				});
				LK.getSound('delivery').play();
				scoreText.setText(LK.getScore());
				// Remove delivery arrow
				if (deliveryArrow) {
					deliveryArrow.destroy();
					deliveryArrow = null;
				}
				// Create pickup arrow for next available package
				if (packages.length > 0) {
					pickupArrow = game.addChild(new Arrow('pickup'));
					pickupArrow.target = packages[0];
				}
				// Check win condition
				if (packagesDelivered >= totalPackages) {
					if (currentLevel < 4) {
						currentLevel++;
						startLevel();
					} else {
						LK.showYouWin();
					}
				}
			} else {
				// Wrong delivery
				LK.setScore(Math.max(0, LK.getScore() - 50));
				scoreText.setText(LK.getScore());
				LK.effects.flashObject(self, 0xff0000, 500);
			}
		}
	};
	self.distanceTo = function (other) {
		var dx = self.x - other.x;
		var dy = self.y - other.y;
		return Math.sqrt(dx * dx + dy * dy);
	};
	return self;
});
var Package = Container.expand(function (targetHouseId) {
	var self = Container.call(this);
	var packageGraphics = self.attachAsset('package', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.collected = false;
	self.targetHouseId = targetHouseId; // Link package to specific house
	return self;
});
var Player = Container.expand(function () {
	var self = Container.call(this);
	var playerGraphics = self.attachAsset('player', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 5;
	self.hasPackage = false;
	self.targetHouse = null;
	return self;
});
var PowerUp = Container.expand(function (type) {
	var self = Container.call(this);
	self.type = type; // 'time', 'speed', 'shield'
	self.collected = false;
	// Use specific asset based on powerup type
	var assetName = 'powerup'; // default
	if (type === 'time') {
		assetName = 'time_powerup';
	} else if (type === 'speed') {
		assetName = 'speed_powerup';
	} else if (type === 'shield') {
		assetName = 'shield_powerup';
	} else if (type === 'life') {
		assetName = 'life_powerup';
	}
	var powerupGraphics = self.attachAsset(assetName, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	return self;
});

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

/**** 
* Game Code
****/ 
// Game variables
var player;
var packages = [];
var houses = [];
var cars = [];
var dogs = [];
var powerups = [];
var currentLevel = 1;
var totalPackages = 3;
var packagesDelivered = 0;
var gameTime = 60000; // 60 seconds
var timeRemaining = gameTime;
var dragNode = null;
var lastCollisionCheck = {};
var targetX = null;
var targetY = null;
var isMoving = false;
var pickupArrow = null;
var deliveryArrow = null;
var lives = 3;
// Block system variables
var blockSize = 460; // 4x4 road tiles (115 * 4)
var blocksX = 4; // Number of blocks horizontally
var blocksY = 5; // Number of blocks vertically
var streetWidth = 115; // Width of streets between blocks
// Helper function to check if position is on a street (road)
function isOnStreet(x, y) {
	var blockX = Math.floor(x / (blockSize + streetWidth));
	var blockY = Math.floor(y / (blockSize + streetWidth));
	var localX = x % (blockSize + streetWidth);
	var localY = y % (blockSize + streetWidth);
	// Check if position is in street area (between blocks)
	return localX >= blockSize || localY >= blockSize;
}
// Helper function to get random street position
function getRandomStreetPosition() {
	var attempts = 0;
	var maxAttempts = 100;
	while (attempts < maxAttempts) {
		var x = Math.random() * 2048;
		var y = Math.random() * 2732;
		if (isOnStreet(x, y)) {
			return {
				x: x,
				y: y
			};
		}
		attempts++;
	}
	// Fallback to center street
	return {
		x: 1024,
		y: 1366
	};
}
// Helper function to get random block position for houses
function getRandomBlockPosition() {
	var blockX = Math.floor(Math.random() * blocksX);
	var blockY = Math.floor(Math.random() * blocksY);
	var startX = blockX * (blockSize + streetWidth);
	var startY = blockY * (blockSize + streetWidth);
	var x = startX + 100 + Math.random() * (blockSize - 200);
	var y = startY + 100 + Math.random() * (blockSize - 200);
	return {
		x: x,
		y: y
	};
}
// UI elements
var scoreText = new Text2('Score: 0', {
	size: 60,
	fill: 0xFFFFFF
});
scoreText.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreText);
var timeText = new Text2('Time: 60', {
	size: 60,
	fill: 0xFFFFFF
});
timeText.anchor.set(1, 0);
LK.gui.topRight.addChild(timeText);
var levelText = new Text2('Level 1', {
	size: 60,
	fill: 0xFFFFFF
});
levelText.anchor.set(0, 0);
LK.gui.topLeft.addChild(levelText);
var livesText = new Text2('Lives: 3', {
	size: 60,
	fill: 0xFFFFFF
});
livesText.anchor.set(0, 1);
LK.gui.bottomLeft.addChild(livesText);
// Create varied road background with different orientations for visual variety
for (var i = 0; i < 18; i++) {
	for (var j = 0; j < 24; j++) {
		// Create visual variety by rotating some road tiles
		var orientation = 0;
		if (Math.random() < 0.3) {
			// 30% chance of rotation
			orientation = Math.floor(Math.random() * 4); // 0, 1, 2, or 3 (90 degree increments)
		}
		var road = LK.getAsset('road', {
			x: i * 115,
			y: j * 115,
			anchorX: 0,
			anchorY: 0,
			orientation: orientation
		});
		game.addChild(road);
	}
}
// Create street blocks in the block areas for city-like appearance
for (var blockX = 0; blockX < blocksX; blockX++) {
	for (var blockY = 0; blockY < blocksY; blockY++) {
		var startX = blockX * (blockSize + streetWidth);
		var startY = blockY * (blockSize + streetWidth);
		// Add street block asset in the center of each block
		var streetBlock = LK.getAsset('street_block', {
			x: startX + blockSize / 2,
			y: startY + blockSize / 2,
			anchorX: 0.5,
			anchorY: 0.5
		});
		game.addChild(streetBlock);
	}
}
function startLevel() {
	// Clear existing game objects
	for (var i = packages.length - 1; i >= 0; i--) {
		packages[i].destroy();
	}
	for (var i = houses.length - 1; i >= 0; i--) {
		houses[i].destroy();
	}
	for (var i = cars.length - 1; i >= 0; i--) {
		cars[i].destroy();
	}
	for (var i = dogs.length - 1; i >= 0; i--) {
		dogs[i].destroy();
	}
	for (var i = powerups.length - 1; i >= 0; i--) {
		powerups[i].destroy();
	}
	// Clear arrow indicators
	if (pickupArrow) {
		pickupArrow.destroy();
		pickupArrow = null;
	}
	if (deliveryArrow) {
		deliveryArrow.destroy();
		deliveryArrow = null;
	}
	packages = [];
	houses = [];
	cars = [];
	dogs = [];
	powerups = [];
	packagesDelivered = 0;
	// Reset time
	timeRemaining = gameTime;
	// Update UI
	levelText.setText('Level ' + currentLevel);
	// Create player if not exists
	if (!player) {
		player = game.addChild(new Player());
		// Find a safe spawn position that doesn't overlap with houses
		var playerSpawned = false;
		var attempts = 0;
		var maxAttempts = 50;
		var minPlayerDistance = 150; // Minimum distance from houses
		while (!playerSpawned && attempts < maxAttempts) {
			var spawnX = 200 + Math.random() * 1600;
			var spawnY = 200 + Math.random() * 1200;
			var positionClear = true;
			// Check if spawn position is clear of houses
			for (var j = 0; j < houses.length; j++) {
				var dx = spawnX - houses[j].x;
				var dy = spawnY - houses[j].y;
				var distance = Math.sqrt(dx * dx + dy * dy);
				if (distance < minPlayerDistance) {
					positionClear = false;
					break;
				}
			}
			if (positionClear) {
				player.x = spawnX;
				player.y = spawnY;
				playerSpawned = true;
			}
			attempts++;
		}
		// Fallback to default position if no safe spot found
		if (!playerSpawned) {
			player.x = 1024;
			player.y = 2366;
		}
	}
	player.hasPackage = false;
	player.targetHouse = null;
	player.hasShield = false;
	// Helper function to check if position overlaps with existing houses
	function isPositionClear(x, y, minDistance) {
		for (var j = 0; j < houses.length; j++) {
			var dx = x - houses[j].x;
			var dy = y - houses[j].y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance < minDistance) {
				return false;
			}
		}
		return true;
	}
	// Create packages and houses
	totalPackages = 2 + currentLevel;
	for (var i = 0; i < totalPackages; i++) {
		// Create package with specific target house ID
		var pkg = new Package(i);
		pkg.x = 200 + Math.random() * 1600;
		pkg.y = 200 + Math.random() * 1200;
		packages.push(pkg);
		game.addChild(pkg);
	}
	// Create corresponding house with overlap prevention
	// Create pickup arrow indicator pointing to first available package
	if (packages.length > 0) {
		pickupArrow = game.addChild(new Arrow('pickup'));
		pickupArrow.target = packages[0];
	}
	// Create packages and houses in blocks
	for (var i = 0; i < totalPackages; i++) {
		var house = new House(i);
		var attempts = 0;
		var maxAttempts = 50;
		var minHouseDistance = 200; // Minimum distance between houses
		do {
			var blockPos = getRandomBlockPosition();
			house.x = blockPos.x;
			house.y = blockPos.y;
			attempts++;
		} while (!isPositionClear(house.x, house.y, minHouseDistance) && attempts < maxAttempts);
		houses.push(house);
		game.addChild(house);
		// Add a street block foundation below each house for visual enhancement
		var houseStreetBlock = LK.getAsset('street_block', {
			x: house.x,
			y: house.y + 80,
			// Position slightly below the house
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 0.6,
			// Make it smaller than the main block
			scaleY: 0.6
		});
		game.addChild(houseStreetBlock);
	}
	// Create cars (more with each level) - spawn only on streets
	var numCars = currentLevel + 1;
	for (var i = 0; i < numCars; i++) {
		var car = new Car();
		var streetPos = getRandomStreetPosition();
		car.x = streetPos.x;
		car.y = streetPos.y;
		cars.push(car);
		game.addChild(car);
	}
	// Create dogs
	var numDogs = Math.floor(currentLevel / 2) + 1;
	for (var i = 0; i < numDogs; i++) {
		var dog = new Dog();
		dog.x = Math.random() * 2048;
		dog.y = Math.random() * 2732;
		dogs.push(dog);
		game.addChild(dog);
	}
	// Create power-ups
	var powerupTypes = ['time', 'speed', 'shield', 'life'];
	for (var i = 0; i < 2; i++) {
		var powerup = new PowerUp(powerupTypes[Math.floor(Math.random() * powerupTypes.length)]);
		powerup.x = Math.random() * 2048;
		powerup.y = Math.random() * 2732;
		powerups.push(powerup);
		game.addChild(powerup);
	}
}
function handleMove(x, y, obj) {
	// Set target position for smooth movement
	targetX = Math.max(30, Math.min(2018, x));
	targetY = Math.max(30, Math.min(2702, y));
	isMoving = true;
	// Orient player sprite based on mouse direction
	if (player) {
		var dx = targetX - player.x;
		if (dx > 0) {
			// Moving right - face right (normal orientation)
			player.scaleX = 1;
		} else if (dx < 0) {
			// Moving left - face left (flip horizontally)
			player.scaleX = -1;
		}
	}
}
game.move = handleMove;
game.down = function (x, y, obj) {
	// Check if clicking on package to pick up
	for (var i = 0; i < packages.length; i++) {
		var pkg = packages[i];
		if (!pkg.collected && pkg.intersects && player.intersects(pkg)) {
			if (!player.hasPackage) {
				pkg.collected = true;
				pkg.destroy();
				packages.splice(i, 1);
				player.hasPackage = true;
				// Use the package's assigned target house
				player.targetHouse = pkg.targetHouseId;
				LK.getSound('pickup').play();
				// Remove pickup arrow and create delivery arrow
				if (pickupArrow) {
					pickupArrow.destroy();
					pickupArrow = null;
				}
				// Create delivery arrow pointing to target house
				if (player.targetHouse !== null && player.targetHouse < houses.length) {
					deliveryArrow = game.addChild(new Arrow('delivery'));
					deliveryArrow.target = houses[player.targetHouse];
				}
				return;
			}
		}
	}
	handleMove(x, y, obj);
};
game.up = function (x, y, obj) {
	// Mouse up - no action needed for smooth movement
};
game.update = function () {
	// Smooth player movement towards target
	if (isMoving && targetX !== null && targetY !== null) {
		var dx = targetX - player.x;
		var dy = targetY - player.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance > 5) {
			// Move towards target with player speed
			var moveX = dx / distance * player.speed;
			var moveY = dy / distance * player.speed;
			var oldX = player.x;
			var oldY = player.y;
			player.x += moveX;
			player.y += moveY;
			// Check collision with houses
			var hitHouse = false;
			var hitTargetHouse = false;
			for (var h = 0; h < houses.length; h++) {
				if (player.intersects(houses[h])) {
					hitHouse = true;
					// Check if this is the target house for delivery
					if (player.hasPackage && player.targetHouse === h) {
						hitTargetHouse = true;
					}
					break;
				}
			}
			// If hit house, revert movement unless it's the target house for delivery
			if (hitHouse && !hitTargetHouse) {
				player.x = oldX;
				player.y = oldY;
				isMoving = false; // Stop movement when hitting house
			}
		} else {
			// Close enough to target, stop moving
			player.x = targetX;
			player.y = targetY;
			isMoving = false;
		}
	}
	// Update time
	timeRemaining -= 16.67; // Approximate 60fps
	var seconds = Math.ceil(timeRemaining / 1000);
	timeText.setText('Time: ' + Math.max(0, seconds));
	// Check time up
	if (timeRemaining <= 0) {
		LK.showGameOver();
		return;
	}
	// Check package pickup
	for (var i = packages.length - 1; i >= 0; i--) {
		var pkg = packages[i];
		if (!pkg.collected && player.intersects(pkg)) {
			if (!player.hasPackage) {
				pkg.collected = true;
				pkg.destroy();
				packages.splice(i, 1);
				player.hasPackage = true;
				// Use the package's assigned target house
				player.targetHouse = pkg.targetHouseId;
				LK.getSound('pickup').play();
				// Remove pickup arrow and create delivery arrow
				if (pickupArrow) {
					pickupArrow.destroy();
					pickupArrow = null;
				}
				// Create delivery arrow pointing to target house
				if (player.targetHouse !== null && player.targetHouse < houses.length) {
					deliveryArrow = game.addChild(new Arrow('delivery'));
					deliveryArrow.target = houses[player.targetHouse];
				}
			}
		}
	}
	// Check package delivery when player collides with house
	if (player.hasPackage && player.targetHouse !== null) {
		for (var h = 0; h < houses.length; h++) {
			var house = houses[h];
			var houseKey = 'house_delivery_' + h;
			var currentCollision = player.intersects(house);
			if (!lastCollisionCheck[houseKey] && currentCollision) {
				// Just started colliding with house
				if (player.targetHouse === h) {
					// Correct delivery
					LK.setScore(LK.getScore() + 100);
					player.hasPackage = false;
					player.targetHouse = null;
					house.hasDelivery = true;
					packagesDelivered++;
					// Visual feedback
					tween(house, {
						scaleX: 1.3,
						scaleY: 1.3
					}, {
						duration: 200,
						onFinish: function onFinish() {
							tween(house, {
								scaleX: 1,
								scaleY: 1
							}, {
								duration: 200
							});
						}
					});
					LK.getSound('delivery').play();
					scoreText.setText(LK.getScore());
					// Remove delivery arrow
					if (deliveryArrow) {
						deliveryArrow.destroy();
						deliveryArrow = null;
					}
					// Create pickup arrow for next available package
					if (packages.length > 0) {
						pickupArrow = game.addChild(new Arrow('pickup'));
						pickupArrow.target = packages[0];
					}
					// Check win condition
					if (packagesDelivered >= totalPackages) {
						if (currentLevel < 4) {
							currentLevel++;
							startLevel();
						} else {
							LK.showYouWin();
						}
					}
					break; // Exit loop after successful delivery
				} else {
					// Wrong delivery
					LK.setScore(Math.max(0, LK.getScore() - 50));
					scoreText.setText(LK.getScore());
					LK.effects.flashObject(house, 0xff0000, 500);
				}
			}
			lastCollisionCheck[houseKey] = currentCollision;
		}
	}
	// Check powerup collection
	for (var i = powerups.length - 1; i >= 0; i--) {
		var powerup = powerups[i];
		if (!powerup.collected && player.intersects(powerup)) {
			powerup.collected = true;
			powerup.destroy();
			powerups.splice(i, 1);
			if (powerup.type === 'time') {
				timeRemaining += 10000; // Add 10 seconds
			} else if (powerup.type === 'speed') {
				player.speed = 8;
				LK.setTimeout(function () {
					player.speed = 5;
				}, 5000);
			} else if (powerup.type === 'shield') {
				player.hasShield = true;
				// Visual shield effect
				tween(player, {
					tint: 0x00FFFF
				}, {
					duration: 200
				});
				LK.setTimeout(function () {
					player.hasShield = false;
					tween(player, {
						tint: 0xFFFFFF
					}, {
						duration: 200
					});
				}, 8000); // Shield lasts 8 seconds
			} else if (powerup.type === 'life') {
				lives++;
				livesText.setText('Lives: ' + lives);
			}
			LK.getSound('powerup').play();
			LK.setScore(LK.getScore() + 25);
			scoreText.setText(LK.getScore());
		}
	}
	// Check collisions with obstacles
	for (var i = 0; i < cars.length; i++) {
		var car = cars[i];
		var carKey = 'car_' + i;
		var currentCollision = player.intersects(car);
		if (!lastCollisionCheck[carKey] && currentCollision) {
			// Just started colliding
			if (!player.hasShield) {
				lives--;
				livesText.setText('Lives: ' + lives);
				if (lives <= 0) {
					LK.showGameOver();
					return;
				}
				LK.setScore(Math.max(0, LK.getScore() - 25));
				scoreText.setText(LK.getScore());
				LK.effects.flashObject(player, 0xff0000, 500);
			}
		}
		lastCollisionCheck[carKey] = currentCollision;
	}
	for (var i = 0; i < dogs.length; i++) {
		var dog = dogs[i];
		var dogKey = 'dog_' + i;
		var currentCollision = player.intersects(dog);
		if (!lastCollisionCheck[dogKey] && currentCollision) {
			// Just started colliding
			if (!player.hasShield) {
				lives--;
				livesText.setText('Lives: ' + lives);
				if (lives <= 0) {
					LK.showGameOver();
					return;
				}
				LK.setScore(Math.max(0, LK.getScore() - 15));
				scoreText.setText(LK.getScore());
				LK.effects.flashObject(player, 0xff0000, 300);
			}
		}
		lastCollisionCheck[dogKey] = currentCollision;
	}
};
// Start the first level
startLevel();
// Play background music
LK.playMusic('bgmusic');

===================================================================
--- original.js
+++ change.js
@@ -385,20 +385,42 @@
 	fill: 0xFFFFFF
 });
 livesText.anchor.set(0, 1);
 LK.gui.bottomLeft.addChild(livesText);
-// Create road background
+// Create varied road background with different orientations for visual variety
 for (var i = 0; i < 18; i++) {
 	for (var j = 0; j < 24; j++) {
+		// Create visual variety by rotating some road tiles
+		var orientation = 0;
+		if (Math.random() < 0.3) {
+			// 30% chance of rotation
+			orientation = Math.floor(Math.random() * 4); // 0, 1, 2, or 3 (90 degree increments)
+		}
 		var road = LK.getAsset('road', {
 			x: i * 115,
 			y: j * 115,
 			anchorX: 0,
-			anchorY: 0
+			anchorY: 0,
+			orientation: orientation
 		});
 		game.addChild(road);
 	}
 }
+// Create street blocks in the block areas for city-like appearance
+for (var blockX = 0; blockX < blocksX; blockX++) {
+	for (var blockY = 0; blockY < blocksY; blockY++) {
+		var startX = blockX * (blockSize + streetWidth);
+		var startY = blockY * (blockSize + streetWidth);
+		// Add street block asset in the center of each block
+		var streetBlock = LK.getAsset('street_block', {
+			x: startX + blockSize / 2,
+			y: startY + blockSize / 2,
+			anchorX: 0.5,
+			anchorY: 0.5
+		});
+		game.addChild(streetBlock);
+	}
+}
 function startLevel() {
 	// Clear existing game objects
 	for (var i = packages.length - 1; i >= 0; i--) {
 		packages[i].destroy();
@@ -513,8 +535,20 @@
 			attempts++;
 		} while (!isPositionClear(house.x, house.y, minHouseDistance) && attempts < maxAttempts);
 		houses.push(house);
 		game.addChild(house);
+		// Add a street block foundation below each house for visual enhancement
+		var houseStreetBlock = LK.getAsset('street_block', {
+			x: house.x,
+			y: house.y + 80,
+			// Position slightly below the house
+			anchorX: 0.5,
+			anchorY: 0.5,
+			scaleX: 0.6,
+			// Make it smaller than the main block
+			scaleY: 0.6
+		});
+		game.addChild(houseStreetBlock);
 	}
 	// Create cars (more with each level) - spawn only on streets
 	var numCars = currentLevel + 1;
 	for (var i = 0; i < numCars; i++) {