/**** 
* 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();
		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 = 362;
		self.range = 500;
		self.cost = 120;
	} else if (type === 'lightning') {
		self.damage = 400;
		self.range = 500;
		self.cost = 200;
	} else if (type === 'beam') {
		self.damage = 10;
		self.range = 500;
		self.cost = 700;
		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) {
					// Create or update beam visual effect
					if (!self.beamLaser) {
						self.beamLaser = game.addChild(LK.getAsset('beamLaser', {
							anchorX: 0,
							anchorY: 0.5
						}));
					}
					// Position and rotate the beam
					self.beamLaser.x = self.x;
					self.beamLaser.y = self.y;
					var angle = Math.atan2(dy, dx);
					self.beamLaser.rotation = angle;
					self.beamLaser.width = distance;
					// 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;
					if (self.beamLaser) {
						self.beamLaser.destroy();
						self.beamLaser = null;
					}
				}
			} else {
				self.beamTarget = null;
				if (self.beamLaser) {
					self.beamLaser.destroy();
					self.beamLaser = 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();
		if (self.type === 'lightning') {
			// Create visible lightning bullet
			var bullet = new Bullet(self.type, 0, target, false);
			bullet.x = self.x;
			bullet.y = self.y;
			bullets.push(bullet);
			game.addChild(bullet);
			// New lightning system: single target, double hit
			var firstDamage = self.isUpgraded ? 750 : 500;
			var secondDamage = self.isUpgraded ? 1250 : 1000;
			// Apply first damage immediately
			target.takeDamage(firstDamage);
			LK.getSound('enemyHit').play();
			LK.effects.flashObject(target, 0xffff00, 200);
			// Schedule second damage after 1 second with freeze effect
			LK.setTimeout(function () {
				if (target && target.health > 0) {
					target.takeDamage(secondDamage);
					LK.getSound('enemyHit').play();
					LK.effects.flashObject(target, 0xffff00, 200);
					// Freeze target for 1 second
					target.applySlowEffect(0);
					target.slowDuration = 60; // 1 second at 60fps
				}
			}, 1000);
		} else {
			var bullet = new Bullet(self.type, self.damage, target, false);
			bullet.x = self.x;
			bullet.y = self.y;
			bullets.push(bullet);
			game.addChild(bullet);
		}
		if (self.type === 'ice') {
			target.applySlowEffect(self.isUpgraded ? 0.50 : 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.95; // Regular skeleton speed 1.50 * 1.30 = 1.95 meter/second
	} else if (type === 'shieldedSkeleton') {
		self.maxHealth = 3000; // Increased by 50%
		self.goldValue = 25;
		self.speed = 1.30; // Shielded skeleton speed 1.0 * 1.30 = 1.30 meter/second
	} else if (type === 'fastSkeleton') {
		self.maxHealth = 2250; // Increased by 50%
		self.goldValue = 30;
		self.speed = 3.90; // Fast skeleton speed 3.0 * 1.30 = 3.90 meter/second
	} else if (type === 'giantSkeleton') {
		self.maxHealth = 20000;
		self.goldValue = 100;
		self.speed = 1.30; // Giant skeleton speed 1.0 * 1.30 = 1.30 meter/second
	} else if (type === 'witchBoss') {
		self.maxHealth = 80000;
		self.goldValue = 50;
		self.speed = 1.30; // Witch boss speed 1.0 * 1.30 = 1.30 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 () {
		// Only giant skeletons and witch bosses cause immediate game over
		if (self.type === 'giantSkeleton' || self.type === 'witchBoss') {
			gameState = 'gameOver';
			LK.showGameOver();
		} else {
			// Regular skeletons reduce lives by 1
			playerLives--;
			updateLivesDisplay();
			if (playerLives <= 0) {
				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 = 5;
var currentWave = 1;
var waveInProgress = false;
var selectedDragon = null;
var dragons = [];
var enemies = [];
var bullets = [];
var placementZones = [];
var pathPoints = [{
	x: 2048,
	y: 1500
}, {
	x: 1400,
	y: 1500
}, {
	x: 1000,
	y: 1200
}, {
	x: 700,
	y: 800
}, {
	x: 1000,
	y: 400
}, {
	x: 1400,
	y: 700
}, {
	x: 1000,
	y: 1000
}, {
	x: 600,
	y: 1300
}, {
	x: 0,
	y: 1500
}];
var placementPositions = [{
	// Near entrance area
	x: 1600,
	y: 1450
}, {
	// Upper right strategic position
	x: 1550,
	y: 1200
}, {
	// Mid-path right side
	x: 1250,
	y: 1350
}, {
	// Lower mid right
	x: 950,
	y: 1150
}, {
	// Center strategic position
	x: 750,
	y: 950
}, {
	// Left side mid
	x: 550,
	y: 750
}, {
	// Upper left strategic
	x: 850,
	y: 500
}, {
	// Far upper position
	x: 1200,
	y: 200
}, {
	// Upper mid strategic
	x: 1000,
	y: 400
}, {
	// Right upper curve
	x: 1500,
	y: 750
}, {
	// Left strategic covering exit
	x: 400,
	y: 1300
}, {
	// Final exit coverage
	x: 300,
	y: 1050
}];
// 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;
}
// Placement zones removed - dragons can be placed anywhere valid
// 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: 5', {
	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\n200g', {
	size: 30,
	fill: 0xFFFFFF
}));
lightningButtonText.anchor.set(0.5, 0.5);
var beamButtonText = beamButton.addChild(new Text2('Beam\n700g', {
	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 = 200;else if (type === 'beam') cost = 700;
	if (playerGold >= cost) {
		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();
			}
		}
	}
}
// Helper function to check if position is on path
function isOnPath(x, y) {
	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);
		// Calculate distance from point to line segment
		var A = x - currentPoint.x;
		var B = y - currentPoint.y;
		var C = dx;
		var D = dy;
		var dot = A * C + B * D;
		var lenSq = C * C + D * D;
		var param = -1;
		if (lenSq !== 0) {
			param = dot / lenSq;
		}
		var xx, yy;
		if (param < 0) {
			xx = currentPoint.x;
			yy = currentPoint.y;
		} else if (param > 1) {
			xx = nextPoint.x;
			yy = nextPoint.y;
		} else {
			xx = currentPoint.x + param * C;
			yy = currentPoint.y + param * D;
		}
		var distToPath = Math.sqrt((x - xx) * (x - xx) + (y - yy) * (y - yy));
		if (distToPath < 80) {
			// Path thickness consideration
			return true;
		}
	}
	return false;
}
// Game click handler for dragon placement
game.down = function (x, y, obj) {
	if (gameState === 'playing' && selectedDragonType) {
		// Check if position is valid (not on path and no existing dragon)
		if (!isOnPath(x, y)) {
			var hasExistingDragon = false;
			for (var i = 0; i < dragons.length; i++) {
				if (Math.abs(dragons[i].x - x) < 100 && Math.abs(dragons[i].y - y) < 100) {
					hasExistingDragon = true;
					break;
				}
			}
			if (!hasExistingDragon) {
				placeDragon(selectedDragonType, x, y, -1);
			}
		}
	}
};
// 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 >= 200) {
		selectedDragonType = selectedDragonType === 'lightning' ? null : 'lightning';
		updateButtonHighlights();
	}
};
beamButton.down = function () {
	if (gameState === 'playing' && playerGold >= 700) {
		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 ? 24 : 60; // Half the spacing: 48/2 = 24, 120/2 = 60
		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
@@ -58,9 +58,9 @@
 		self.damage = 500;
 		self.range = 500;
 		self.cost = 100;
 	} else if (type === 'ice') {
-		self.damage = 250;
+		self.damage = 362;
 		self.range = 500;
 		self.cost = 120;
 	} else if (type === 'lightning') {
 		self.damage = 400;
@@ -68,9 +68,9 @@
 		self.cost = 200;
 	} else if (type === 'beam') {
 		self.damage = 10;
 		self.range = 500;
-		self.cost = 500;
+		self.cost = 700;
 		self.beamTarget = null;
 		self.beamDamageMultiplier = 1;
 		self.beamStartTime = 0;
 		self.shootInterval = 100; // Beam updates faster
@@ -564,9 +564,9 @@
 	size: 30,
 	fill: 0xFFFFFF
 }));
 lightningButtonText.anchor.set(0.5, 0.5);
-var beamButtonText = beamButton.addChild(new Text2('Beam\n500g', {
+var beamButtonText = beamButton.addChild(new Text2('Beam\n700g', {
 	size: 30,
 	fill: 0xFFFFFF
 }));
 beamButtonText.anchor.set(0.5, 0.5);
@@ -600,9 +600,9 @@
 	}
 }
 function placeDragon(type, x, y, zoneIndex) {
 	var cost;
-	if (type === 'fire') cost = 100;else if (type === 'ice') cost = 120;else if (type === 'lightning') cost = 200;else if (type === 'beam') cost = 500;
+	if (type === 'fire') cost = 100;else if (type === 'ice') cost = 120;else if (type === 'lightning') cost = 200;else if (type === 'beam') cost = 700;
 	if (playerGold >= cost) {
 		playerGold -= cost;
 		updateGoldDisplay();
 		var dragon = game.addChild(new Dragon(type, x, y));
@@ -758,9 +758,9 @@
 		updateButtonHighlights();
 	}
 };
 beamButton.down = function () {
-	if (gameState === 'playing' && playerGold >= 500) {
+	if (gameState === 'playing' && playerGold >= 700) {
 		selectedDragonType = selectedDragonType === 'beam' ? null : 'beam';
 		updateButtonHighlights();
 	}
 };