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

/**** 
* Classes
****/ 
var Bullet = Container.expand(function (type, damage, target, isChain) {
	var self = Container.call(this);
	var bulletGraphics = self.attachAsset(type + 'Bullet', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.damage = damage;
	self.target = target;
	self.speed = 8;
	self.isChain = isChain || false;
	self.hasHit = false;
	self.update = function () {
		if (!self.target || self.hasHit) return;
		var dx = self.target.x - self.x;
		var dy = self.target.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance < 30) {
			self.hitTarget();
		} else {
			self.x += dx / distance * self.speed;
			self.y += dy / distance * self.speed;
		}
	};
	self.hitTarget = function () {
		if (self.hasHit) return;
		self.hasHit = true;
		self.target.takeDamage(self.damage);
		LK.getSound('enemyHit').play();
		if (self.isChain && self.target.health > 0) {
			handleChainLightning(self.target, self.damage);
		}
		self.destroy();
		for (var i = bullets.length - 1; i >= 0; i--) {
			if (bullets[i] === self) {
				bullets.splice(i, 1);
				break;
			}
		}
	};
	return self;
});
var Dragon = Container.expand(function (type, x, y) {
	var self = Container.call(this);
	var dragonGraphics = self.attachAsset(type + 'Dragon', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.type = type;
	self.isUpgraded = false;
	self.lastShotTime = 0;
	self.shootInterval = 1500;
	if (type === 'fire') {
		self.damage = 500;
		self.range = 500;
		self.cost = 100;
	} else if (type === 'ice') {
		self.damage = 250;
		self.range = 500;
		self.cost = 120;
	} else if (type === 'lightning') {
		self.damage = 400;
		self.range = 500;
		self.cost = 150;
	} else if (type === 'beam') {
		self.damage = 10;
		self.range = 500;
		self.cost = 200;
		self.beamTarget = null;
		self.beamDamageMultiplier = 1;
		self.beamStartTime = 0;
		self.shootInterval = 100; // Beam updates faster
	}
	self.x = x;
	self.y = y;
	self.update = function () {
		var currentTime = Date.now();
		if (self.type === 'beam') {
			// Handle beam dragon logic
			if (self.beamTarget && self.beamTarget.health > 0) {
				var dx = self.beamTarget.x - self.x;
				var dy = self.beamTarget.y - self.y;
				var distance = Math.sqrt(dx * dx + dy * dy);
				if (distance <= self.range) {
					// Calculate damage based on time
					var timeElapsed = (currentTime - self.beamStartTime) / 1000;
					var currentDamage;
					if (timeElapsed < 1) {
						currentDamage = self.isUpgraded ? 15 : 10;
					} else if (timeElapsed < 2) {
						currentDamage = self.isUpgraded ? 300 : 200;
					} else if (timeElapsed < 3) {
						currentDamage = self.isUpgraded ? 750 : 500;
					} else if (timeElapsed < 4) {
						currentDamage = self.isUpgraded ? 1200 : 800;
					} else {
						currentDamage = self.isUpgraded ? 1500 : 1000;
					}
					// Apply damage every 0.5 seconds after 3rd second, otherwise every second
					var shouldDamage = false;
					if (timeElapsed >= 3) {
						shouldDamage = Math.floor(timeElapsed * 2) > Math.floor((timeElapsed - 0.017) * 2);
					} else {
						shouldDamage = Math.floor(timeElapsed) > Math.floor(timeElapsed - 0.017);
					}
					if (shouldDamage) {
						self.beamTarget.takeDamage(currentDamage);
						LK.getSound('enemyHit').play();
					}
				} else {
					self.beamTarget = null;
				}
			} else {
				self.beamTarget = null;
			}
			if (!self.beamTarget) {
				var target = self.findTarget();
				if (target) {
					self.shoot(target);
				}
			}
		} else {
			if (currentTime - self.lastShotTime >= self.shootInterval) {
				var target = self.findTarget();
				if (target) {
					self.shoot(target);
					self.lastShotTime = currentTime;
				}
			}
		}
	};
	self.findTarget = function () {
		var closestEnemy = null;
		var closestDistance = Infinity;
		for (var i = 0; i < enemies.length; i++) {
			var enemy = enemies[i];
			var dx = enemy.x - self.x;
			var dy = enemy.y - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance < closestDistance && distance <= self.range) {
				closestDistance = distance;
				closestEnemy = enemy;
			}
		}
		return closestEnemy;
	};
	self.shoot = function (target) {
		if (self.type === 'beam') {
			// Handle beam dragon shooting
			if (!self.beamTarget || self.beamTarget.health <= 0) {
				self.beamTarget = target;
				self.beamStartTime = Date.now();
				self.beamDamageMultiplier = 1;
			}
			return;
		}
		LK.getSound('shoot').play();
		var bullet = new Bullet(self.type, self.damage, target, self.type === 'lightning');
		bullet.x = self.x;
		bullet.y = self.y;
		bullets.push(bullet);
		game.addChild(bullet);
		if (self.type === 'ice') {
			target.applySlowEffect(self.isUpgraded ? 0.75 : 0.85);
		}
	};
	self.upgrade = function () {
		if (self.isUpgraded) return false;
		if (playerGold >= 150) {
			playerGold -= 150;
			self.isUpgraded = true;
			if (self.type === 'fire') {
				self.damage = 1000;
				tween(dragonGraphics, {
					tint: 0xcc0000
				}, {
					duration: 500
				});
			} else if (self.type === 'ice') {
				self.damage = Math.floor(self.damage * 1.5);
				tween(dragonGraphics, {
					tint: 0x0000cc
				}, {
					duration: 500
				});
			} else if (self.type === 'lightning') {
				self.damage = Math.floor(self.damage * 1.5);
				tween(dragonGraphics, {
					tint: 0xcccc00
				}, {
					duration: 500
				});
			} else if (self.type === 'beam') {
				self.damage = Math.floor(self.damage * 1.5);
				tween(dragonGraphics, {
					tint: 0xcc00cc
				}, {
					duration: 500
				});
			}
			updateGoldDisplay();
			return true;
		}
		return false;
	};
	self.down = function (x, y, obj) {
		if (gameState === 'playing') {
			selectedDragon = self;
			updateUpgradeButton();
		}
	};
	return self;
});
var Enemy = Container.expand(function (type) {
	var self = Container.call(this);
	var enemyGraphics = self.attachAsset(type, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.type = type;
	self.pathIndex = 0;
	self.speed = 0.968; // Base speed increased by 10% (0.88 * 1.1)
	self.slowEffect = 1;
	self.slowDuration = 0;
	if (type === 'regularSkeleton') {
		self.maxHealth = 500;
		self.goldValue = 20;
		self.speed = 1.10; // Regular skeleton speed 1.10 meter/second
	} else if (type === 'shieldedSkeleton') {
		self.maxHealth = 2000;
		self.goldValue = 25;
		self.speed = 1.0; // Shielded skeleton speed 1.0 meter/second
	} else if (type === 'fastSkeleton') {
		self.maxHealth = 1500;
		self.goldValue = 30;
		self.speed = 3.0; // Fast skeleton speed 3.0 meter/second
	} else if (type === 'giantSkeleton') {
		self.maxHealth = 20000;
		self.goldValue = 100;
		self.speed = 1.0; // Giant skeleton speed 1.0 meter/second
	} else if (type === 'witchBoss') {
		self.maxHealth = 80000;
		self.goldValue = 50;
		self.speed = 1.0; // Witch boss speed 1.0 meter/second
	}
	self.health = self.maxHealth;
	self.x = pathPoints[0].x;
	self.y = pathPoints[0].y;
	self.update = function () {
		if (self.slowDuration > 0) {
			self.slowDuration--;
		} else {
			self.slowEffect = 1;
		}
		if (self.pathIndex < pathPoints.length - 1) {
			var currentPoint = pathPoints[self.pathIndex];
			var nextPoint = pathPoints[self.pathIndex + 1];
			var dx = nextPoint.x - self.x;
			var dy = nextPoint.y - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance < 10) {
				self.pathIndex++;
			} else {
				var moveSpeed = self.speed * self.slowEffect;
				self.x += dx / distance * moveSpeed;
				self.y += dy / distance * moveSpeed;
			}
		} else {
			self.reachEnd();
		}
	};
	self.takeDamage = function (damage) {
		self.health -= damage;
		if (self.health <= 0) {
			self.die();
		}
	};
	self.applySlowEffect = function (slowAmount) {
		self.slowEffect = slowAmount;
		self.slowDuration = 180;
	};
	self.die = function () {
		playerGold += self.goldValue;
		updateGoldDisplay();
		self.destroy();
		for (var i = enemies.length - 1; i >= 0; i--) {
			if (enemies[i] === self) {
				enemies.splice(i, 1);
				break;
			}
		}
		checkWaveComplete();
	};
	self.reachEnd = function () {
		gameState = 'gameOver';
		LK.showGameOver();
		self.destroy();
		for (var i = enemies.length - 1; i >= 0; i--) {
			if (enemies[i] === self) {
				enemies.splice(i, 1);
				break;
			}
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
var gameState = 'playing';
var playerGold = 100;
var playerLives = 10;
var currentWave = 1;
var waveInProgress = false;
var selectedDragon = null;
var dragons = [];
var enemies = [];
var bullets = [];
var placementZones = [];
var pathPoints = [{
	x: 2048,
	y: 1600
}, {
	x: 1700,
	y: 1600
}, {
	x: 1400,
	y: 1400
}, {
	x: 1100,
	y: 1200
}, {
	x: 800,
	y: 1000
}, {
	x: 600,
	y: 800
}, {
	x: 500,
	y: 600
}, {
	x: 600,
	y: 400
}, {
	x: 800,
	y: 200
}, {
	x: 1100,
	y: 300
}, {
	x: 1400,
	y: 400
}, {
	x: 1700,
	y: 600
}, {
	x: 1900,
	y: 800
}, {
	x: 1700,
	y: 1000
}, {
	x: 1400,
	y: 1100
}, {
	x: 1100,
	y: 1200
}, {
	x: 800,
	y: 1300
}, {
	x: 500,
	y: 1400
}, {
	x: 200,
	y: 1500
}, {
	x: 0,
	y: 1600
}];
var placementPositions = [{
	x: 1750,
	y: 1850
}, {
	x: 1350,
	y: 1850
}, {
	x: 1000,
	y: 1850
}, {
	x: 650,
	y: 1850
}, {
	x: 250,
	y: 1850
}, {
	x: 50,
	y: 1200
}, {
	x: 50,
	y: 900
}, {
	x: 50,
	y: 600
}, {
	x: 200,
	y: 50
}, {
	x: 500,
	y: 50
}, {
	x: 800,
	y: 50
}, {
	x: 1200,
	y: 50
}, {
	x: 1600,
	y: 50
}, {
	x: 2000,
	y: 350
}, {
	x: 2000,
	y: 650
}];
// Create path as connected thick line segments
for (var i = 0; i < pathPoints.length - 1; i++) {
	var currentPoint = pathPoints[i];
	var nextPoint = pathPoints[i + 1];
	var dx = nextPoint.x - currentPoint.x;
	var dy = nextPoint.y - currentPoint.y;
	var distance = Math.sqrt(dx * dx + dy * dy);
	var angle = Math.atan2(dy, dx);
	var pathLine = game.addChild(LK.getAsset('path', {
		anchorX: 0,
		anchorY: 0.5,
		scaleX: distance / 100,
		scaleY: 0.8,
		tint: 0x654321
	}));
	pathLine.x = currentPoint.x;
	pathLine.y = currentPoint.y;
	pathLine.rotation = angle;
}
// Create placement zones
for (var i = 0; i < placementPositions.length; i++) {
	var zone = game.addChild(LK.getAsset('placementZone', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0.3
	}));
	zone.x = placementPositions[i].x;
	zone.y = placementPositions[i].y;
	zone.zoneIndex = i;
	zone.down = function (x, y, obj) {
		if (gameState === 'playing' && selectedDragonType) {
			placeDragon(selectedDragonType, this.x, this.y, this.zoneIndex);
		}
	};
	placementZones.push(zone);
}
// Create shop panel
var shopPanel = LK.gui.bottom.addChild(LK.getAsset('shopPanel', {
	anchorX: 0.5,
	anchorY: 1
}));
// Create dragon buttons
var fireButton = shopPanel.addChild(LK.getAsset('dragonButton', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: -450,
	y: -150,
	tint: 0xff4444
}));
var iceButton = shopPanel.addChild(LK.getAsset('dragonButton', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: -250,
	y: -150,
	tint: 0x4444ff
}));
var lightningButton = shopPanel.addChild(LK.getAsset('dragonButton', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: -50,
	y: -150,
	tint: 0xffff44
}));
var beamButton = shopPanel.addChild(LK.getAsset('dragonButton', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 150,
	y: -150,
	tint: 0xff44ff
}));
var upgradeButton = shopPanel.addChild(LK.getAsset('dragonButton', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 350,
	y: -150,
	tint: 0x00ff00
}));
var startWaveButton = shopPanel.addChild(LK.getAsset('dragonButton', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 550,
	y: -150,
	tint: 0xff8800
}));
// Create UI text
var goldText = LK.gui.topRight.addChild(new Text2('Gold: 100', {
	size: 60,
	fill: 0xFFFF00
}));
goldText.anchor.set(1, 0);
var livesText = LK.gui.topRight.addChild(new Text2('Lives: 10', {
	size: 60,
	fill: 0xFF0000
}));
livesText.anchor.set(1, 0);
livesText.y = 80;
var waveText = LK.gui.top.addChild(new Text2('Wave: 1', {
	size: 60,
	fill: 0xFFFFFF
}));
waveText.anchor.set(0.5, 0);
var fireButtonText = fireButton.addChild(new Text2('Fire\n100g', {
	size: 30,
	fill: 0xFFFFFF
}));
fireButtonText.anchor.set(0.5, 0.5);
var iceButtonText = iceButton.addChild(new Text2('Ice\n120g', {
	size: 30,
	fill: 0xFFFFFF
}));
iceButtonText.anchor.set(0.5, 0.5);
var lightningButtonText = lightningButton.addChild(new Text2('Lightning\n150g', {
	size: 30,
	fill: 0xFFFFFF
}));
lightningButtonText.anchor.set(0.5, 0.5);
var beamButtonText = beamButton.addChild(new Text2('Beam\n200g', {
	size: 30,
	fill: 0xFFFFFF
}));
beamButtonText.anchor.set(0.5, 0.5);
var upgradeButtonText = upgradeButton.addChild(new Text2('Upgrade\nSelect', {
	size: 30,
	fill: 0xFFFFFF
}));
upgradeButtonText.anchor.set(0.5, 0.5);
var startWaveButtonText = startWaveButton.addChild(new Text2('Start\nWave', {
	size: 30,
	fill: 0xFFFFFF
}));
startWaveButtonText.anchor.set(0.5, 0.5);
var selectedDragonType = null;
var waveSpawnIndex = 0;
var waveSpawnTimer = 0;
function updateGoldDisplay() {
	goldText.setText('Gold: ' + playerGold);
}
function updateLivesDisplay() {
	livesText.setText('Lives: ' + playerLives);
}
function updateWaveDisplay() {
	waveText.setText('Wave: ' + currentWave);
}
function updateUpgradeButton() {
	if (selectedDragon && !selectedDragon.isUpgraded) {
		upgradeButtonText.setText('Upgrade\n150g');
	} else {
		upgradeButtonText.setText('Upgrade\nSelect');
	}
}
function placeDragon(type, x, y, zoneIndex) {
	var cost;
	if (type === 'fire') cost = 100;else if (type === 'ice') cost = 120;else if (type === 'lightning') cost = 150;else if (type === 'beam') cost = 200;
	if (playerGold >= cost) {
		var hasExistingDragon = false;
		for (var i = 0; i < dragons.length; i++) {
			if (Math.abs(dragons[i].x - x) < 50 && Math.abs(dragons[i].y - y) < 50) {
				hasExistingDragon = true;
				break;
			}
		}
		if (!hasExistingDragon) {
			playerGold -= cost;
			updateGoldDisplay();
			var dragon = game.addChild(new Dragon(type, x, y));
			dragons.push(dragon);
			selectedDragonType = null;
			updateButtonHighlights();
		}
	}
}
function updateButtonHighlights() {
	fireButton.tint = selectedDragonType === 'fire' ? 0xffaaaa : 0xff4444;
	iceButton.tint = selectedDragonType === 'ice' ? 0xaaaaff : 0x4444ff;
	lightningButton.tint = selectedDragonType === 'lightning' ? 0xffffaa : 0xffff44;
	beamButton.tint = selectedDragonType === 'beam' ? 0xffaaff : 0xff44ff;
}
function startWave() {
	if (waveInProgress) return;
	waveInProgress = true;
	waveSpawnIndex = 0;
	waveSpawnTimer = 0;
	selectedDragon = null;
	updateUpgradeButton();
}
function spawnEnemy() {
	var enemyType;
	var waveSize;
	if (currentWave === 1) {
		enemyType = 'regularSkeleton';
		waveSize = 15;
	} else if (currentWave === 2) {
		enemyType = 'shieldedSkeleton';
		waveSize = 15;
	} else if (currentWave === 3) {
		enemyType = 'fastSkeleton';
		waveSize = 15;
	} else if (currentWave === 4) {
		if (waveSpawnIndex < 10) {
			enemyType = 'regularSkeleton';
		} else if (waveSpawnIndex < 20) {
			enemyType = 'shieldedSkeleton';
		} else {
			enemyType = 'fastSkeleton';
		}
		waveSize = 30;
	} else if (currentWave === 5) {
		if (waveSpawnIndex < 2) {
			enemyType = 'giantSkeleton';
		} else {
			enemyType = 'witchBoss';
		}
		waveSize = 3;
	}
	if (waveSpawnIndex < waveSize) {
		var enemy = game.addChild(new Enemy(enemyType));
		enemies.push(enemy);
		waveSpawnIndex++;
	}
}
function checkWaveComplete() {
	if (waveInProgress && enemies.length === 0) {
		// Only complete wave if all enemies have been spawned
		var expectedWaveSize;
		if (currentWave === 1 || currentWave === 2 || currentWave === 3) {
			expectedWaveSize = 15;
		} else if (currentWave === 4) {
			expectedWaveSize = 30;
		} else if (currentWave === 5) {
			expectedWaveSize = 3;
		}
		if (waveSpawnIndex >= expectedWaveSize) {
			waveInProgress = false;
			if (currentWave >= 5) {
				gameState = 'victory';
				LK.showYouWin();
			} else {
				currentWave++;
				updateWaveDisplay();
			}
		}
	}
}
function handleChainLightning(hitTarget, baseDamage) {
	var chainTargets = [];
	var maxChains = selectedDragon && selectedDragon.isUpgraded ? 5 : 3;
	var chainDamages = selectedDragon && selectedDragon.isUpgraded ? [500, 400, 300, 200, 100] : [400, 300, 200];
	for (var i = 0; i < enemies.length && chainTargets.length < maxChains - 1; i++) {
		var enemy = enemies[i];
		if (enemy !== hitTarget) {
			var dx = enemy.x - hitTarget.x;
			var dy = enemy.y - hitTarget.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance <= 200) {
				chainTargets.push(enemy);
			}
		}
	}
	// Create visual lightning effects and damage
	var allTargets = [hitTarget].concat(chainTargets);
	for (var i = 0; i < chainTargets.length; i++) {
		var currentTarget = allTargets[i];
		var nextTarget = allTargets[i + 1];
		var damage = chainDamages[i + 1];
		// Create lightning visual effect
		var lightning = game.addChild(LK.getAsset('lightningBullet', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 3,
			scaleY: 0.5
		}));
		lightning.x = currentTarget.x;
		lightning.y = currentTarget.y;
		// Calculate angle and distance for lightning bolt
		var dx = nextTarget.x - currentTarget.x;
		var dy = nextTarget.y - currentTarget.y;
		var angle = Math.atan2(dy, dx);
		var distance = Math.sqrt(dx * dx + dy * dy);
		lightning.rotation = angle;
		lightning.width = distance;
		// Animate lightning effect
		tween(lightning, {
			alpha: 0
		}, {
			duration: 300,
			onFinish: function onFinish() {
				lightning.destroy();
			}
		});
		// Apply damage with delay
		LK.setTimeout(function (t, d) {
			return function () {
				if (t && t.health > 0) {
					t.takeDamage(d);
				}
			};
		}(nextTarget, damage), (i + 1) * 100);
	}
}
// Button event handlers
fireButton.down = function () {
	if (gameState === 'playing' && playerGold >= 100) {
		selectedDragonType = selectedDragonType === 'fire' ? null : 'fire';
		updateButtonHighlights();
	}
};
iceButton.down = function () {
	if (gameState === 'playing' && playerGold >= 120) {
		selectedDragonType = selectedDragonType === 'ice' ? null : 'ice';
		updateButtonHighlights();
	}
};
lightningButton.down = function () {
	if (gameState === 'playing' && playerGold >= 150) {
		selectedDragonType = selectedDragonType === 'lightning' ? null : 'lightning';
		updateButtonHighlights();
	}
};
beamButton.down = function () {
	if (gameState === 'playing' && playerGold >= 200) {
		selectedDragonType = selectedDragonType === 'beam' ? null : 'beam';
		updateButtonHighlights();
	}
};
upgradeButton.down = function () {
	if (gameState === 'playing' && selectedDragon) {
		selectedDragon.upgrade();
		updateUpgradeButton();
	}
};
startWaveButton.down = function () {
	if (gameState === 'playing' && !waveInProgress) {
		startWave();
	}
};
game.update = function () {
	if (gameState !== 'playing') return;
	// Update dragons
	for (var i = 0; i < dragons.length; i++) {
		dragons[i].update();
	}
	// Update enemies
	for (var i = 0; i < enemies.length; i++) {
		enemies[i].update();
	}
	// Update bullets
	for (var i = bullets.length - 1; i >= 0; i--) {
		bullets[i].update();
	}
	// Spawn enemies during wave
	if (waveInProgress) {
		waveSpawnTimer++;
		var spawnInterval = currentWave === 1 ? 48 : 120; // 60% faster spawning for first wave (120 * 0.4 = 48)
		if (waveSpawnTimer >= spawnInterval) {
			spawnEnemy();
			waveSpawnTimer = 0;
		}
	}
	// Check if wave is complete - only after all enemies are spawned
	var expectedWaveSize;
	if (currentWave === 1 || currentWave === 2 || currentWave === 3) {
		expectedWaveSize = 15;
	} else if (currentWave === 4) {
		expectedWaveSize = 30;
	} else if (currentWave === 5) {
		expectedWaveSize = 3;
	}
	if (waveInProgress && waveSpawnIndex >= expectedWaveSize) {
		if (enemies.length === 0) {
			checkWaveComplete();
		}
	}
};

