/**** 
* 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 = 300;
		self.range = 500;
		self.cost = 70;
	} else if (type === 'ice') {
		self.damage = 50;
		self.range = 500;
		self.cost = 70;
	} else if (type === 'lightning') {
		self.damage = 200;
		self.range = 500;
		self.cost = 70;
	} else if (type === 'beam') {
		self.damage = 10;
		self.range = 500;
		self.cost = 150;
		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 baseDamage = self.isUpgraded ? 15 : 10;
					var currentDamage;
					if (timeElapsed < 1) {
						currentDamage = baseDamage;
					} else if (timeElapsed < 2) {
						currentDamage = baseDamage * 10;
					} else if (timeElapsed < 3) {
						currentDamage = baseDamage * 30;
					} else if (timeElapsed < 4) {
						currentDamage = baseDamage * 50;
					} else {
						currentDamage = baseDamage * 100;
					}
					// 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.2 : 0.4);
		}
	};
	self.upgrade = function () {
		if (self.isUpgraded) return false;
		if (playerGold >= 100) {
			playerGold -= 100;
			self.isUpgraded = true;
			if (self.type === 'fire') {
				self.damage = Math.floor(self.damage * 1.5);
				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.88;
	self.slowEffect = 1;
	self.slowDuration = 0;
	if (type === 'regularSkeleton') {
		self.maxHealth = 300;
		self.goldValue = 10;
	} else if (type === 'shieldedSkeleton') {
		self.maxHealth = 1000;
		self.goldValue = 15;
	} else if (type === 'fastSkeleton') {
		self.maxHealth = 300;
		self.goldValue = 10;
		self.speed = 1.76; // 100% faster than regular (0.88 * 2)
	} else if (type === 'giantSkeleton') {
		self.maxHealth = 5000;
		self.goldValue = 100;
	} else if (type === 'witchBoss') {
		self.maxHealth = 15000;
		self.goldValue = 50;
	}
	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: 1200
}, {
	x: 1800,
	y: 1200
}, {
	x: 1600,
	y: 1000
}, {
	x: 1400,
	y: 800
}, {
	x: 1200,
	y: 600
}, {
	x: 1000,
	y: 400
}, {
	x: 800,
	y: 600
}, {
	x: 600,
	y: 800
}, {
	x: 400,
	y: 1000
}, {
	x: 200,
	y: 1200
}, {
	x: 0,
	y: 1200
}];
var placementPositions = [{
	x: 1700,
	y: 900
}, {
	x: 1500,
	y: 700
}, {
	x: 1300,
	y: 500
}, {
	x: 1100,
	y: 300
}, {
	x: 900,
	y: 500
}, {
	x: 700,
	y: 700
}, {
	x: 500,
	y: 900
}, {
	x: 300,
	y: 1100
}, {
	x: 1900,
	y: 1100
}, {
	x: 1100,
	y: 1300
}];
// Create path
for (var i = 0; i < pathPoints.length; i++) {
	var pathSegment = game.addChild(LK.getAsset('path', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 0.8,
		scaleY: 0.8
	}));
	pathSegment.x = pathPoints[i].x;
	pathSegment.y = pathPoints[i].y;
}
// 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\n70g', {
	size: 30,
	fill: 0xFFFFFF
}));
fireButtonText.anchor.set(0.5, 0.5);
var iceButtonText = iceButton.addChild(new Text2('Ice\n70g', {
	size: 30,
	fill: 0xFFFFFF
}));
iceButtonText.anchor.set(0.5, 0.5);
var lightningButtonText = lightningButton.addChild(new Text2('Lightning\n70g', {
	size: 30,
	fill: 0xFFFFFF
}));
lightningButtonText.anchor.set(0.5, 0.5);
var beamButtonText = beamButton.addChild(new Text2('Beam\n150g', {
	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\n100g');
	} else {
		upgradeButtonText.setText('Upgrade\nSelect');
	}
}
function placeDragon(type, x, y, zoneIndex) {
	var cost = type === 'beam' ? 150 : 70;
	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 = 20;
	} else if (currentWave === 2) {
		enemyType = 'shieldedSkeleton';
		waveSize = 20;
	} else if (currentWave === 3) {
		enemyType = 'fastSkeleton';
		waveSize = 20;
	} else if (currentWave === 4) {
		if (waveSpawnIndex < 20) {
			enemyType = 'shieldedSkeleton';
		} else if (waveSpawnIndex < 40) {
			enemyType = 'regularSkeleton';
		} else {
			enemyType = 'fastSkeleton';
		}
		waveSize = 60;
	} 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 = 20;
		} else if (currentWave === 4) {
			expectedWaveSize = 60;
		} 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 ? [baseDamage, baseDamage * 0.7, baseDamage * 0.5, baseDamage * 0.3, baseDamage * 0.2] : [baseDamage, baseDamage * 0.5, baseDamage * 0.25];
	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 >= 70) {
		selectedDragonType = selectedDragonType === 'fire' ? null : 'fire';
		updateButtonHighlights();
	}
};
iceButton.down = function () {
	if (gameState === 'playing' && playerGold >= 70) {
		selectedDragonType = selectedDragonType === 'ice' ? null : 'ice';
		updateButtonHighlights();
	}
};
lightningButton.down = function () {
	if (gameState === 'playing' && playerGold >= 70) {
		selectedDragonType = selectedDragonType === 'lightning' ? null : 'lightning';
		updateButtonHighlights();
	}
};
beamButton.down = function () {
	if (gameState === 'playing' && playerGold >= 150) {
		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++;
		if (waveSpawnTimer >= 120) {
			spawnEnemy();
			waveSpawnTimer = 0;
		}
	}
	// Check if wave is complete - only after all enemies are spawned
	var expectedWaveSize;
	if (currentWave === 1 || currentWave === 2 || currentWave === 3) {
		expectedWaveSize = 20;
	} else if (currentWave === 4) {
		expectedWaveSize = 60;
	} else if (currentWave === 5) {
		expectedWaveSize = 3;
	}
	if (waveInProgress && waveSpawnIndex >= expectedWaveSize) {
		if (enemies.length === 0) {
			checkWaveComplete();
		}
	}
};

===================================================================
--- original.js
+++ change.js
@@ -235,8 +235,12 @@
 		self.goldValue = 10;
 	} else if (type === 'shieldedSkeleton') {
 		self.maxHealth = 1000;
 		self.goldValue = 15;
+	} else if (type === 'fastSkeleton') {
+		self.maxHealth = 300;
+		self.goldValue = 10;
+		self.speed = 1.76; // 100% faster than regular (0.88 * 2)
 	} else if (type === 'giantSkeleton') {
 		self.maxHealth = 5000;
 		self.goldValue = 100;
 	} else if (type === 'witchBoss') {
@@ -575,8 +579,20 @@
 	} else if (currentWave === 2) {
 		enemyType = 'shieldedSkeleton';
 		waveSize = 20;
 	} else if (currentWave === 3) {
+		enemyType = 'fastSkeleton';
+		waveSize = 20;
+	} else if (currentWave === 4) {
+		if (waveSpawnIndex < 20) {
+			enemyType = 'shieldedSkeleton';
+		} else if (waveSpawnIndex < 40) {
+			enemyType = 'regularSkeleton';
+		} else {
+			enemyType = 'fastSkeleton';
+		}
+		waveSize = 60;
+	} else if (currentWave === 5) {
 		if (waveSpawnIndex < 2) {
 			enemyType = 'giantSkeleton';
 		} else {
 			enemyType = 'witchBoss';
@@ -591,12 +607,19 @@
 }
 function checkWaveComplete() {
 	if (waveInProgress && enemies.length === 0) {
 		// Only complete wave if all enemies have been spawned
-		var expectedWaveSize = currentWave === 3 ? 3 : 20;
+		var expectedWaveSize;
+		if (currentWave === 1 || currentWave === 2 || currentWave === 3) {
+			expectedWaveSize = 20;
+		} else if (currentWave === 4) {
+			expectedWaveSize = 60;
+		} else if (currentWave === 5) {
+			expectedWaveSize = 3;
+		}
 		if (waveSpawnIndex >= expectedWaveSize) {
 			waveInProgress = false;
-			if (currentWave >= 3) {
+			if (currentWave >= 5) {
 				gameState = 'victory';
 				LK.showYouWin();
 			} else {
 				currentWave++;
@@ -719,9 +742,17 @@
 			waveSpawnTimer = 0;
 		}
 	}
 	// Check if wave is complete - only after all enemies are spawned
-	if (waveInProgress && waveSpawnIndex >= (currentWave === 3 ? 3 : 20)) {
+	var expectedWaveSize;
+	if (currentWave === 1 || currentWave === 2 || currentWave === 3) {
+		expectedWaveSize = 20;
+	} else if (currentWave === 4) {
+		expectedWaveSize = 60;
+	} else if (currentWave === 5) {
+		expectedWaveSize = 3;
+	}
+	if (waveInProgress && waveSpawnIndex >= expectedWaveSize) {
 		if (enemies.length === 0) {
 			checkWaveComplete();
 		}
 	}