===================================================================
--- original.js
+++ change.js
@@ -393,52 +393,52 @@
 	x: 0,
 	y: 1600
 }];
 var placementPositions = [{
-	x: 1500,
-	y: 1800
+	x: 1750,
+	y: 1850
 }, {
-	x: 1200,
-	y: 1700
+	x: 1350,
+	y: 1850
 }, {
-	x: 900,
-	y: 1600
+	x: 1000,
+	y: 1850
 }, {
-	x: 600,
-	y: 1700
+	x: 650,
+	y: 1850
 }, {
-	x: 300,
-	y: 1800
+	x: 250,
+	y: 1850
 }, {
-	x: 300,
+	x: 50,
+	y: 1200
+}, {
+	x: 50,
 	y: 900
 }, {
-	x: 200,
+	x: 50,
 	y: 600
 }, {
-	x: 300,
-	y: 300
+	x: 200,
+	y: 50
 }, {
-	x: 600,
-	y: 100
+	x: 500,
+	y: 50
 }, {
-	x: 900,
+	x: 800,
 	y: 50
 }, {
 	x: 1200,
-	y: 100
+	y: 50
 }, {
-	x: 1500,
-	y: 200
+	x: 1600,
+	y: 50
 }, {
-	x: 1800,
-	y: 400
+	x: 2000,
+	y: 350
 }, {
-	x: 1900,
-	y: 700
-}, {
-	x: 1800,
-	y: 1000
+	x: 2000,
+	y: 650
 }];
 // Create path as connected thick line segments
 for (var i = 0; i < pathPoints.length - 1; i++) {
 	var currentPoint = pathPoints[i];
@@ -450,9 +450,10 @@
 	var pathLine = game.addChild(LK.getAsset('path', {
 		anchorX: 0,
 		anchorY: 0.5,
 		scaleX: distance / 100,
-		scaleY: 0.3
+		scaleY: 0.8,
+		tint: 0x654321
 	}));
 	pathLine.x = currentPoint.x;
 	pathLine.y = currentPoint.y;
 	pathLine.rotation = angle;