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

/**** 
* Classes
****/ 
var Building = Container.expand(function (id, size) {
	var self = Container.call(this);
	self.id = id || 'default';
	self.size = size || {
		w: 2,
		h: 2
	};
	var assetId = 'building_' + self.id;
	var baseGraphics = self.attachAsset(assetId, {
		anchorX: 0,
		anchorY: 0
	});
	baseGraphics.width = CELL_SIZE * self.size.w;
	baseGraphics.height = CELL_SIZE * self.size.h;
	baseGraphics.tint = 0xFFFFFF;
	baseGraphics.alpha = 1;
	self.down = function () {
		if (isMenuTransitioning) {
			return;
		}
		game.children.forEach(function (child) {
			if (child instanceof BuildingInfoMenu) {
				hideBuildingInfoMenu(child);
			}
		});
		if (selectedBuilding === self) {
			selectedBuilding = null;
			return;
		}
		selectedBuilding = self;
		var menu = game.addChild(new BuildingInfoMenu(self));
		menu.x = 2048 / 2;
		isMenuTransitioning = true;
		tween(menu, {
			y: 2732 - 250
		}, {
			duration: 200,
			easing: tween.backOut,
			onFinish: function onFinish() {
				isMenuTransitioning = false;
			}
		});
	};
	return self;
});
var BuildingInfoMenu = Container.expand(function (building) {
	var self = Container.call(this);
	self.building = building;
	self.y = 2732 + 225;
	var menuBackground = self.attachAsset('panel_popup_background', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	menuBackground.width = 2048;
	menuBackground.height = 500;
	var closeButton = new Container();
	var closeBackground = closeButton.attachAsset('notification', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 90,
		height: 90,
		tint: 0xAA0000
	});
	var closeText = new Text2('X', {
		size: 68,
		fill: 0xFFFFFF,
		weight: 800
	});
	closeText.anchor.set(0.5, 0.5);
	closeButton.addChild(closeText);
	closeButton.x = menuBackground.width / 2 - 57;
	closeButton.y = -menuBackground.height / 2 + 57;
	self.addChild(closeButton);
	closeButton.down = function () {
		hideBuildingInfoMenu(self);
	};
	var originalDestroy = self.destroy;
	self.destroy = function () {
		if (selectedBuilding === self.building) {
			selectedBuilding = null;
		}
		originalDestroy.call(self);
	};
	return self;
});
/**** * Classes
****/ 
var Bullet = Container.expand(function (startX, startY, targetEnemy, props) {
	var self = Container.call(this);
	self.targetEnemy = targetEnemy;
	self.props = props;
	self.x = startX;
	self.y = startY;
	self.isAnimated = Array.isArray(self.props.graphic);
	self.allFrames = [];
	if (self.isAnimated) {
		var frameNames = self.props.graphic;
		for (var i = 0; i < frameNames.length; i++) {
			var frameSprite = self.attachAsset(frameNames[i], {
				anchorX: 0.5,
				anchorY: 0.5
			});
			frameSprite.visible = false;
			self.allFrames.push(frameSprite);
		}
		self.currentFrame = 0;
		self.frameDuration = 4;
		self.frameTicker = 0;
		if (self.allFrames.length > 0) {
			self.allFrames[self.currentFrame].visible = true;
		}
	} else {
		var bulletGraphics = self.attachAsset(self.props.graphic || 'bullet', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		if (self.props.bulletType === 'chain') {
			bulletGraphics.visible = false;
		}
		self.allFrames.push(bulletGraphics);
	}
	if (self.props.bulletType === 'splash') {
		self.allFrames[0].tint = 0xFF8C00;
	}
	if (self.props.bulletType === 'slow') {
		self.allFrames.forEach(function (frame) {
			frame.tint = 0xADD8E6;
		});
	}
	self.update = function () {
		if (!self.targetEnemy || !self.targetEnemy.parent || self.targetEnemy.health <= 0) {
			self.destroy();
			return;
		}
		var dx = self.targetEnemy.x - self.x;
		var dy = self.targetEnemy.y - self.y;
		var angle = Math.atan2(dy, dx);
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (self.isAnimated) {
			self.frameTicker++;
			if (self.frameTicker >= self.frameDuration) {
				self.frameTicker = 0;
				self.allFrames[self.currentFrame].visible = false;
				self.currentFrame = (self.currentFrame + 1) % self.allFrames.length;
				self.allFrames[self.currentFrame].visible = true;
			}
		}
		self.allFrames.forEach(function (frame) {
			if (self.props.graphic === 'projectile_fireball') {
				frame.rotation += 0.2;
			} else {
				frame.rotation = angle;
			}
		});
		if (distance < self.props.bulletSpeed) {
			self.targetEnemy.takeDamage(self.props.damage);
			switch (self.props.bulletType) {
				case 'slow':
					if (Math.random() < self.props.slowChance) {
						if (self.targetEnemy.slowDuration <= 0) {
							self.targetEnemy.originalTint = self.targetEnemy.children[0].tint;
						}
						self.targetEnemy.children[0].tint = 0xADD8E6;
						self.targetEnemy.slowDuration = self.props.slowDuration;
						self.targetEnemy.slowFactor = self.props.slowAmount;
					}
					break;
				case 'splash':
					spellEffectLayer.addChild(new Explosion(self.x, self.y, self.props.splashScale));
					enemies.forEach(function (enemy) {
						if (enemy !== self.targetEnemy) {
							var distToSplash = Math.sqrt(Math.pow(self.x - enemy.x, 2) + Math.pow(self.y - enemy.y, 2));
							if (distToSplash < self.props.splashRadius) {
								enemy.takeDamage(self.props.splashDamage);
							}
						}
					});
					break;
				case 'chain':
					spellEffectLayer.addChild(new LightningStrikeEffect(self.x, self.y));
					if (Math.random() < self.props.chainChance) {
						var chainedTargets = [self.targetEnemy];
						var lastTarget = self.targetEnemy;
						var damage = self.props.damage;
						for (var i = 0; i < self.props.chainTargets; i++) {
							damage -= self.props.chainDamageFalloff;
							if (damage <= 0) {
								break;
							}
							var nextTarget = null;
							var minChainDist = Infinity;
							enemies.forEach(function (enemy) {
								if (!chainedTargets.includes(enemy)) {
									var distToChain = Math.sqrt(Math.pow(lastTarget.x - enemy.x, 2) + Math.pow(lastTarget.y - enemy.y, 2));
									if (distToChain < self.props.range / 2 && distToChain < minChainDist) {
										minChainDist = distToChain;
										nextTarget = enemy;
									}
								}
							});
							if (nextTarget) {
								nextTarget.takeDamage(damage);
								spellEffectLayer.addChild(new ChainLightningVisual(lastTarget, nextTarget));
								chainedTargets.push(nextTarget);
								lastTarget = nextTarget;
							} else {
								break;
							}
						}
					}
					break;
			}
			self.destroy();
		} else {
			self.x += Math.cos(angle) * self.props.bulletSpeed;
			self.y += Math.sin(angle) * self.props.bulletSpeed;
		}
	};
	return self;
});
var ChainLightningVisual = Container.expand(function (sourceEnemy, targetEnemy) {
	var self = Container.call(this);
	var dx = targetEnemy.x - sourceEnemy.x;
	var dy = targetEnemy.y - sourceEnemy.y;
	var distance = Math.sqrt(dx * dx + dy * dy);
	var angle = Math.atan2(dy, dx);
	self.x = sourceEnemy.x;
	self.y = sourceEnemy.y;
	self.rotation = angle;
	var frameNames = [];
	for (var i = 1; i <= 4; i++) {
		frameNames.push('chain_lightning_' + i);
	}
	var allFrames = [];
	for (var i = 0; i < frameNames.length; i++) {
		var frameSprite = self.attachAsset(frameNames[i], {
			anchorX: 0,
			anchorY: 0.5,
			width: distance,
			height: 80
		});
		frameSprite.blendMode = 1;
		frameSprite.visible = false;
		allFrames.push(frameSprite);
	}
	var currentFrame = 0;
	var frameDuration = 6;
	var frameTicker = 0;
	if (allFrames.length > 0) {
		allFrames[currentFrame].visible = true;
	}
	self.update = function () {
		frameTicker++;
		if (frameTicker >= frameDuration) {
			frameTicker = 0;
			if (allFrames[currentFrame]) {
				allFrames[currentFrame].visible = false;
			}
			currentFrame++;
			if (currentFrame >= allFrames.length) {
				self.destroy();
			} else {
				if (allFrames[currentFrame]) {
					allFrames[currentFrame].visible = true;
				}
			}
		}
	};
	return self;
});
var CurseEffect = Container.expand(function (x, y, spellData) {
	var self = Container.call(this);
	self.x = x;
	self.y = y;
	var radius = spellData.radius;
	var radiusSq = radius * radius;
	var duration = spellData.duration;
	var isFadingOut = false;
	var effectGraphics = self.attachAsset('curse_effect_circle', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: radius * 2,
		height: radius * 2
	});
	effectGraphics.alpha = 0;
	tween(effectGraphics, {
		alpha: 0.8
	}, {
		duration: 500
	});
	self.update = function () {
		if (isFadingOut) {
			return;
		}
		duration--;
		if (duration <= 0) {
			isFadingOut = true;
			tween(self, {
				alpha: 0
			}, {
				duration: 500,
				onFinish: function onFinish() {
					self.destroy();
				}
			});
			return;
		}
		effectGraphics.rotation -= 0.005;
		enemies.forEach(function (enemy) {
			var dx = enemy.x - self.x;
			var dy = enemy.y - self.y;
			if (dx * dx + dy * dy < radiusSq) {
				enemy.isCursed = true;
				enemy.curseTimer = 120;
				enemy.damageTakenMultiplier = spellData.damageMultiplier;
				enemy.slowFactor = Math.min(enemy.slowFactor, spellData.slowFactor);
			}
		});
	};
	return self;
});
var DebugCell = Container.expand(function () {
	var self = Container.call(this);
	var cellGraphics = self.attachAsset('cell', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	cellGraphics.tint = Math.random() * 0xffffff;
	var debugArrows = [];
	var numberLabel = new Text2('0', {
		size: 30,
		fill: 0xFFFFFF,
		weight: 800
	});
	numberLabel.anchor.set(.5, .5);
	self.addChild(numberLabel);
	self.update = function () {};
	self.down = function () {
		return;
		if (self.cell.type == 0 || self.cell.type == 1) {
			self.cell.type = self.cell.type == 1 ? 0 : 1;
			if (grid.pathFind()) {
				self.cell.type = self.cell.type == 1 ? 0 : 1;
				grid.pathFind();
				var notification = game.addChild(new Notification("Path is blocked!"));
				notification.x = 2048 / 2;
				notification.y = grid.height - 50;
			}
			grid.renderDebug();
		}
	};
	self.removeArrows = function () {
		while (debugArrows.length) {
			self.removeChild(debugArrows.pop());
		}
	};
	self.render = function (data) {
		switch (data.type) {
			case 0:
			case 2:
				{
					if (data.pathId != pathId) {
						self.removeArrows();
						numberLabel.setText("-");
						cellGraphics.tint = 0x880000;
						return;
					}
					numberLabel.visible = true;
					var tint = Math.floor(data.score / maxScore * 0x88);
					var towerInRangeHighlight = false;
					if (selectedTower && data.towersInRange && data.towersInRange.indexOf(selectedTower) !== -1) {
						towerInRangeHighlight = true;
						cellGraphics.tint = 0x0088ff;
					} else {
						cellGraphics.tint = 0x88 - tint << 8 | tint;
					}
					while (debugArrows.length > data.targets.length) {
						self.removeChild(debugArrows.pop());
					}
					for (var a = 0; a < data.targets.length; a++) {
						var destination = data.targets[a];
						var ox = destination.x - data.x;
						var oy = destination.y - data.y;
						var angle = Math.atan2(oy, ox);
						if (!debugArrows[a]) {
							debugArrows[a] = LK.getAsset('arrow', {
								anchorX: -.5,
								anchorY: 0.5
							});
							debugArrows[a].alpha = .5;
							self.addChildAt(debugArrows[a], 1);
						}
						debugArrows[a].rotation = angle;
					}
					break;
				}
			case 1:
				{
					self.removeArrows();
					cellGraphics.tint = 0xaaaaaa;
					numberLabel.visible = false;
					break;
				}
			case 3:
				{
					self.removeArrows();
					cellGraphics.tint = 0x008800;
					numberLabel.visible = false;
					break;
				}
		}
		numberLabel.setText(Math.floor(data.score / 1000) / 10);
	};
});
var EffectIndicator = Container.expand(function (x, y, type) {
	var self = Container.call(this);
	self.x = x;
	self.y = y;
	var effectGraphics = self.attachAsset('rangeCircle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	effectGraphics.blendMode = 1;
	switch (type) {
		case 'splash':
			effectGraphics.tint = 0x33CC00;
			effectGraphics.width = effectGraphics.height = CELL_SIZE * 1.5;
			break;
		case 'slow':
			effectGraphics.tint = 0x9900FF;
			effectGraphics.width = effectGraphics.height = CELL_SIZE;
			break;
		case 'poison':
			effectGraphics.tint = 0x00FFAA;
			effectGraphics.width = effectGraphics.height = CELL_SIZE;
			break;
		case 'sniper':
			effectGraphics.tint = 0xFF5500;
			effectGraphics.width = effectGraphics.height = CELL_SIZE;
			break;
	}
	effectGraphics.alpha = 0.7;
	self.alpha = 0;
	tween(self, {
		alpha: 0.8,
		scaleX: 1.5,
		scaleY: 1.5
	}, {
		duration: 200,
		easing: tween.easeOut,
		onFinish: function onFinish() {
			tween(self, {
				alpha: 0,
				scaleX: 2,
				scaleY: 2
			}, {
				duration: 300,
				easing: tween.easeIn,
				onFinish: function onFinish() {
					self.destroy();
				}
			});
		}
	});
	return self;
});
var Enemy = Container.expand(function (type, spawnerId, laneId) {
	var self = Container.call(this);
	self.type = type || 'normal';
	self.spawnerId = spawnerId;
	self.laneId = laneId;
	self.laneOffset = 0; // NOWA WŁAŚCIWOŚĆ
	self.speed = 0.01;
	self.originalSpeed = self.speed;
	self.slowDuration = 0;
	self.slowFactor = 1;
	self.isCursed = false;
	self.curseTimer = 0;
	self.damageTakenMultiplier = 1;
	self.isBurning = false;
	self.burnDuration = 0;
	self.burnDamage = 0;
	self.lastBurnTick = 0;
	self.isStunned = false;
	self.stunTimer = 0;
	self.originalTint = 0xFFFFFF;
	self.cellX = 0;
	self.cellY = 0;
	self.currentTarget = undefined;
	self.maxHealth = 78;
	self.health = self.maxHealth;
	self.waveNumber = currentWave;
	self.isFlying = false;
	self.isBoss = false;
	self.isRanged = false;
	self.manaCategory = 'strong';
	self.damage = 10;
	self.attackSpeed = 120;
	self.lastAttack = 0;
	self.range = 1.5 * CELL_SIZE;
	self.targetUnit = null;
	self.goldValue = 10;
	switch (self.type) {
		case 'shield':
			self.maxHealth = 94;
			self.damage = 3;
			self.manaCategory = 'strong';
			self.goldValue = 36;
			break;
		case 'rider':
			self.maxHealth = 78;
			self.damage = 6;
			self.speed *= 1.5;
			self.manaCategory = 'strong';
			self.goldValue = 59;
			break;
		case 'chieftain':
			self.maxHealth = 524;
			self.damage = 10;
			self.isBoss = true;
			self.manaCategory = 'boss';
			self.goldValue = 304;
			break;
		case 'archer':
			self.maxHealth = 31;
			self.damage = 7;
			self.attackSpeed = 48;
			self.isRanged = true;
			self.range = 6 * CELL_SIZE;
			self.manaCategory = 'strong';
			self.goldValue = 34;
			break;
		default:
			self.maxHealth = 62;
			self.damage = 4;
			self.manaCategory = 'weak';
			self.goldValue = 19;
			break;
	}
	self.originalSpeed = self.speed;
	self.health = self.maxHealth;
	var enemyGraphics = self.attachAsset('orc_' + self.type, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var healthBarOutline = self.attachAsset('healthBarOutline', {
		anchorX: 0,
		anchorY: 0.5
	});
	var healthBarBG = self.attachAsset('healthBar', {
		anchorX: 0,
		anchorY: 0.5
	});
	var healthBar = self.attachAsset('healthBar', {
		anchorX: 0,
		anchorY: 0.5
	});
	healthBarBG.y = healthBarOutline.y = healthBar.y = -enemyGraphics.height / 2 - 10;
	healthBarOutline.x = -healthBarOutline.width / 2;
	healthBarBG.x = healthBar.x = -healthBar.width / 2 - .5;
	healthBar.tint = 0x00ff00;
	healthBarBG.tint = 0xff0000;
	self.healthBar = healthBar;
	self.takeDamage = function (amount) {
		self.health -= amount * self.damageTakenMultiplier;
		if (self.health < 0) {
			self.health = 0;
		}
		self.healthBar.width = self.health / self.maxHealth * 70;
	};
	self.findTarget = function () {
		if (self.isFlying) {
			return null;
		}
		var closestUnit = null;
		var minDistance = self.range * self.range;
		for (var i = 0; i < friendlyUnits.length; i++) {
			var unit = friendlyUnits[i];
			var dx = unit.x - self.x;
			var dy = unit.y - self.y;
			var distanceSq = dx * dx + dy * dy;
			if (distanceSq < minDistance) {
				minDistance = distanceSq;
				closestUnit = unit;
			}
		}
		return closestUnit;
	};
	self.attack = function () {
		if (!self.targetUnit || self.targetUnit.health <= 0) {
			return;
		}
		if (self.isRanged) {
			self.fireProjectile();
			return;
		}
		self.targetUnit.takeDamage(self.damage);
		var angle = Math.atan2(self.targetUnit.y - self.y, self.targetUnit.x - self.x);
		var recoilDistance = 5;
		var originalX = self.targetUnit.x;
		var originalY = self.targetUnit.y;
		tween(self.targetUnit, {
			x: originalX + Math.cos(angle) * recoilDistance,
			y: originalY + Math.sin(angle) * recoilDistance
		}, {
			duration: 80,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				if (self.targetUnit) {
					tween(self.targetUnit, {
						x: originalX,
						y: originalY
					}, {
						duration: 120,
						easing: tween.easeIn
					});
				}
			}
		});
		var unitGraphics = self.targetUnit.children[0];
		if (unitGraphics) {
			var originalTint = unitGraphics.tint;
			unitGraphics.tint = 0xFF0000;
			LK.setTimeout(function () {
				if (unitGraphics && !unitGraphics.destroyed) {
					unitGraphics.tint = originalTint;
				}
			}, 100);
		}
		createHitSparks(self.targetUnit.x, self.targetUnit.y);
	};
	self.update = function () {
		if (self.isStunned) {
			self.stunTimer--;
			if (self.stunTimer <= 0) {
				self.isStunned = false;
			}
			return false;
		}
		self.speed = self.originalSpeed;
		if (self.slowDuration > 0) {
			self.slowDuration--;
			self.speed *= self.slowFactor;
			if (self.slowDuration <= 0) {
				self.slowFactor = 1;
				enemyGraphics.tint = self.originalTint;
			}
		}
		if (self.isCursed) {
			self.curseTimer--;
			if (self.curseTimer <= 0) {
				self.isCursed = false;
				self.damageTakenMultiplier = 1;
			} else {
				self.speed *= self.slowFactor;
			}
		}
		if (self.isBurning) {
			if (LK.ticks - self.lastBurnTick >= 60) {
				self.takeDamage(self.burnDamage);
				self.lastBurnTick = LK.ticks;
			}
			self.burnDuration--;
			if (self.burnDuration <= 0) {
				self.isBurning = false;
			}
		}
		if (self.health <= 0) {
			self.health = 0;
			self.healthBar.width = 0;
			return false;
		}
		self.targetUnit = self.findTarget();
		var combatSpeedInPixels = self.speed * CELL_SIZE * 1.2;
		if (self.targetUnit && self.targetUnit.health > 0) {
			var dx = self.targetUnit.x - self.x;
			var dy = self.targetUnit.y - self.y;
			if (Math.sqrt(dx * dx + dy * dy) < self.range) {
				if (LK.ticks - self.lastAttack >= self.attackSpeed) {
					self.attack();
					self.lastAttack = LK.ticks;
				}
			} else {
				var angle = Math.atan2(dy, dx);
				self.x += Math.cos(angle) * combatSpeedInPixels;
				self.y += Math.sin(angle) * combatSpeedInPixels;
			}
		} else {
			if (grid.updateEnemy(self)) {
				return true;
			}
			if (self.currentTarget) {
				var targetPixelX = grid.x + (self.currentTarget.x + self.laneOffset) * CELL_SIZE + CELL_SIZE / 2;
				var targetPixelY = grid.y + self.currentTarget.y * CELL_SIZE + CELL_SIZE / 2;
				var dx = targetPixelX - self.x;
				var dy = targetPixelY - self.y;
				var dist = Math.sqrt(dx * dx + dy * dy);
				if (dist < combatSpeedInPixels) {
					// NOWA, BARDZIEJ NIEZAWODNA LOGIKA
					if (self.currentTarget.type === 4) {
						return true; // NATYCHMIAST URUCHOM UTRATĘ ŻYCIA
					}
					self.x = targetPixelX;
					self.y = targetPixelY;
					self.cellX = self.currentTarget.x;
					self.cellY = self.currentTarget.y;
					self.currentTarget = null;
				} else {
					var angle = Math.atan2(dy, dx);
					self.x += Math.cos(angle) * combatSpeedInPixels;
					self.y += Math.sin(angle) * combatSpeedInPixels;
				}
			}
		}
		healthBarOutline.y = healthBarBG.y = healthBar.y = -enemyGraphics.height / 2 - 10;
		return false;
	};
	return self;
});
var Explosion = Container.expand(function (x, y, scale) {
	var self = Container.call(this);
	self.x = x;
	self.y = y;
	self.scale.set(scale || 1); // Ustawiamy skalę
	var allFrames = [];
	for (var i = 1; i <= 8; i++) {
		var frameSprite = self.attachAsset('explosion_fire_' + i, {
			anchorX: 0.5,
			anchorY: 0.5
		});
		frameSprite.blendMode = 1;
		frameSprite.visible = false;
		allFrames.push(frameSprite);
	}
	var currentFrame = 0;
	var frameDuration = 5;
	var frameTicker = 0;
	if (allFrames.length > 0) {
		allFrames[currentFrame].visible = true;
	}
	self.update = function () {
		if (allFrames.length === 0) {
			self.destroy();
			return;
		}
		frameTicker++;
		if (frameTicker >= frameDuration) {
			frameTicker = 0;
			allFrames[currentFrame].visible = false;
			currentFrame++;
			if (currentFrame >= allFrames.length) {
				self.destroy();
			} else {
				allFrames[currentFrame].visible = true;
			}
		}
	};
	return self;
});
var FireWall = Container.expand(function (x, y, spellData) {
	var self = Container.call(this);
	self.x = x;
	self.y = y;
	self.spellData = spellData;
	self.duration = self.spellData.duration;
	self.radiusSq = self.spellData.radius * self.spellData.radius;
	var isFadingOut = false;
	self.update = function () {
		if (isFadingOut) {
			return;
		}
		self.duration--;
		if (self.duration <= 0) {
			isFadingOut = true;
			var spellIndex = activeSpells.indexOf(self);
			if (spellIndex !== -1) {
				activeSpells.splice(spellIndex, 1);
			}
			self.destroy();
			return;
		}
		enemies.forEach(function (enemy) {
			if (enemy.isBurning) {
				return;
			}
			var dx = enemy.x - self.x;
			var dy = enemy.y - self.y;
			if (dx * dx + dy * dy < self.radiusSq) {
				enemy.isBurning = true;
				enemy.burnDuration = self.spellData.dotDuration;
				enemy.burnDamage = self.spellData.dotDamage;
			}
		});
	};
	return self;
});
var FireWallVisual = Container.expand(function (x, y, size) {
	var self = Container.call(this);
	self.x = x;
	self.y = y;
	var frameNames = [];
	for (var i = 1; i <= 13; i++) {
		frameNames.push('fire_wall_' + i);
	}
	var allFrames = [];
	for (var i = 0; i < frameNames.length; i++) {
		var frameSprite = self.attachAsset(frameNames[i], {
			anchorX: 0.5,
			anchorY: 0.5,
			width: size,
			height: size
		});
		frameSprite.blendMode = 1;
		frameSprite.visible = false;
		allFrames.push(frameSprite);
	}
	var currentFrame = 0;
	var frameDuration = 7;
	var frameTicker = 0;
	var lifetime = 460;
	if (allFrames.length > 0) {
		allFrames[currentFrame].visible = true;
	}
	self.update = function () {
		lifetime--;
		if (lifetime <= 0) {
			tween(self, {
				alpha: 0
			}, {
				duration: 500,
				onFinish: function onFinish() {
					self.destroy();
				}
			});
			return;
		}
		frameTicker++;
		if (frameTicker >= frameDuration) {
			frameTicker = 0;
			if (allFrames[currentFrame]) {
				allFrames[currentFrame].visible = false;
			}
			currentFrame = (currentFrame + 1) % allFrames.length;
			if (allFrames[currentFrame]) {
				allFrames[currentFrame].visible = true;
			}
		}
	};
	return self;
});
var FriendlyUnit = Container.expand(function (startX, startY, unitStats) {
	var self = Container.call(this);
	self.unitType = unitStats.id || 'swordsman';
	Object.assign(self, unitStats);
	self.x = startX;
	self.y = startY;
	self.health = self.maxHealth;
	self.lastAttack = 0;
	self.targetEnemy = null;
	var assetId = 'unit_' + self.unitType;
	var unitGraphics = self.attachAsset(assetId, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var healthBarOutline = self.attachAsset('healthBarOutline', {
		anchorX: 0,
		anchorY: 0.5
	});
	var healthBarBG = self.attachAsset('healthBar', {
		anchorX: 0,
		anchorY: 0.5
	});
	var healthBar = self.attachAsset('healthBar', {
		anchorX: 0,
		anchorY: 0.5
	});
	healthBarBG.y = healthBarOutline.y = healthBar.y = -unitGraphics.height / 2 - 10;
	healthBarOutline.x = -healthBarOutline.width / 2;
	healthBarBG.x = healthBar.x = -healthBar.width / 2 - .5;
	healthBar.tint = 0x00ff00;
	healthBarBG.tint = 0xff0000;
	self.healthBar = healthBar;
	self.takeDamage = function (amount) {
		self.health -= amount;
		if (self.health < 0) {
			self.health = 0;
		}
		self.healthBar.width = self.health / self.maxHealth * 70;
	};
	self.findClosestEnemy = function () {
		var closestEnemy = null;
		var minDistanceSq = self.detectionRange * self.detectionRange;
		for (var i = 0; i < enemies.length; i++) {
			var enemy = enemies[i];
			if (enemy.isFlying && !self.isRanged) {
				continue;
			}
			var dx = enemy.x - self.x;
			var dy = enemy.y - self.y;
			var distanceSq = dx * dx + dy * dy;
			if (distanceSq < minDistanceSq) {
				minDistanceSq = distanceSq;
				closestEnemy = enemy;
			}
		}
		return closestEnemy;
	};
	self.fireProjectile = function () {
		var bulletProps = {
			damage: self.damage,
			bulletSpeed: 12,
			graphic: 'arrow_unit_archer'
		};
		var bullet = new Bullet(self.x, self.y, self.targetEnemy, bulletProps);
		gateContainer.addChild(bullet);
		bullets.push(bullet);
	};
	self.attack = function () {
		if (!self.targetEnemy || self.targetEnemy.health <= 0) {
			return;
		}
		if (self.isRanged) {
			self.fireProjectile();
			return;
		}
		self.targetEnemy.takeDamage(self.damage);
		var angle = Math.atan2(self.targetEnemy.y - self.y, self.targetEnemy.x - self.x);
		var recoilDistance = 5;
		var originalX = self.targetEnemy.x;
		var originalY = self.targetEnemy.y;
		tween(self.targetEnemy, {
			x: originalX + Math.cos(angle) * recoilDistance,
			y: originalY + Math.sin(angle) * recoilDistance
		}, {
			duration: 80,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				if (self.targetEnemy) {
					tween(self.targetEnemy, {
						x: originalX,
						y: originalY
					}, {
						duration: 120,
						easing: tween.easeIn
					});
				}
			}
		});
		var enemyGraphics = self.targetEnemy.children[0];
		if (enemyGraphics) {
			var originalTint = enemyGraphics.tint;
			enemyGraphics.tint = 0xFF0000;
			LK.setTimeout(function () {
				if (enemyGraphics && !enemyGraphics.destroyed) {
					enemyGraphics.tint = originalTint;
				}
			}, 100);
		}
		createHitSparks(self.targetEnemy.x, self.targetEnemy.y);
	};
	self.die = function () {
		peopleRegenQueue.push(LK.ticks);
		var unitIndex = friendlyUnits.indexOf(self);
		if (unitIndex !== -1) {
			friendlyUnits.splice(unitIndex, 1);
		}
		self.destroy();
	};
	self.update = function () {
		if (self.health <= 0) {
			self.die();
			return;
		}
		self.healthBar.width = self.health / self.maxHealth * 70;
		if (!self.targetEnemy || self.targetEnemy.health <= 0 || !self.targetEnemy.parent) {
			self.targetEnemy = self.findClosestEnemy();
		}
		if (self.targetEnemy) {
			var dx = self.targetEnemy.x - self.x;
			var dy = self.targetEnemy.y - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance < self.range) {
				if (LK.ticks - self.lastAttack >= self.attackSpeed) {
					self.attack();
					self.lastAttack = LK.ticks;
				}
				return;
			} else if (distance < self.detectionRange) {
				var angle = Math.atan2(dy, dx);
				self.x += Math.cos(angle) * self.speed;
				self.y += Math.sin(angle) * self.speed;
				return;
			} else {
				self.targetEnemy = null;
			}
		}
		// SPRAWDZENIE, CZY NA MAPIE SĄ WROGOWIE
		if (enemies.length === 0) {
			return; // Jeśli nie ma wrogów, stój w miejscu
		}
		// PONIŻEJ LOGIKA RUCHU, GDY SĄ WROGOWIE, ALE ŻADEN NIE JEST W ZASIĘGU
		var moveX = 0;
		var moveY = 0;
		// Idź w górę
		moveY -= 1;
		var separationX = 0;
		var separationY = 0;
		var separationRadius = 40;
		for (var i = 0; i < friendlyUnits.length; i++) {
			var otherUnit = friendlyUnits[i];
			if (otherUnit === self) {
				continue;
			}
			var otherDx = self.x - otherUnit.x;
			var otherDy = self.y - otherUnit.y;
			var otherDist = Math.sqrt(otherDx * otherDx + otherDy * otherDy);
			if (otherDist > 0 && otherDist < separationRadius) {
				separationX += otherDx / (otherDist * otherDist);
				separationY += otherDy / (otherDist * otherDist);
			}
		}
		var separationWeight = 15;
		moveX += separationX * separationWeight;
		moveY += separationY * separationWeight;
		var moveMagnitude = Math.sqrt(moveX * moveX + moveY * moveY);
		if (moveMagnitude > 0) {
			var finalMoveX = moveX / moveMagnitude * self.speed;
			var finalMoveY = moveY / moveMagnitude * self.speed;
			self.x += finalMoveX;
			self.y += finalMoveY;
		}
		if (self.y < grid.y) {
			self.die();
		}
	};
	return self;
});
var GoldIndicator = Container.expand(function (value, x, y) {
	var self = Container.call(this);
	var shadowText = new Text2("+" + value, {
		size: 45,
		fill: 0x000000,
		weight: 800
	});
	shadowText.anchor.set(0.5, 0.5);
	shadowText.x = 2;
	shadowText.y = 2;
	self.addChild(shadowText);
	var goldText = new Text2("+" + value, {
		size: 45,
		fill: 0xFFD700,
		weight: 800
	});
	goldText.anchor.set(0.5, 0.5);
	self.addChild(goldText);
	self.x = x;
	self.y = y;
	self.alpha = 0;
	self.scaleX = 0.5;
	self.scaleY = 0.5;
	tween(self, {
		alpha: 1,
		scaleX: 1.2,
		scaleY: 1.2,
		y: y - 40
	}, {
		duration: 50,
		easing: tween.easeOut,
		onFinish: function onFinish() {
			tween(self, {
				alpha: 0,
				scaleX: 1.5,
				scaleY: 1.5,
				y: y - 80
			}, {
				duration: 600,
				easing: tween.easeIn,
				delay: 800,
				onFinish: function onFinish() {
					self.destroy();
				}
			});
		}
	});
	return self;
});
var Golem = Container.expand(function (x, y) {
	var self = Container.call(this);
	self.x = x;
	self.y = y;
	self.maxHealth = 130;
	self.health = self.maxHealth;
	self.damage = 2;
	self.attackSpeed = 100;
	self.range = 1.2 * CELL_SIZE;
	self.lastAttack = 0;
	self.targetEnemy = null;
	self.lifetime = 1200;
	self.isFadingOut = false;
	var golemGraphics = self.attachAsset('unit_golem', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var healthBarOutline = self.attachAsset('healthBarOutline', {
		anchorX: 0,
		anchorY: 0.5
	});
	var healthBarBG = self.attachAsset('healthBar', {
		anchorX: 0,
		anchorY: 0.5
	});
	var healthBar = self.attachAsset('healthBar', {
		anchorX: 0,
		anchorY: 0.5
	});
	healthBarBG.y = healthBarOutline.y = healthBar.y = -golemGraphics.height / 2 - 10;
	healthBarOutline.x = -healthBarOutline.width / 2;
	healthBarBG.x = healthBar.x = -healthBar.width / 2 - .5;
	healthBar.tint = 0x00ff00;
	healthBarBG.tint = 0xff0000;
	self.healthBar = healthBar;
	self.takeDamage = function (amount) {
		self.health -= amount;
		if (self.health < 0) {
			self.health = 0;
		}
		self.healthBar.width = self.health / self.maxHealth * 70;
	};
	self.findClosestEnemy = function () {
		var closestEnemy = null;
		var minDistanceSq = self.range * self.range;
		for (var i = 0; i < enemies.length; i++) {
			var enemy = enemies[i];
			if (enemy.isFlying) {
				continue;
			}
			var dx = enemy.x - self.x;
			var dy = enemy.y - self.y;
			var distanceSq = dx * dx + dy * dy;
			if (distanceSq < minDistanceSq) {
				minDistanceSq = distanceSq;
				closestEnemy = enemy;
			}
		}
		return closestEnemy;
	};
	self.attack = function () {
		if (!self.targetEnemy || self.targetEnemy.health <= 0) {
			return;
		}
		self.targetEnemy.takeDamage(self.damage);
		createHitSparks(self.targetEnemy.x, self.targetEnemy.y);
	};
	self.die = function () {
		self.isFadingOut = true;
		tween(self, {
			alpha: 0
		}, {
			duration: 500,
			onFinish: function onFinish() {
				var unitIndex = friendlyUnits.indexOf(self);
				if (unitIndex !== -1) {
					friendlyUnits.splice(unitIndex, 1);
				}
				self.destroy();
			}
		});
	};
	self.update = function () {
		if (self.isFadingOut) {
			return;
		}
		self.lifetime--;
		if (self.lifetime <= 0 || self.health <= 0) {
			self.die();
			return;
		}
		if (!self.targetEnemy || self.targetEnemy.health <= 0 || !self.targetEnemy.parent) {
			self.targetEnemy = self.findClosestEnemy();
		}
		if (self.targetEnemy) {
			var dx = self.targetEnemy.x - self.x;
			var dy = self.targetEnemy.y - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance < self.range) {
				if (LK.ticks - self.lastAttack >= self.attackSpeed) {
					self.attack();
					self.lastAttack = LK.ticks;
				}
			}
		}
	};
	return self;
});
var GolemSummonEffect = Container.expand(function (x, y, onComplete) {
	var self = Container.call(this);
	self.x = x;
	self.y = y;
	var frameNames = [];
	for (var i = 1; i <= 11; i++) {
		frameNames.push('golem_summon_' + i);
	}
	var allFrames = [];
	var animationSize = 250;
	for (var i = 0; i < frameNames.length; i++) {
		var frameSprite = self.attachAsset(frameNames[i], {
			anchorX: 0.5,
			anchorY: 0.5,
			width: animationSize,
			height: animationSize
		});
		frameSprite.blendMode = 1;
		frameSprite.visible = false;
		allFrames.push(frameSprite);
	}
	var currentFrame = 0;
	var frameDuration = 6;
	var frameTicker = 0;
	if (allFrames.length > 0) {
		allFrames[currentFrame].visible = true;
	}
	self.update = function () {
		frameTicker++;
		if (frameTicker >= frameDuration) {
			frameTicker = 0;
			if (allFrames[currentFrame]) {
				allFrames[currentFrame].visible = false;
			}
			currentFrame++;
			if (currentFrame >= allFrames.length) {
				if (onComplete) {
					onComplete();
				}
				self.destroy();
			} else {
				if (allFrames[currentFrame]) {
					allFrames[currentFrame].visible = true;
				}
			}
		}
	};
	return self;
});
var Grid = Container.expand(function (gridWidth, gridHeight) {
	var self = Container.call(this);
	self.cells = [];
	for (var i = 0; i < gridWidth; i++) {
		self.cells[i] = [];
		for (var j = 0; j < gridHeight; j++) {
			self.cells[i][j] = {
				targets: {},
				score: {},
				towersInRange: [],
				specialEffect: null
			};
		}
	}
	for (var i = 0; i < gridWidth; i++) {
		for (var j = 0; j < gridHeight; j++) {
			var cell = self.cells[i][j];
			cell.x = i;
			cell.y = j;
			cell.up = self.cells[i - 1] && self.cells[i - 1][j];
			cell.left = self.cells[i][j - 1];
			cell.right = self.cells[i][j + 1];
			cell.down = self.cells[i + 1] && self.cells[i + 1][j];
		}
	}
	self.getCell = function (x, y) {
		return self.cells[x] && self.cells[x][y];
	};
	self.calculatePath = function (pathId, goalCell) {
		var toProcess = [goalCell];
		var pathCounter = Math.random();
		toProcess[0].pathId = pathCounter;
		toProcess[0].score[pathId] = 0;
		function processNode(node, targetValue, targetNode) {
			if (node && node.type === 0) {
				if (!node.score[pathId] || targetValue < node.score[pathId]) {
					node.targets[pathId] = [targetNode];
					node.score[pathId] = targetValue;
					if (node.pathId != pathCounter) {
						toProcess.push(node);
						node.pathId = pathCounter;
					}
				}
			}
		}
		while (toProcess.length) {
			var node = toProcess.shift();
			var targetScore = node.score[pathId] + 1;
			processNode(node.up, targetScore, node);
			processNode(node.right, targetScore, node);
			processNode(node.down, targetScore, node);
			processNode(node.left, targetScore, node);
		}
	};
	self.renderDebug = function () {};
	self.updateEnemy = function (enemy) {
		var cell = grid.getCell(enemy.cellX, enemy.cellY);
		if (cell.type === 4) {
			return true;
		}
		if (!enemy.currentTarget) {
			var lanePathId = enemy.spawnerId + "_" + enemy.laneId;
			if (cell && cell.targets[lanePathId]) {
				enemy.currentTarget = cell.targets[lanePathId][0];
			}
		}
		return false;
	};
});
var HealingFieldEffect = Container.expand(function (x, y, spellData) {
	var self = Container.call(this);
	self.x = x;
	self.y = y;
	var radius = spellData.radius;
	var radiusSq = radius * radius;
	var duration = 360;
	var healAmount = spellData.heal;
	var healInterval = 60;
	var particleInterval = 15;
	var healTicker = 0;
	var particleTicker = 0;
	var isFadingOut = false;
	var magicCircle = self.attachAsset('magic_circle_heal', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: radius * 2,
		height: radius * 2
	});
	function pulse() {
		if (!self.parent || isFadingOut) {
			return;
		}
		tween(magicCircle, {
			alpha: 0.4
		}, {
			duration: 1500,
			easing: tween.easeInOut,
			onFinish: function onFinish() {
				if (!self.parent || isFadingOut) {
					return;
				}
				tween(magicCircle, {
					alpha: 0.8
				}, {
					duration: 1500,
					easing: tween.easeInOut,
					onFinish: pulse
				});
			}
		});
	}
	magicCircle.alpha = 0;
	tween(magicCircle, {
		alpha: 0.8
	}, {
		duration: 500,
		onFinish: pulse
	});
	self.update = function () {
		if (isFadingOut) {
			return;
		}
		duration--;
		if (duration <= 0) {
			isFadingOut = true;
			tween(self, {
				alpha: 0
			}, {
				duration: 500,
				onFinish: function onFinish() {
					self.destroy();
				}
			});
			return;
		}
		healTicker++;
		if (healTicker >= healInterval) {
			healTicker = 0;
			friendlyUnits.forEach(function (unit) {
				var dx = unit.x - self.x;
				var dy = unit.y - self.y;
				if (dx * dx + dy * dy < radiusSq) {
					unit.health = Math.min(unit.maxHealth, unit.health + healAmount);
					unit.healthBar.width = unit.health / unit.maxHealth * 70;
				}
			});
		}
		particleTicker++;
		if (particleTicker >= particleInterval) {
			particleTicker = 0;
			var angle = Math.random() * 2 * Math.PI;
			var dist = Math.sqrt(Math.random()) * radius;
			var pX = Math.cos(angle) * dist;
			var pY = Math.sin(angle) * dist;
			var particle = new HealingParticle(pX, pY);
			self.addChild(particle);
		}
	};
	return self;
});
var HealingParticle = Container.expand(function (x, y) {
	var self = Container.call(this);
	self.x = x;
	self.y = y;
	var particleGraphics = self.attachAsset('particle_heal_plus', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	particleGraphics.tint = 0xFFC0CB;
	self.alpha = 0;
	tween(self, {
		alpha: 0.8,
		y: self.y - 20
	}, {
		duration: 1500,
		easing: tween.easeOut,
		onFinish: function onFinish() {
			tween(self, {
				alpha: 0,
				y: self.y - 30
			}, {
				duration: 1500,
				easing: tween.easeIn,
				onFinish: function onFinish() {
					self.destroy();
				}
			});
		}
	});
	return self;
});
var LightningStrike = Container.expand(function (x, y, type) {
	var self = Container.call(this);
	self.x = x;
	self.y = y;
	var frameNames = [];
	for (var i = 1; i <= 5; i++) {
		frameNames.push('lightning_' + type + '_' + i);
	}
	var allFrames = [];
	for (var i = 0; i < frameNames.length; i++) {
		var frameSprite = self.attachAsset(frameNames[i], {
			anchorX: 0.5,
			anchorY: 0.8
		});
		frameSprite.blendMode = 1;
		frameSprite.visible = false;
		allFrames.push(frameSprite);
	}
	var currentFrame = 0;
	var frameDuration = 5;
	var frameTicker = 0;
	if (allFrames.length > 0) {
		allFrames[currentFrame].visible = true;
	}
	self.update = function () {
		if (allFrames.length === 0) {
			self.destroy();
			return;
		}
		frameTicker++;
		if (frameTicker >= frameDuration) {
			frameTicker = 0;
			if (allFrames[currentFrame]) {
				allFrames[currentFrame].visible = false;
			}
			currentFrame++;
			if (currentFrame >= allFrames.length) {
				self.destroy();
			} else {
				if (allFrames[currentFrame]) {
					allFrames[currentFrame].visible = true;
				}
			}
		}
	};
	return self;
});
var LightningStrikeEffect = Container.expand(function (x, y) {
	var self = Container.call(this);
	self.x = x;
	self.y = y;
	var frameNames = [];
	for (var i = 1; i <= 7; i++) {
		frameNames.push('lightning_strike_' + i);
	}
	var allFrames = [];
	for (var i = 0; i < frameNames.length; i++) {
		var frameSprite = self.attachAsset(frameNames[i], {
			anchorX: 0.5,
			anchorY: 0.9
		});
		frameSprite.blendMode = 1;
		frameSprite.visible = false;
		allFrames.push(frameSprite);
	}
	var currentFrame = 0;
	var frameDuration = 3;
	var frameTicker = 0;
	if (allFrames.length > 0) {
		allFrames[currentFrame].visible = true;
	}
	self.update = function () {
		if (allFrames.length === 0) {
			self.destroy();
			return;
		}
		frameTicker++;
		if (frameTicker >= frameDuration) {
			frameTicker = 0;
			if (allFrames[currentFrame]) {
				allFrames[currentFrame].visible = false;
			}
			currentFrame++;
			if (currentFrame >= allFrames.length) {
				self.destroy();
			} else {
				if (allFrames[currentFrame]) {
					allFrames[currentFrame].visible = true;
				}
			}
		}
	};
	return self;
});
var NPC = Container.expand(function (spawnX, spawnY, graphicAsset) {
	var self = Container.call(this);
	self.x = spawnX;
	self.y = spawnY;
	self.speed = 0.5 + Math.random() * 0.5;
	self.state = 'IDLE';
	self.stateTimer = Math.random() * 90 + 30;
	self.path = [];
	self.currentTargetPos = null;
	self.interactionPartner = null;
	self.clickCount = 0;
	var npcGraphics = self.attachAsset(graphicAsset, {
		anchorX: 0.5,
		anchorY: 0.9
	});
	npcGraphics.scale.set(0.6);
	self.down = function () {
		self.clickCount++;
		var message = "";
		if (self.clickCount === 1) {
			message = "Don't click me!";
		} else if (self.clickCount === 2) {
			message = "I'M SERIOUS, STOP!";
		} else if (self.clickCount === 3) {
			message = "THAT'S IT, I'M LEAVING!";
			self.state = 'LEAVING';
			self.stateTimer = 180;
			npcGraphics.destroy();
			npcGraphics = self.attachAsset('npc_suitcase', {
				anchorX: 0.5,
				anchorY: 0.9
			});
			npcGraphics.scale.set(0.6);
		}
		var bubble = new SpeechBubble(message, self.x, self.y - npcGraphics.height);
		npcLayer.addChild(bubble);
	};
	self.findPath = function (targetCell) {
		var startCell = castleGrid.getCell(Math.floor((self.x - castleGrid.x) / CELL_SIZE), Math.floor((self.y - castleGrid.y) / CELL_SIZE));
		if (!startCell || !targetCell || startCell === targetCell) {
			return [];
		}
		var queue = [[startCell]];
		var visited = {}; // ZMIANA: Zamiast new Set()
		var startKey = startCell.x + ',' + startCell.y;
		visited[startKey] = true;
		while (queue.length > 0) {
			var path = queue.shift();
			var lastCell = path[path.length - 1];
			if (lastCell === targetCell) {
				return path;
			}
			var neighbors = [lastCell.up, lastCell.down, lastCell.left, lastCell.right].filter(function (n) {
				if (!n || n.type !== 1) {
					return false;
				}
				var key = n.x + ',' + n.y;
				return !visited[key]; // ZMIANA: Sprawdzanie w obiekcie
			});
			for (var i = 0; i < neighbors.length; i++) {
				var neighbor = neighbors[i];
				var key = neighbor.x + ',' + neighbor.y;
				visited[key] = true; // ZMIANA: Dodawanie do obiektu
				var newPath = path.slice();
				newPath.push(neighbor);
				queue.push(newPath);
			}
		}
		return [];
	};
	self.findWanderTarget = function () {
		var validCells = [];
		for (var i = 0; i < castleGrid.cells.length; i++) {
			for (var j = 0; j < castleGrid.cells[i].length; j++) {
				if (castleGrid.cells[i][j].type === 1) {
					validCells.push(castleGrid.cells[i][j]);
				}
			}
		}
		if (validCells.length > 0) {
			var targetCell = validCells[Math.floor(Math.random() * validCells.length)];
			self.path = self.findPath(targetCell);
			if (self.path.length > 0) {
				self.state = 'WANDERING';
			}
		}
	};
	self.findInteractionPartner = function () {
		var potentialPartners = npcs.filter(function (p) {
			return p !== self && p.state === 'IDLE' && !p.interactionPartner;
		});
		var closestPartner = null;
		var minDistanceSq = Math.pow(3 * CELL_SIZE, 2);
		potentialPartners.forEach(function (p) {
			var dx = p.x - self.x;
			var dy = p.y - self.y;
			var distSq = dx * dx + dy * dy;
			if (distSq < minDistanceSq) {
				minDistanceSq = distSq;
				closestPartner = p;
			}
		});
		if (closestPartner) {
			self.interactionPartner = closestPartner;
			closestPartner.interactionPartner = self;
			var partnerCell = castleGrid.getCell(Math.floor((closestPartner.x - castleGrid.x) / CELL_SIZE), Math.floor((closestPartner.y - castleGrid.y) / CELL_SIZE));
			self.path = self.findPath(partnerCell);
			if (self.path.length > 0) {
				self.state = 'WANDERING';
				closestPartner.state = 'INTERRUPTED';
			} else {
				self.interactionPartner.interactionPartner = null;
				self.interactionPartner = null;
				self.findWanderTarget();
			}
		} else {
			self.findWanderTarget();
		}
	};
	self.startInteracting = function () {
		self.state = 'INTERACTING';
		self.stateTimer = Math.random() * 240 + 120;
		if (self.interactionPartner) {
			self.interactionPartner.state = 'INTERACTING';
			self.interactionPartner.stateTimer = self.stateTimer;
			var bubbleX = (self.x + self.interactionPartner.x) / 2;
			var bubbleY = Math.min(self.y, self.interactionPartner.y) - 80;
			var bubble = new SpeechBubble("...", bubbleX, bubbleY, true);
			npcLayer.addChild(bubble);
		}
	};
	self.update = function () {
		switch (self.state) {
			case 'IDLE':
				self.stateTimer--;
				if (self.stateTimer <= 0) {
					if (Math.random() < 0.5) {
						self.findInteractionPartner();
					} else {
						self.findWanderTarget();
					}
				}
				break;
			case 'WANDERING':
				if (self.path.length === 0 && !self.currentTargetPos) {
					if (self.interactionPartner) {
						self.startInteracting();
					} else {
						self.state = 'IDLE';
						self.stateTimer = Math.random() * 90 + 60;
					}
					return;
				}
				if (!self.currentTargetPos && self.path.length > 0) {
					var nextCell = self.path.shift();
					self.currentTargetPos = {
						x: castleGrid.x + nextCell.x * CELL_SIZE + CELL_SIZE / 2,
						y: castleGrid.y + nextCell.y * CELL_SIZE + CELL_SIZE / 2
					};
				}
				if (self.currentTargetPos) {
					var dx = self.currentTargetPos.x - self.x;
					var dy = self.currentTargetPos.y - self.y;
					var dist = Math.sqrt(dx * dx + dy * dy);
					if (dist < self.speed) {
						self.x = self.currentTargetPos.x;
						self.y = self.currentTargetPos.y;
						self.currentTargetPos = null;
					} else {
						self.x += dx / dist * self.speed;
						self.y += dy / dist * self.speed;
					}
				}
				break;
			case 'INTERACTING':
				self.stateTimer--;
				if (self.stateTimer <= 0) {
					self.state = 'IDLE';
					self.stateTimer = Math.random() * 90 + 30;
					if (self.interactionPartner) {
						self.interactionPartner.interactionPartner = null;
						self.interactionPartner.state = 'IDLE';
						self.interactionPartner.stateTimer = Math.random() * 90 + 30;
						self.interactionPartner = null;
					}
				}
				break;
			case 'LEAVING':
				self.y += self.speed * 2;
				self.stateTimer--;
				if (self.stateTimer <= 0) {
					tween(self, {
						alpha: 0
					}, {
						duration: 1000,
						onFinish: function onFinish() {
							people--;
							updateUI();
							self.destroy();
						}
					});
					self.state = 'GONE';
				}
				break;
			case 'INTERRUPTED':
			case 'GONE':
				break;
		}
	};
	return self;
});
var Notification = Container.expand(function (message) {
	var self = Container.call(this);
	var notificationGraphics = self.attachAsset('panel_popup_background', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Zakładamy, że panel notyfikacji ma stały, mniejszy rozmiar
	notificationGraphics.width = 800;
	notificationGraphics.height = 150;
	var notificationText = new Text2(message, {
		size: 50,
		fill: 0x000000,
		weight: 800
	});
	notificationText.anchor.set(0.5, 0.5);
	self.addChild(notificationText);
	self.alpha = 1;
	var fadeOutTime = 120;
	self.update = function () {
		if (fadeOutTime > 0) {
			fadeOutTime--;
			self.alpha = Math.min(fadeOutTime / 120 * 2, 1);
		} else {
			self.destroy();
		}
	};
	return self;
});
var PlacementPreview = Container.expand(function () {
	var self = Container.call(this);
	self.itemType = 'tower';
	self.subType = 'guard';
	self.itemSize = {
		w: 2,
		h: 2
	};
	self.hasEnoughGold = true;
	self.canPlace = false;
	self.gridX = 0;
	self.gridY = 0;
	var rangeIndicator = self.attachAsset('rangeCircle', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0.3
	});
	var previewHolder = new Container();
	self.addChild(previewHolder);
	var previewGraphics = previewHolder.attachAsset('cell', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// NOWA LOGIKA: Cień + Tekst
	var textStyle = {
		size: 60,
		weight: 900,
		align: 'center'
	};
	var bonusTextShadow = new Text2("", Object.assign({}, textStyle, {
		fill: 0x000000
	}));
	bonusTextShadow.anchor.set(0.5, 0.5);
	bonusTextShadow.x = 3;
	bonusTextShadow.y = 3;
	previewHolder.addChild(bonusTextShadow);
	var bonusText = new Text2("", Object.assign({}, textStyle, {
		fill: 0xFFFFFF
	}));
	bonusText.anchor.set(0.5, 0.5);
	previewHolder.addChild(bonusText);
	self.updateAppearance = function (specialEffect) {
		previewGraphics.width = CELL_SIZE * self.itemSize.w;
		previewGraphics.height = CELL_SIZE * self.itemSize.h;
		previewGraphics.alpha = 0.6; // Lepsza czytelność na lekko ciemniejszym tle
		bonusText.setText("");
		bonusTextShadow.setText("");
		previewGraphics.tint = 0x00BFFF;
		if (specialEffect && self.canPlace && self.hasEnoughGold) {
			var textToShow = "";
			if (specialEffect === 'amplifier') {
				previewGraphics.tint = 0xFFD700;
				textToShow = "+15% DMG";
			} else if (specialEffect === 'catalyst') {
				previewGraphics.tint = 0x9370DB;
				textToShow = "+30% ATS";
			}
			bonusText.setText(textToShow);
			bonusTextShadow.setText(textToShow);
		}
		rangeIndicator.visible = false;
		if (self.itemType === 'tower') {
			var stats = TOWER_DATA[self.subType] ? TOWER_DATA[self.subType][1] : null;
			if (stats && stats.range) {
				rangeIndicator.width = rangeIndicator.height = stats.range * 2;
				rangeIndicator.visible = true;
			}
		}
		if (!self.canPlace || !self.hasEnoughGold) {
			previewGraphics.tint = 0xFF0000;
			bonusText.setText("");
			bonusTextShadow.setText("");
		}
	};
	self.updatePlacementStatus = function (targetGrid) {
		var validGridPlacement = true;
		var currentGrid = targetGrid || grid;
		var currentSpecialEffect = null;
		if (self.gridY <= 4 && self.itemType === 'tower') {
			validGridPlacement = false;
		}
		if (self.gridY + self.itemSize.h > currentGrid.cells[0].length && self.itemType === 'building') {
			validGridPlacement = false;
		}
		if (validGridPlacement) {
			for (var i = 0; i < self.itemSize.w; i++) {
				for (var j = 0; j < self.itemSize.h; j++) {
					var cell = currentGrid.getCell(self.gridX + i, self.gridY + j);
					if (!cell || cell.type !== 1) {
						validGridPlacement = false;
					}
					if (cell && cell.specialEffect) {
						currentSpecialEffect = cell.specialEffect;
						break;
					}
				}
				if (currentSpecialEffect) {
					break;
				}
			}
		}
		var cost = 0;
		if (self.itemType === 'tower') {
			cost = getTowerCost(self.subType);
		} else {
			var buildingCost = getBuildingCost(self.subType);
			cost = buildingCost.gold;
		}
		self.hasEnoughGold = gold >= cost;
		self.canPlace = validGridPlacement;
		self.updateAppearance(currentSpecialEffect);
	};
	self.snapToGrid = function (x, y, targetGrid) {
		var currentGrid = targetGrid || grid;
		var gridPosX = x - currentGrid.x;
		var gridPosY = y - currentGrid.y;
		self.gridX = Math.floor(gridPosX / CELL_SIZE);
		self.gridY = Math.floor(gridPosY / CELL_SIZE);
		var itemWidth = CELL_SIZE * self.itemSize.w;
		var itemHeight = CELL_SIZE * self.itemSize.h;
		self.x = currentGrid.x + self.gridX * CELL_SIZE + itemWidth / 2;
		self.y = currentGrid.y + self.gridY * CELL_SIZE + itemHeight / 2;
		self.updatePlacementStatus(currentGrid);
	};
	return self;
});
var SourceBuilding = Container.expand(function (buildingType) {
	var self = Container.call(this);
	self.buildingType = buildingType || 'default';
	var buildingData = BUILDING_DATA[self.buildingType];
	var assetId = 'building_' + self.buildingType;
	var baseGraphics = self.attachAsset(assetId, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	baseGraphics.width = 130;
	baseGraphics.height = 130;
	var typeLabelShadow = new Text2(buildingData.name, {
		size: 50,
		fill: 0x000000,
		weight: 800
	});
	typeLabelShadow.anchor.set(0.5, 0.5);
	typeLabelShadow.x = 4;
	typeLabelShadow.y = -20 + 4;
	self.addChild(typeLabelShadow);
	var typeLabel = new Text2(buildingData.name, {
		size: 50,
		fill: 0xFFFFFF,
		weight: 800
	});
	typeLabel.anchor.set(0.5, 0.5);
	typeLabel.y = -20;
	self.addChild(typeLabel);
	var costLabelShadow = new Text2(buildingData.cost, {
		size: 50,
		fill: 0x000000,
		weight: 800
	});
	costLabelShadow.anchor.set(0.5, 0.5);
	costLabelShadow.x = 4;
	costLabelShadow.y = 24 + 12;
	self.addChild(costLabelShadow);
	var costLabel = new Text2(buildingData.cost, {
		size: 50,
		fill: 0xFFD700,
		weight: 800
	});
	costLabel.anchor.set(0.5, 0.5);
	costLabel.y = 20 + 12;
	self.addChild(costLabel);
	self.update = function () {
		var currentCost = getBuildingCost(self.buildingType);
		if (costLabel.text !== currentCost.gold) {
			costLabel.setText(currentCost.gold);
			costLabelShadow.setText(currentCost.gold);
		}
		var canAfford = gold >= currentCost.gold;
		self.alpha = canAfford ? 1 : 0.5;
	};
	return self;
});
var SourceSpell = Container.expand(function (spellId) {
	var self = Container.call(this);
	self.spellId = spellId;
	var spellData = SPELL_DATA[self.spellId];
	var assetId = 'icon_spell_' + self.spellId;
	var baseGraphics = self.attachAsset(assetId, {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 198,
		height: 198
	});
	var nameLabelShadow = new Text2(spellData.name, {
		size: 40,
		fill: 0x000000,
		weight: 800,
		align: 'center'
	});
	nameLabelShadow.anchor.set(0.5, 0.5);
	nameLabelShadow.x = 2;
	nameLabelShadow.y = -20 + 2;
	self.addChild(nameLabelShadow);
	var nameLabel = new Text2(spellData.name, {
		size: 40,
		fill: 0xFFFFFF,
		weight: 800,
		align: 'center'
	});
	nameLabel.anchor.set(0.5, 0.5);
	nameLabel.y = -20;
	self.addChild(nameLabel);
	var costLabelShadow = new Text2(spellData.cost, {
		size: 50,
		fill: 0x000000,
		weight: 800
	});
	costLabelShadow.anchor.set(0.5, 0.5);
	costLabelShadow.x = 4;
	costLabelShadow.y = 24 + 12;
	self.addChild(costLabelShadow);
	var costLabel = new Text2(spellData.cost, {
		size: 50,
		fill: 0x00BFFF,
		weight: 800
	});
	costLabel.anchor.set(0.5, 0.5);
	costLabel.y = 20 + 12;
	self.addChild(costLabel);
	self.update = function () {
		var canAfford = mana >= spellData.cost;
		self.alpha = canAfford ? 1 : 0.5;
	};
	return self;
});
var SourceTower = Container.expand(function (towerType) {
	var self = Container.call(this);
	self.towerType = towerType || 'default';
	var assetId = 'tower_' + self.towerType;
	var baseGraphics = self.attachAsset(assetId, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	baseGraphics.isTowerBase = true;
	baseGraphics.width = 130;
	baseGraphics.height = 170;
	var stats = TOWER_DATA[self.towerType][1]; // Pobierz dane dla poziomu 1
	var towerName = stats.name;
	var initialCost = stats.cost;
	var typeLabelShadow = new Text2(towerName, {
		size: 40,
		fill: 0x000000,
		weight: 800
	});
	typeLabelShadow.anchor.set(0.5, 0.5);
	typeLabelShadow.x = 2;
	typeLabelShadow.y = -20 + 2;
	self.addChild(typeLabelShadow);
	var typeLabel = new Text2(towerName, {
		size: 40,
		fill: 0xFFFFFF,
		weight: 800
	});
	typeLabel.anchor.set(0.5, 0.5);
	typeLabel.y = -20;
	self.addChild(typeLabel);
	var costLabelShadow = new Text2(initialCost, {
		size: 50,
		fill: 0x000000,
		weight: 800
	});
	costLabelShadow.anchor.set(0.5, 0.5);
	costLabelShadow.x = 4;
	costLabelShadow.y = 24 + 12;
	self.addChild(costLabelShadow);
	var costLabel = new Text2(initialCost, {
		size: 50,
		fill: 0xFFD700,
		weight: 800
	});
	costLabel.anchor.set(0.5, 0.5);
	costLabel.y = 20 + 12;
	self.addChild(costLabel);
	self.update = function () {
		// Ta funkcja będzie aktualizować koszt w przyszłości, gdy wprowadzimy dynamiczne zmiany
		var currentCost = TOWER_DATA[self.towerType][1].cost;
		if (!isBuildPhase && currentWave > 0) {
			currentCost = Math.floor(currentCost * 1.5);
		}
		if (costLabel.text !== currentCost) {
			costLabel.setText(currentCost);
			costLabelShadow.setText(currentCost);
		}
		var canAfford = gold >= currentCost;
		self.alpha = canAfford ? 1 : 0.5;
	};
	return self;
});
var SourceUnit = Container.expand(function (unitId) {
	var self = Container.call(this);
	self.unitId = unitId;
	self.interactive = true;
	var unitData = UNIT_DATA[self.unitId];
	var assetId = 'unit_' + unitId;
	var baseGraphics = self.attachAsset(assetId, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	baseGraphics.width = 160;
	baseGraphics.height = 180;
	var nameLabelShadow = new Text2(unitData.name, {
		size: 40,
		fill: 0x000000,
		weight: 800,
		align: 'center'
	});
	nameLabelShadow.anchor.set(0.5, 0.5);
	nameLabelShadow.x = 2;
	nameLabelShadow.y = -20 + 2;
	self.addChild(nameLabelShadow);
	var nameLabel = new Text2(unitData.name, {
		size: 40,
		fill: 0xFFFFFF,
		weight: 800,
		align: 'center'
	});
	nameLabel.anchor.set(0.5, 0.5);
	nameLabel.y = -20;
	self.addChild(nameLabel);
	var costLabelShadow = new Text2(unitData.cost, {
		size: 50,
		fill: 0x000000,
		weight: 800
	});
	costLabelShadow.anchor.set(0.5, 0.5);
	costLabelShadow.x = 4;
	costLabelShadow.y = 24 + 12;
	self.addChild(costLabelShadow);
	var costLabel = new Text2(unitData.cost, {
		size: 50,
		fill: 0xFFD700,
		weight: 800
	});
	costLabel.anchor.set(0.5, 0.5);
	costLabel.y = 20 + 12;
	self.addChild(costLabel);
	self.update = function () {
		var canAfford = gold >= unitData.cost && people > 0;
		self.alpha = canAfford ? 1 : 0.5;
	};
	self.down = function () {
		if (activeWeatherEvent === 'STORM') {
			var notification = game.addChild(new Notification("Recruitment disabled during a storm!"));
			notification.x = 2048 / 2;
			notification.y = grid.height - 50;
			return;
		}
		if (LK.ticks - lastRecruitActionTick < 10) {
			return;
		}
		if (gold >= unitData.cost && people > 0) {
			lastRecruitActionTick = LK.ticks;
			var finalStats = Object.assign({}, unitData);
			// Bonus z Training Ground
			var trainingGroundsCount = castleBuildings.filter(function (b) {
				return b.id === 'training_ground';
			}).length;
			if (trainingGroundsCount > 0) {
				var unitBonus = Math.pow(1.05, trainingGroundsCount);
				finalStats.maxHealth = Math.round(finalStats.maxHealth * unitBonus);
				finalStats.damage = Math.round(finalStats.damage * unitBonus);
			}
			// Bonus ze Smithy (jeśli istnieje)
			var hasSmithy = castleBuildings.some(function (b) {
				return b.id === 'smithy';
			});
			if (hasSmithy) {
				finalStats.maxHealth = Math.floor(finalStats.maxHealth * 1.15);
				finalStats.damage = Math.floor(finalStats.damage * 1.15);
			}
			setGold(gold - finalStats.cost);
			people--;
			updateUI();
			panelActionTaken = true;
			var spawnLaneOffset = 80;
			var spawnLanes = [2048 / 2 - spawnLaneOffset, 2048 / 2, 2048 / 2 + spawnLaneOffset];
			var spawnX = spawnLanes[Math.floor(Math.random() * spawnLanes.length)];
			spawnX += Math.random() * 40 - 20;
			var spawnY = grid.y + (grid.cells[0].length - 3) * CELL_SIZE;
			var newUnit = new FriendlyUnit(spawnX, spawnY, finalStats);
			friendlyUnitLayer.addChild(newUnit);
			friendlyUnits.push(newUnit);
		} else {
			var message = gold < unitData.cost ? "Not enough gold!" : "Not enough people!";
			var notification = game.addChild(new Notification(message));
			notification.x = 2048 / 2;
			notification.y = grid.height - 50;
		}
	};
	return self;
});
var SpeechBubble = Container.expand(function (text, x, y, isGroup) {
	var self = Container.call(this);
	self.x = x;
	self.y = y;
	var dialogues = ["The harvest should be good this year.", "A fine day for the kingdom.", "Did you know our king has one purple and one blue eye? I've heard he loves music.", "I hear that in MemeTower, a Cursed Crystal holds Demon Pepe captive.", "I used to be an adventurer like you, then I took an arrow in the knee.", "Stay a while and listen."];
	var displayText = isGroup ? dialogues[Math.floor(Math.random() * dialogues.length)] : text;
	var bubbleGraphics = self.attachAsset('dialogue_bubble', {
		// Placeholder
		anchorX: 0.5,
		anchorY: 1,
		width: 300,
		height: 150,
		tint: 0xEFEFEF
	});
	var bubbleText = new Text2(displayText, {
		size: 28,
		fill: 0x000000,
		align: 'center',
		wordWrap: true,
		wordWrapWidth: 280
	});
	bubbleText.anchor.set(0.5, 0.5);
	bubbleText.y = -85;
	self.addChild(bubbleText);
	self.alpha = 0;
	tween(self, {
		alpha: 1,
		y: y - 10
	}, {
		duration: 200,
		easing: tween.easeOut,
		onFinish: function onFinish() {
			LK.setTimeout(function () {
				tween(self, {
					alpha: 0
				}, {
					duration: 500,
					onFinish: function onFinish() {
						self.destroy();
					}
				});
			}, isGroup ? 4000 : 2000);
		}
	});
	return self;
});
var SpellPreview = Container.expand(function () {
	var self = Container.call(this);
	self.visible = false;
	self.spellId = null;
	self.rangeIndicator = self.attachAsset('rangeCircle', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0.4
	});
	self.rangeIndicator.blendMode = 1;
	self.unitIndicator = self.attachAsset('unit_golem', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0.5,
		width: 160,
		height: 160,
		visible: false
	});
	self.getActiveGraphic = function () {
		if (self.spellId === 'summon_golem') {
			return self.unitIndicator;
		}
		return self.rangeIndicator;
	};
	self.updateAppearance = function (spellData, canAfford) {
		self.spellId = spellData.id;
		if (spellData.id === 'summon_golem') {
			self.rangeIndicator.visible = false;
			self.unitIndicator.visible = true;
		} else {
			self.rangeIndicator.visible = true;
			self.unitIndicator.visible = false;
			self.rangeIndicator.width = self.rangeIndicator.height = spellData.radius * 2;
		}
		var activeGraphic = self.getActiveGraphic();
		if (activeGraphic) {
			activeGraphic.tint = canAfford ? 0x00BFFF : 0xFF0000;
		}
		self.visible = true;
	};
	self.updatePosition = function (x, y) {
		self.x = x;
		self.y = y;
	};
	return self;
});
var ThunderstormEffect = Container.expand(function (x, y, spellData) {
	var self = Container.call(this);
	self.x = x;
	self.y = y;
	var radius = spellData.radius;
	var radiusSq = radius * radius;
	var lifetime = spellData.duration || 90;
	var hitEnemies = [];
	var totalStrikes = 12;
	var stormDuration = 90;
	var strikesSpawned = 0;
	var spawnTicker = 0;
	var timeBetweenStrikes = stormDuration / totalStrikes;
	self.update = function () {
		lifetime--;
		if (lifetime <= 0) {
			self.destroy();
			return;
		}
		enemies.forEach(function (enemy) {
			if (hitEnemies.indexOf(enemy) !== -1) {
				return;
			}
			var dx = enemy.x - self.x;
			var dy = enemy.y - self.y;
			if (dx * dx + dy * dy < radiusSq) {
				enemy.isStunned = true;
				enemy.stunTimer = spellData.stunDuration;
				if (spellData.damage) {
					enemy.takeDamage(spellData.damage);
				}
				hitEnemies.push(enemy);
			}
		});
		spawnTicker++;
		if (spawnTicker >= timeBetweenStrikes) {
			spawnTicker = 0;
			strikesSpawned++;
			if (strikesSpawned > totalStrikes) {
				return;
			}
			var angle = Math.random() * 2 * Math.PI;
			var dist = Math.sqrt(Math.random()) * radius;
			var strikeX = self.x + Math.cos(angle) * dist;
			var strikeY = self.y + Math.sin(angle) * dist;
			var type = Math.random() > 0.5 ? 'white' : 'yellow';
			var strike = new LightningStrike(strikeX, strikeY, type);
			spellEffectLayer.addChild(strike);
		}
	};
	return self;
});
var Tower = Container.expand(function (towerType) {
	var self = Container.call(this);
	self.towerType = towerType;
	self.level = 1;
	self.levelPath = '';
	self.maxLevel = 3;
	self.gridX = 0;
	self.gridY = 0;
	self.targetEnemies = [];
	self.lastFired = 0;
	self.totalValue = 0;
	self.isConstructing = false;
	self.constructionContainer = null;
	self.timerText = null;
	self.auraEffectContainer = null;
	self.baseStats = {};
	self.buffs = [];
	self.tileBuff = null; // NOWA WŁAŚCIWOŚĆ
	self.towersInAura = [];
	if (self.towerType === 'banner') {
		self.auraCheckTimer = 0;
		self.particleSpawnTimer = 0;
		self.particleSpawnRate = 190;
	}
	function setTowerSize(graphic) {
		var towerScaleX = 2.4;
		var towerScaleY = 3.9;
		graphic.width = CELL_SIZE * towerScaleX;
		graphic.height = CELL_SIZE * towerScaleY;
	}
	function applyStats(stats) {
		self.baseStats = Object.assign({}, stats);
		Object.assign(self, stats);
		self.recalculateStats();
	}
	self.recalculateStats = function () {
		self.damage = self.baseStats.damage;
		self.fireRate = self.baseStats.fireRate;
		// Aplikuj buff z pola
		if (self.tileBuff) {
			if (self.tileBuff.damage) {
				self.damage *= self.tileBuff.damage;
			}
			if (self.tileBuff.attackSpeed) {
				self.fireRate /= self.tileBuff.attackSpeed;
			}
		}
		// Aplikuj buffy z innych źródeł (np. Banner)
		self.buffs.forEach(function (buff) {
			if (buff.effect.damage) {
				self.damage *= buff.effect.damage;
			}
			if (buff.effect.attackSpeed) {
				self.fireRate /= buff.effect.attackSpeed;
			}
		});
	};
	self.addBuff = function (buff) {
		if (!self.buffs.find(function (b) {
			return b.source === buff.source;
		})) {
			self.buffs.push(buff);
			self.recalculateStats();
		}
	};
	self.removeBuff = function (buffSource) {
		self.buffs = self.buffs.filter(function (b) {
			return b.source !== buffSource;
		});
		self.recalculateStats();
	};
	var initialStats = TOWER_DATA[self.towerType][self.level];
	self.cost = initialStats.cost;
	self.totalValue = self.cost;
	applyStats(initialStats);
	var assetId = 'tower_' + self.towerType;
	var baseGraphics = self.attachAsset(assetId, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	baseGraphics.isTowerBase = true;
	setTowerSize(baseGraphics);
	self.getRange = function () {
		return self.range;
	};
	self.getTotalValue = function () {
		return self.totalValue;
	};
	self.upgrade = function (path) {
		if (self.isConstructing) {
			return;
		}
		path = path || '';
		var nextLevelKey = self.level + 1 + path;
		var upgradeData = TOWER_DATA[self.towerType][nextLevelKey];
		if (!upgradeData) {
			return;
		}
		self.startConstructionAnimation(5, function () {
			if (self.aura) {
				self.removeAuraFromTowers();
			}
			self.level++;
			self.levelPath = path;
			self.totalValue += upgradeData.cost;
			var stats = TOWER_DATA[self.towerType][self.level + self.levelPath];
			applyStats(stats); // Stosuje bazowe staty i przelicza z buffami
			var oldGraphics = self.children[0];
			if (oldGraphics.isTowerBase) {
				oldGraphics.destroy();
			}
			var newAssetId = 'tower_' + self.towerType + '_' + self.level + self.levelPath;
			var newGraphics = self.attachAsset(newAssetId, {
				anchorX: 0.5,
				anchorY: 0.5
			});
			newGraphics.isTowerBase = true;
			setTowerSize(newGraphics);
			self.addChildAt(newGraphics, 0);
			if (self.towerType === 'crossbow' && self.gridX < 12) {
				newGraphics.scale.x = -1;
			}
			if (self.aura) {
				self.applyAuraToTowers();
			}
		});
	};
	self.destroyAura = function () {
		if (self.aura) {
			self.removeAuraFromTowers();
		}
	};
	self.placeOnGrid = function (gridX, gridY) {
		self.gridX = gridX;
		self.gridY = gridY;
		self.x = grid.x + (gridX + 1) * CELL_SIZE;
		self.y = grid.y + (gridY + 1) * CELL_SIZE - 50;
		if (self.towerType === 'crossbow' && self.gridX < 12) {
			var towerGraphic = self.children[0];
			if (towerGraphic) {
				towerGraphic.scale.x = -1;
			}
		}
		// Sprawdź bonus z pola i go przypisz
		for (var i = 0; i < 2; i++) {
			for (var j = 0; j < 2; j++) {
				var cell = grid.getCell(gridX + i, gridY + j);
				if (cell && cell.specialEffect) {
					if (cell.specialEffect === 'amplifier') {
						self.tileBuff = {
							damage: 1.15
						};
					} else if (cell.specialEffect === 'catalyst') {
						self.tileBuff = {
							attackSpeed: 1.30
						};
					}
					self.recalculateStats();
					break; // Znaleziono bonus, przerywamy pętlę
				}
			}
			if (self.tileBuff) {
				break;
			}
		}
		for (var i = 0; i < 2; i++) {
			for (var j = 0; j < 2; j++) {
				var cellToOccupy = grid.getCell(gridX + i, gridY + j);
				if (cellToOccupy) {
					cellToOccupy.type = 5;
				}
			}
		}
		if (self.aura) {
			self.applyAuraToTowers();
		}
	};
	self.findTargets = function () {
		var maxTargets = self.multiShot || 1;
		var potentialTargets = [];
		if (self.damage === 0) {
			return [];
		}
		if (self.bulletType === 'slow') {
			var unslowedTargets = [];
			var slowedTargets = [];
			enemies.forEach(function (enemy) {
				var dx = enemy.x - self.x;
				var dy = enemy.y - self.y;
				if (dx * dx + dy * dy < self.range * self.range) {
					if (!enemy.slowed) {
						unslowedTargets.push(enemy);
					} else {
						slowedTargets.push(enemy);
					}
				}
			});
			potentialTargets = unslowedTargets.concat(slowedTargets);
		} else {
			enemies.forEach(function (enemy) {
				var dx = enemy.x - self.x;
				var dy = enemy.y - self.y;
				if (dx * dx + dy * dy < self.range * self.range) {
					potentialTargets.push(enemy);
				}
			});
			potentialTargets.sort(function (a, b) {
				var distA = Math.pow(a.x - self.x, 2) + Math.pow(a.y - self.y, 2);
				var distB = Math.pow(b.x - self.x, 2) + Math.pow(b.y - self.y, 2);
				return distA - distB;
			});
		}
		return potentialTargets.slice(0, maxTargets);
	};
	self.fire = function () {
		self.targetEnemies.forEach(function (targetEnemy) {
			if (targetEnemy && targetEnemy.health > 0) {
				var dx = targetEnemy.x - self.x;
				var dy = targetEnemy.y - self.y;
				var angle = Math.atan2(dy, dx);
				var bulletX = self.x + Math.cos(angle) * 40;
				var bulletY = self.y + Math.sin(angle) * 40;
				var bullet = new Bullet(bulletX, bulletY, targetEnemy, self);
				if (self.towerType === 'mage') {
					spellEffectLayer.addChild(bullet);
				} else {
					gateContainer.addChild(bullet);
				}
				bullets.push(bullet);
			}
		});
	};
	self.applyAuraToTowers = function () {
		self.removeAuraFromTowers();
		towers.forEach(function (tower) {
			if (tower === self) {
				return;
			}
			var dx = tower.x - self.x;
			var dy = tower.y - self.y;
			if (dx * dx + dy * dy < self.range * self.range) {
				tower.addBuff({
					source: self,
					effect: self.aura
				});
				self.towersInAura.push(tower);
			}
		});
	};
	self.removeAuraFromTowers = function () {
		self.towersInAura.forEach(function (tower) {
			tower.removeBuff(self);
		});
		self.towersInAura = [];
	};
	self.startConstructionAnimation = function (duration, onComplete) {
		self.isConstructing = true;
		var baseGraphics = self.children[0];
		if (baseGraphics) {
			baseGraphics.visible = false;
		}
		if (self.constructionContainer) {
			self.constructionContainer.destroy();
		}
		self.constructionContainer = new Container();
		self.addChild(self.constructionContainer);
		var constructionAssets = [];
		for (var i = 1; i <= 5; i++) {
			var assetName = 'tower_construction_' + i;
			var asset = self.constructionContainer.attachAsset(assetName, {
				anchorX: 0.5,
				anchorY: 0.5
			});
			asset.alpha = i === 1 ? 1 : 0;
			constructionAssets.push(asset);
		}
		if (self.timerText) {
			self.timerText.destroy();
		}
		self.timerText = new Text2(duration.toString(), {
			size: 80,
			fill: 0xFFFFFF,
			weight: 800,
			stroke: 0x000000,
			strokeThickness: 10
		});
		self.timerText.anchor.set(0.5, 0.5);
		self.timerText.y = -CELL_SIZE * 1.5;
		self.addChild(self.timerText);
		function animateStep(stage) {
			if (stage > duration) {
				if (baseGraphics) {
					baseGraphics.visible = true;
				}
				self.constructionContainer.destroy();
				self.constructionContainer = null;
				self.timerText.destroy();
				self.timerText = null;
				self.isConstructing = false;
				if (onComplete) {
					onComplete();
				}
				return;
			}
			self.timerText.setText((duration - stage + 1).toString());
			var currentAsset = constructionAssets[stage - 1];
			var prevAsset = constructionAssets[stage - 2];
			if (prevAsset) {
				tween(prevAsset, {
					alpha: 0
				}, {
					duration: 200
				});
			}
			if (currentAsset) {
				tween(currentAsset, {
					alpha: 1
				}, {
					duration: 300
				});
			}
			LK.setTimeout(function () {
				animateStep(stage + 1);
			}, 1000);
		}
		animateStep(1);
	};
	self.update = function () {
		if (self.isConstructing) {
			return;
		}
		if (self.towerType === 'banner') {
			self.auraCheckTimer++;
			if (self.auraCheckTimer > 60) {
				self.auraCheckTimer = 0;
				self.applyAuraToTowers();
			}
			self.particleSpawnTimer++;
			if (self.particleSpawnTimer >= self.particleSpawnRate) {
				self.particleSpawnTimer = 0;
				self.towersInAura.forEach(function (buffedTower) {
					if (buffedTower && buffedTower.parent) {
						var particle = new Container();
						particle.attachAsset('aura_particle', {
							anchorX: 0.5,
							anchorY: 0.5,
							alpha: 0.8
						});
						var spread = 80;
						particle.x = buffedTower.x + (Math.random() * spread - spread / 2);
						particle.y = buffedTower.y + 100;
						gateContainer.addChild(particle);
						tween(particle, {
							y: buffedTower.y - 120,
							alpha: 0
						}, {
							duration: 4000 + Math.random() * 1000,
							easing: tween.easeIn,
							onFinish: function onFinish() {
								particle.destroy();
							}
						});
					}
				});
			}
			return;
		}
		self.targetEnemies = self.findTargets();
		if (self.targetEnemies.length > 0) {
			if (self.fireRate > 0 && LK.ticks - self.lastFired >= self.fireRate) {
				self.fire();
				self.lastFired = LK.ticks;
			}
		}
	};
	self.down = function (x, y, obj) {
		if (isMenuTransitioning || self.isConstructing) {
			return;
		}
		if (selectedTower === self) {
			closeActiveUpgradeMenu();
			return;
		}
		closeActiveUpgradeMenu();
		selectedTower = self;
		var upgradeMenu = game.addChild(new UpgradeMenu(self));
		upgradeMenu.x = 2048 / 2;
		isMenuTransitioning = true;
		tween(upgradeMenu, {
			y: 2732 - 250
		}, {
			duration: 200,
			easing: tween.backOut,
			onFinish: function onFinish() {
				isMenuTransitioning = false;
			}
		});
		var rangeCircle = new Container();
		rangeCircle.isTowerRange = true;
		rangeCircle.tower = self;
		var graphics = rangeCircle.attachAsset('rangeCircle', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		graphics.width = graphics.height = self.getRange() * 2;
		graphics.alpha = 0.2;
		graphics.tint = 0xFFFFFF;
		rangeCircle.x = self.x;
		rangeCircle.y = self.y;
		gateContainer.addChildAt(rangeCircle, gateContainer.children.indexOf(towerLayer));
	};
	return self;
});
var UpgradeMenu = Container.expand(function (tower) {
	var self = Container.call(this);
	self.tower = tower;
	self.y = 2732 + 225;
	var menuBackground = self.attachAsset('panel_upgrade_background', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	menuBackground.width = 1800;
	menuBackground.height = 550;
	var closeButton = new Container();
	var closeBackground = closeButton.attachAsset('notification', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 90,
		height: 90,
		tint: 0xAA0000
	});
	var closeText = new Text2('X', {
		size: 68,
		fill: 0xFFFFFF,
		weight: 800
	});
	closeText.anchor.set(0.5, 0.5);
	closeButton.addChild(closeText);
	closeButton.x = menuBackground.width / 2 - 57;
	closeButton.y = -menuBackground.height / 2 + 57;
	self.addChild(closeButton);
	closeButton.down = function () {
		hideUpgradeMenu(self);
	};
	function createStatLine(label, value, yPos, isBuffed) {
		var statLabel = new Text2(label + ':', {
			size: 55,
			fill: 0xFFFFFF,
			weight: 600,
			align: 'left'
		});
		statLabel.anchor.set(0, 0.5);
		statLabel.x = -620;
		statLabel.y = yPos;
		self.addChild(statLabel);
		var statValue = new Text2(value, {
			size: 55,
			fill: isBuffed ? 0x00FF00 : 0xFFD700,
			// ZIELONY jeśli wzmocnione
			weight: 800,
			align: 'left'
		});
		statValue.anchor.set(0, 0.5);
		statValue.x = statLabel.x + 300;
		statValue.y = yPos;
		self.addChild(statValue);
	}
	function populateStats() {
		var yStart = -120;
		var yStep = 70;
		var isDamageBuffed = self.tower.tileBuff && self.tower.tileBuff.damage;
		var isSpeedBuffed = self.tower.tileBuff && self.tower.tileBuff.attackSpeed;
		createStatLine('Damage', Math.round(self.tower.damage), yStart, isDamageBuffed);
		createStatLine('Fire Rate', Math.round(60 / self.tower.fireRate * 100) / 100 + '/s', yStart + yStep, isSpeedBuffed);
		createStatLine('Range', Math.round(self.tower.range / CELL_SIZE * 10) / 10, yStart + yStep * 2, false); // Zakładamy, że zasięg nie jest buffowany z pola
	}
	populateStats();
	function createUpgradeButton(upgradeKey, position, totalButtons) {
		var upgradeData = TOWER_DATA[self.tower.towerType][upgradeKey];
		if (!upgradeData) {
			return;
		}
		var button = new Container();
		var bg = button.attachAsset('button_upgrade', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		bg.width = 500;
		if (totalButtons > 1) {
			bg.height = (450 - 100) / totalButtons - 15;
		} else {
			bg.height = 140;
		}
		var buttonTextContent = upgradeData.name + '\n' + upgradeData.cost + 'g';
		var text = new Text2(buttonTextContent, {
			size: 40,
			fill: 0xFFFFFF,
			weight: 800,
			align: 'center',
			wordWrap: true,
			wordWrapWidth: bg.width - 20
		});
		text.anchor.set(0.5, 0.5);
		text.x = 20;
		button.addChild(text);
		var canAfford = gold >= upgradeData.cost;
		button.alpha = canAfford ? 1 : 0.7;
		button.down = function () {
			if (gold >= upgradeData.cost) {
				setGold(gold - upgradeData.cost);
				self.tower.upgrade(upgradeKey.replace((self.tower.level + 1).toString(), ''));
				hideUpgradeMenu(self);
			} else {
				var notification = game.addChild(new Notification("Not enough gold!"));
				notification.x = 2048 / 2;
				notification.y = grid.height - 50;
			}
		};
		button.x = position.x;
		button.y = position.y;
		self.addChild(button);
	}
	function populateUpgradeButtons() {
		var hasWorkshop = castleBuildings.some(function (b) {
			return b.id === 'workshop';
		});
		if (self.tower.level >= (hasWorkshop ? self.tower.maxLevel : 2)) {
			var maxLevelText = new Text2('Max Level', {
				size: 60,
				fill: 0xFFD700,
				weight: 800
			});
			if (self.tower.level === 2 && !hasWorkshop) {
				maxLevelText.setText("Requires Workshop");
				maxLevelText.size = 50;
			}
			maxLevelText.anchor.set(0.5, 0.5);
			maxLevelText.x = 300;
			self.addChild(maxLevelText);
			return;
		}
		var nextLevel = self.tower.level + 1;
		var upgradeKeys = Object.keys(TOWER_DATA[self.tower.towerType]).filter(function (key) {
			if (!key.startsWith(nextLevel.toString())) {
				return false;
			}
			if (self.tower.level === 2 && self.tower.levelPath && !key.includes(self.tower.levelPath)) {
				return false;
			}
			if (nextLevel >= 3 && !hasWorkshop) {
				return false;
			}
			return true;
		});
		var buttonX = 300;
		if (upgradeKeys.length === 1) {
			createUpgradeButton(upgradeKeys[0], {
				x: buttonX,
				y: 0
			}, 1);
		} else if (upgradeKeys.length > 1) {
			var totalButtonHeight = 450 - 100;
			var buttonHeight = totalButtonHeight / upgradeKeys.length;
			var startY = -totalButtonHeight / 2 + buttonHeight / 2;
			for (var i = 0; i < upgradeKeys.length; i++) {
				createUpgradeButton(upgradeKeys[i], {
					x: buttonX,
					y: startY + i * buttonHeight
				}, upgradeKeys.length);
			}
		}
	}
	populateUpgradeButtons();
	var originalDestroy = self.destroy;
	self.destroy = function () {
		for (var i = game.children.length - 1; i >= 0; i--) {
			if (game.children[i].isTowerRange && game.children[i].tower === self.tower) {
				gateContainer.removeChild(game.children[i]);
			}
		}
		if (selectedTower === self.tower) {
			selectedTower = null;
		}
		originalDestroy.call(self);
	};
	return self;
});
var WeatherSelection = Container.expand(function (levelNumber, onComplete) {
	var self = Container.call(this);
	self.levelNumber = levelNumber;
	self.onComplete = onComplete;
	self.cards = [];
	self.animationTicker = 0;
	self.animationDelay = 5;
	self.currentStep = 0;
	self.winningEventId = null;
	self.winningCardIndex = -1;
	self.stepsToGo = -1; // ZMIANA: Inicjalizujemy na -1, żeby update nie ruszył za wcześnie
	var bg = self.attachAsset('cell', {
		width: 2048,
		height: 2732,
		tint: 0x000000,
		alpha: 0
	});
	tween(bg, {
		alpha: 0.7
	}, {
		duration: 300
	});
	var visualCardTypes = ['SUNNY', 'RAIN', 'FOG', 'NIGHT', 'STORM'];
	var cardContainer = new Container();
	self.addChild(cardContainer);
	var cardSpacing = 240;
	var totalWidth = (visualCardTypes.length - 1) * cardSpacing;
	var startX = -totalWidth / 2;
	cardContainer.x = 2048 / 2;
	cardContainer.y = 2732 / 2 - 200;
	for (var i = 0; i < visualCardTypes.length; i++) {
		var eventId = visualCardTypes[i];
		var cardAsset = EVENT_DATA[eventId].asset;
		var card = cardContainer.attachAsset(cardAsset, {
			anchorX: 0.5,
			anchorY: 0.5
		});
		card.x = startX + i * cardSpacing;
		card.y = 500;
		card.alpha = 0;
		card.tint = 0x777777;
		self.cards.push(card);
		var tweenOptions = {
			duration: 400,
			delay: 100 + i * 150,
			easing: tween.backOut
		};
		// ZMIANA: Uruchom losowanie po zakończeniu animacji ostatniej karty
		if (i === visualCardTypes.length - 1) {
			tweenOptions.onFinish = function () {
				self.startSelection();
			};
		}
		tween(card, {
			y: 0,
			alpha: 1
		}, tweenOptions);
	}
	self.startSelection = function () {
		var deck = WEATHER_DECK_DATA[self.levelNumber] || WEATHER_DECK_DATA[1];
		self.winningEventId = deck[Math.floor(Math.random() * deck.length)];
		self.winningCardIndex = visualCardTypes.indexOf(self.winningEventId);
		var fullLoops = 2;
		self.stepsToGo = fullLoops * self.cards.length + self.winningCardIndex; // ZMIANA: Poprawiona kalkulacja kroków
	};
	self.showResult = function () {
		activeWeatherEvent = self.winningEventId;
		applyActiveWeatherModifiers();
		var winningCard = self.cards[self.winningCardIndex];
		winningCard.tint = 0xFFFFFF; // ZMIANA: Gwarancja podświetlenia
		var flash = self.attachAsset('cell', {
			width: 2048,
			height: 2732,
			tint: 0xFFFFFF,
			alpha: 0
		});
		tween(flash, {
			alpha: 0.7
		}, {
			duration: 100,
			onFinish: function onFinish() {
				tween(flash, {
					alpha: 0
				}, {
					duration: 150,
					onFinish: function onFinish() {
						flash.destroy();
					}
				});
			}
		});
		shakeScreen(15, 200);
		for (var i = 0; i < 30; i++) {
			var particle = self.attachAsset('star_particle', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			particle.x = winningCard.x + cardContainer.x + (Math.random() - 0.5) * 200;
			particle.y = winningCard.y + cardContainer.y + (Math.random() - 0.5) * 200;
			particle.scale.set(Math.random() * 0.5 + 0.3);
			tween(particle, {
				x: particle.x + (Math.random() - 0.5) * 400,
				y: particle.y + (Math.random() - 0.5) * 400,
				alpha: 0,
				scaleX: 0.1,
				scaleY: 0.1
			}, {
				duration: 800 + Math.random() * 500,
				onFinish: particle.destroy.bind(particle)
			});
		}
		for (var i = 0; i < self.cards.length; i++) {
			if (i !== self.winningCardIndex) {
				tween(self.cards[i], {
					alpha: 0,
					y: 50
				}, {
					duration: 300
				});
			}
		}
		tween(winningCard, {
			x: 0,
			y: -100,
			scaleX: 1.5,
			scaleY: 1.5
		}, {
			duration: 800,
			easing: tween.easeOut
		});
		var eventInfo = EVENT_DATA[self.winningEventId];
		var descriptionContainer = new Container();
		descriptionContainer.x = cardContainer.x;
		descriptionContainer.y = cardContainer.y + 400;
		descriptionContainer.alpha = 0;
		self.addChild(descriptionContainer);
		var nameText = new Text2(eventInfo.name, {
			size: 70,
			fill: 0xFFFFFF,
			weight: 800
		});
		nameText.anchor.set(0.5, 0.5);
		var descText = new Text2(eventInfo.description, {
			size: 50,
			fill: 0xDDDDDD,
			weight: 500,
			align: 'center',
			wordWrap: true,
			wordWrapWidth: 800
		});
		descText.anchor.set(0.5, 0.5);
		descText.y = 80;
		descriptionContainer.addChild(nameText);
		descriptionContainer.addChild(descText);
		tween(descriptionContainer, {
			alpha: 1
		}, {
			duration: 400,
			delay: 200
		});
		LK.setTimeout(function () {
			tween(self, {
				alpha: 0
			}, {
				duration: 500,
				onFinish: function onFinish() {
					if (self.onComplete) {
						self.onComplete();
					}
					self.destroy();
				}
			});
		}, 4000);
	};
	self.update = function () {
		if (self.stepsToGo > -1) {
			// ZMIANA: Sprawdzamy czy losowanie się zaczęło
			self.animationTicker++;
			if (self.animationTicker >= self.animationDelay) {
				self.animationTicker = 0;
				// ZMIANA: Uproszczona i bardziej niezawodna logika podświetlania
				self.cards.forEach(function (card) {
					card.tint = 0x777777;
				});
				var currentIndex = self.currentStep % self.cards.length;
				self.cards[currentIndex].tint = 0xFFFFFF;
				if (self.currentStep >= self.stepsToGo) {
					self.stepsToGo = -1; // Zatrzymaj pętlę losowania
					// Ostatnie podświetlenie na właściwej karcie
					self.cards.forEach(function (card) {
						card.tint = 0x777777;
					});
					self.cards[self.winningCardIndex].tint = 0xFFFFFF;
					LK.setTimeout(function () {
						self.showResult();
					}, 1000);
				} else {
					self.currentStep++;
					// Zwalnianie animacji
					if (self.stepsToGo - self.currentStep < 5) {
						self.animationDelay += 4;
					} else if (self.stepsToGo - self.currentStep < 10) {
						self.animationDelay += 1;
					}
				}
			}
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
/**** * Game Code
****/ 
function hideBuildingInfoMenu(menu) {
	if (isHidingUpgradeMenu) {
		return;
	}
	isHidingUpgradeMenu = true;
	isMenuTransitioning = true;
	tween(menu, {
		y: 2732 + 225
	}, {
		duration: 150,
		easing: tween.easeIn,
		onFinish: function onFinish() {
			menu.destroy();
			isHidingUpgradeMenu = false;
			isMenuTransitioning = false;
		}
	});
}
function shakeScreen(intensity, duration) {
	var initialX = game.x;
	var initialY = game.y;
	var shakeTicker = 0;
	var shakeDuration = Math.ceil(duration / 10); // Czas trwania w cyklach
	function doShake() {
		if (shakeTicker >= shakeDuration) {
			game.x = initialX;
			game.y = initialY;
			return;
		}
		var shakeX = (Math.random() - 0.5) * intensity;
		var shakeY = (Math.random() - 0.5) * intensity;
		game.x = initialX + shakeX;
		game.y = initialY + shakeY;
		shakeTicker++;
		LK.setTimeout(doShake, 10);
	}
	doShake();
}
function createHitSparks(x, y) {
	var numSparks = 5;
	for (var i = 0; i < numSparks; i++) {
		var spark = new Container();
		var sparkGraphics = spark.attachAsset('star_particle', {
			anchorX: 0.5,
			anchorY: 0.5,
			tint: 0xFFD700
		});
		spark.x = x;
		spark.y = y;
		gateContainer.addChild(spark);
		var angle = Math.random() * Math.PI * 2;
		var distance = Math.random() * 40 + 20;
		tween(spark, {
			x: x + Math.cos(angle) * distance,
			y: y + Math.sin(angle) * distance,
			alpha: 0
		}, {
			duration: 500,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				spark.destroy();
			}
		});
	}
}
function applyActiveWeatherModifiers() {
	if (activeWeatherEvent === 'FOG') {
		towers.forEach(function (tower) {
			if (tower.towerType === 'mage') {
				tower.addBuff({
					source: 'FOG_DEBUFF',
					effect: {
						damage: EVENT_DATA.FOG.modifier.mageTowerDebuff
					}
				});
			}
		});
	}
}
function clearActiveWeatherModifiers() {
	towers.forEach(function (tower) {
		tower.removeBuff('FOG_DEBUFF');
	});
}
function showSpellOverlay() {
	spellOverlay.visible = true;
	tween(spellOverlay, {
		alpha: 0.7
	}, {
		duration: 650,
		easing: tween.easeOut
	});
}
function hideSpellOverlay() {
	tween(spellOverlay, {
		alpha: 0
	}, {
		duration: 400,
		easing: tween.easeIn,
		onFinish: function onFinish() {
			spellOverlay.visible = false;
		}
	});
}
var CELL_SIZE = 76;
var TOWER_DATA = {
	'guard': {
		1: {
			name: 'Guard Tower',
			cost: 30,
			damage: 5,
			fireRate: 60,
			range: 5 * CELL_SIZE,
			bulletSpeed: 7,
			graphic: 'arrow_guard'
		},
		2: {
			name: 'Veteran Guard',
			cost: 80,
			// Zwiększono z 60
			damage: 9,
			fireRate: 70,
			multiShot: 2,
			range: 5 * CELL_SIZE,
			bulletSpeed: 7,
			graphic: 'arrow_guard'
		},
		3: {
			name: 'Elite Guard',
			cost: 155,
			// Zwiększono ze 120
			damage: 16,
			fireRate: 85,
			multiShot: 3,
			range: 6 * CELL_SIZE,
			bulletSpeed: 7,
			graphic: 'arrow_guard'
		}
	},
	'crossbow': {
		1: {
			name: 'Crossbow Tower',
			cost: 50,
			damage: 13,
			fireRate: 150,
			range: 7 * CELL_SIZE,
			bulletSpeed: 15,
			graphic: 'arrow_crossbow'
		},
		2: {
			name: 'Heavy Crossbow',
			cost: 130,
			// Zwiększono ze 100
			damage: 25,
			fireRate: 150,
			range: 7.5 * CELL_SIZE,
			bulletSpeed: 15,
			graphic: 'arrow_crossbow'
		},
		3: {
			name: 'Arbalest',
			cost: 260,
			// Zwiększono z 200
			damage: 30,
			fireRate: 150,
			multiShot: 2,
			range: 8 * CELL_SIZE,
			bulletSpeed: 15,
			graphic: 'arrow_crossbow'
		}
	},
	'mage': {
		1: {
			name: 'Mage Tower',
			cost: 40,
			damage: 8,
			fireRate: 90,
			range: 5 * CELL_SIZE,
			bulletSpeed: 8,
			bulletType: 'normal',
			graphic: 'bullet'
		},
		'2F': {
			name: 'Fire Mage',
			cost: 105,
			damage: 10,
			fireRate: 120,
			range: 6 * CELL_SIZE,
			bulletSpeed: 8,
			bulletType: 'splash',
			splashDamage: 8,
			splashRadius: 1.3 * CELL_SIZE,
			splashScale: 1.4,
			graphic: 'projectile_fireball'
		},
		'3F': {
			name: 'Pyromancer',
			cost: 200,
			damage: 15,
			fireRate: 120,
			range: 6.5 * CELL_SIZE,
			bulletSpeed: 8,
			bulletType: 'splash',
			splashDamage: 12,
			splashRadius: 1.6 * CELL_SIZE,
			splashScale: 1.7,
			graphic: 'projectile_fireball'
		},
		'2W': {
			name: 'Water Mage',
			cost: 105,
			damage: 9,
			fireRate: 140,
			range: 6 * CELL_SIZE,
			bulletSpeed: 8,
			bulletType: 'slow',
			slowAmount: 0.6,
			multiShot: 2,
			slowDuration: 120,
			slowChance: 0.4,
			graphic: ['ice_spike_1', 'ice_spike_2', 'ice_spike_3', 'ice_spike_4', 'ice_spike_5']
		},
		'3W': {
			name: 'Ice Archmage',
			cost: 210,
			damage: 12,
			fireRate: 160,
			range: 6.5 * CELL_SIZE,
			bulletSpeed: 8,
			bulletType: 'slow',
			slowAmount: 0.5,
			multiShot: 2,
			slowDuration: 140,
			slowChance: 0.6,
			graphic: ['ice_spike_1', 'ice_spike_2', 'ice_spike_3', 'ice_spike_4', 'ice_spike_5']
		},
		'2L': {
			name: 'Lightning Mage',
			cost: 105,
			damage: 9,
			fireRate: 150,
			range: 7 * CELL_SIZE,
			bulletSpeed: 20,
			bulletType: 'chain',
			chainTargets: 3,
			chainDamageFalloff: 2,
			chainChance: 0.25,
			graphic: 'bullet'
		},
		'3L': {
			name: 'Stormcaller',
			cost: 210,
			damage: 16,
			fireRate: 150,
			range: 7.5 * CELL_SIZE,
			bulletSpeed: 20,
			bulletType: 'chain',
			chainTargets: 3,
			chainDamageFalloff: 2,
			chainChance: 0.45,
			graphic: 'bullet'
		}
	},
	'banner': {
		1: {
			name: 'War Banner',
			cost: 50,
			damage: 0,
			range: 4 * CELL_SIZE,
			aura: {
				'attackSpeed': 1.15
			}
		},
		'2A': {
			name: 'Banner of Fury',
			cost: 130,
			// Zwiększono ze 100
			range: 4 * CELL_SIZE,
			aura: {
				'attackSpeed': 1.3
			}
		},
		'2B': {
			name: 'Banner of Command',
			cost: 130,
			// Zwiększono ze 100
			range: 4 * CELL_SIZE,
			aura: {
				'attackSpeed': 1.15,
				'damage': 1.15
			}
		}
	}
};
var BUILDING_DATA = {
	'home': {
		id: 'home',
		name: 'Home',
		size: {
			w: 3,
			h: 3
		},
		cost: 50,
		description: 'Each Home increases your max Population by 5.'
	},
	'training_ground': {
		id: 'training_ground',
		name: 'Training Ground',
		size: {
			w: 3,
			h: 3
		},
		// Przykładowy rozmiar
		cost: 100,
		// Przykładowy koszt
		description: 'All recruited units gain +5% Health and Attack. This effect stacks.'
	},
	'workshop': {
		id: 'workshop',
		name: 'Workshop',
		size: {
			w: 4,
			h: 3
		},
		cost: 150,
		description: 'Unlocks advanced tower upgrades (Level 3+).'
	},
	'magic_sanctum': {
		id: 'magic_sanctum',
		name: 'Magic Sanctum',
		size: {
			w: 3,
			h: 3
		},
		// Przykładowy rozmiar
		cost: 100,
		// Przykładowy koszt
		description: 'Increases the effectiveness of all spells by 10%. This effect stacks.'
	},
	'barracks': {
		id: 'barracks',
		name: 'Barracks',
		size: {
			w: 6,
			h: 7
		},
		cost: 200,
		description: 'Unlocks the Army panel and allows recruitment of units.'
	},
	'magic_academy': {
		id: 'magic_academy',
		name: 'Magic Academy',
		size: {
			w: 6,
			h: 8
		},
		cost: 200,
		description: 'Unlocks Mana and the Magic panel, allowing you to cast powerful spells.'
	},
	'tavern': {
		id: 'tavern',
		name: 'Tavern',
		size: {
			w: 5,
			h: 5
		},
		cost: 120,
		description: 'Generates income each wave. Each Tavern provides 30g, plus a bonus of +2g for each person in your population.'
	},
	'smithy': {
		id: 'smithy',
		name: 'Smithy',
		size: {
			w: 5,
			h: 6
		},
		cost: 150,
		description: 'Provides global buffs to towers and units.'
	},
	'infirmary': {
		id: 'infirmary',
		name: 'Infirmary',
		size: {
			w: 4,
			h: 3
		},
		cost: 200,
		description: 'Reduces the time it takes for population to regenerate after a unit dies.'
	}
};
var SPELL_DATA = {
	'fire_wall': {
		id: 'fire_wall',
		name: 'Fire Wall',
		description: 'Damages enemies in an area.',
		cost: 0,
		radius: 2.5 * CELL_SIZE,
		duration: 460,
		dotDamage: 7,
		dotDuration: 180
	},
	'healing_field': {
		id: 'healing_field',
		name: 'Healing Field',
		description: 'Heals allied targets in an area.',
		cost: 0,
		heal: 25,
		radius: 3 * CELL_SIZE
	},
	'lightning_stun': {
		id: 'lightning_stun',
		name: 'Thunderstorm',
		description: 'Stuns and damages enemies in an area.',
		cost: 0,
		stunDuration: 2 * 60,
		radius: 3 * CELL_SIZE,
		damage: 15,
		duration: 90
	},
	'summon_golem': {
		id: 'summon_golem',
		name: 'Summon Golem',
		description: 'Summons a temporary blocker unit.',
		cost: 0,
		radius: 0
	},
	'curse': {
		id: 'curse',
		name: 'Curse',
		description: 'Cursed enemies move slower and take more damage.',
		cost: 0,
		damageMultiplier: 1.10,
		slowFactor: 0.85,
		duration: 480,
		radius: 3.5 * CELL_SIZE
	}
};
var LEVEL_DATA_ALL = {
	1: {
		levelName: "Level 1: Royal Road",
		mapAsset: 'map1',
		initialGold: 600,
		initialLives: 20,
		mapLayout: ["222222221100011222222222", "22222222AA00011222222222", "222222221100011222222222", "222222221100011222222222", "2222222211000AA222222222", "222222221100011222222222", "222222221100011222222222", "222222221100011222222222", "222222221100011222222222", "222222221100011222222222", "222222221100011222222222", "222222221100011222222222", "222222221100011222222222", "222222221100011222222222", "222222221100011222222222", "222222221100011222222222", "222222221100011222222222", "222222221100011222222222", "222222221100011222222222", "222222221100011222222222", "222222221100011222222222", "222222221100011222222222", "222222221100011222222222", "222222221100011222222222", "222222221100011222222222", "222222221100011222222222", "222222221100011222222222", "222222221100011222222222", "222222221100011222222222", "2222222211E0011222222222"],
		castleMapLayout: ["11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111"],
		spawnPoints: [{
			id: 'mainPath',
			startX: 11,
			startY: 5,
			goalX: 11,
			goalY: 34,
			lanes: [{
				id: 'mainPath_L',
				offset: -0.6
			}, {
				id: 'mainPath_C',
				offset: 0
			}, {
				id: 'mainPath_R',
				offset: 0.6
			}]
		}],
		waves: [{
			wave: 1,
			phases: [{
				delay: 0,
				interval: 140,
				units: [{
					spawner: 'mainPath',
					type: 'normal',
					count: 12
				}]
			}]
		}, {
			wave: 2,
			phases: [{
				delay: 0,
				interval: 100,
				units: [{
					spawner: 'mainPath',
					type: 'normal',
					count: 10
				}]
			}, {
				delay: 450,
				interval: 120,
				units: [{
					spawner: 'mainPath',
					type: 'shield',
					count: 6
				}]
			}]
		}, {
			wave: 3,
			phases: [{
				delay: 0,
				interval: 110,
				units: [{
					spawner: 'mainPath',
					type: 'normal',
					count: 8
				}, {
					spawner: 'mainPath',
					type: 'shield',
					count: 3
				}]
			}, {
				delay: 600,
				interval: 60,
				units: [{
					spawner: 'mainPath',
					type: 'rider',
					count: 9
				}]
			}]
		}, {
			wave: 4,
			phases: [{
				delay: 0,
				interval: 130,
				units: [{
					spawner: 'mainPath',
					type: 'shield',
					count: 10
				}]
			}, {
				delay: 240,
				interval: 100,
				units: [{
					spawner: 'mainPath',
					type: 'archer',
					count: 8
				}]
			}, {
				delay: 500,
				interval: 80,
				units: [{
					spawner: 'mainPath',
					type: 'rider',
					count: 6
				}]
			}]
		}, {
			wave: 5,
			phases: [{
				delay: 0,
				interval: 70,
				units: [{
					spawner: 'mainPath',
					type: 'normal',
					count: 15
				}]
			}, {
				delay: 400,
				interval: 110,
				units: [{
					spawner: 'mainPath',
					type: 'shield',
					count: 10
				}, {
					spawner: 'mainPath',
					type: 'archer',
					count: 8
				}]
			}, {
				delay: 400,
				interval: 60,
				units: [{
					spawner: 'mainPath',
					type: 'rider',
					count: 10
				}]
			}]
		}, {
			wave: 6,
			phases: [{
				delay: 0,
				interval: 100,
				units: [{
					spawner: 'mainPath',
					type: 'shield',
					count: 10
				}, {
					spawner: 'mainPath',
					type: 'archer',
					count: 8
				}]
			}, {
				delay: 400,
				interval: 80,
				units: [{
					spawner: 'mainPath',
					type: 'chieftain',
					count: 1,
					isBoss: true
				}, {
					spawner: 'mainPath',
					type: 'rider',
					count: 10
				}]
			}]
		}]
	},
	2: {
		levelName: "Level 2: Old Mill Path",
		mapAsset: 'map2',
		initialGold: 650,
		initialLives: 20,
		mapLayout: ["110021111222222222222222", "110021111222222222222222", "110021111222222222222222", "110021111222222222222222", "110021111222222222222222", "110021111222222222222222", "110021111222222222222222", "110021111222222222222222", "110021111111111111111111", "110021111111111111111111", "110021111111111111111111", "110000000000000000000000", "110000000000000000000000", "222222222222222222222200", "111111111111111111111100", "111111111111111111111100", "111111111111111111111100", "222222222222222221111100", "222222222222222221111100", "222222222222222221111100", "222222222222222221111100", "222222222222222221111100", "222222222222222221111100", "222222222222222221111100", "222222222222222221111100", "222222222222222221111100", "222222222222222221111100", "222222222222222221111100", "222222222222222221111100", "2222222222222222211111E0"],
		castleMapLayout: ["11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111"],
		spawnPoints: [{
			id: 'mainPath',
			startX: 2,
			startY: 5,
			goalX: 23,
			goalY: 34,
			lanes: [{
				id: 'mainPath_L',
				offset: 0.2
			}, {
				id: 'mainPath_C',
				offset: 0
			}, {
				id: 'mainPath_R',
				offset: 1.8
			}]
		}],
		waves: [{
			wave: 1,
			phases: [{
				delay: 0,
				interval: 120,
				units: [{
					spawner: 'mainPath',
					type: 'normal',
					count: 10
				}, {
					spawner: 'mainPath',
					type: 'rider',
					count: 4
				}]
			}]
		}, {
			wave: 2,
			phases: [{
				delay: 0,
				interval: 150,
				units: [{
					spawner: 'mainPath',
					type: 'shield',
					count: 12
				}]
			}, {
				delay: 600,
				interval: 100,
				units: [{
					spawner: 'mainPath',
					type: 'archer',
					count: 8
				}]
			}]
		}, {
			wave: 3,
			phases: [{
				delay: 0,
				interval: 80,
				units: [{
					spawner: 'mainPath',
					type: 'normal',
					count: 20
				}]
			}, {
				delay: 500,
				interval: 50,
				units: [{
					spawner: 'mainPath',
					type: 'rider',
					count: 10
				}]
			}]
		}, {
			wave: 4,
			phases: [{
				delay: 0,
				interval: 130,
				units: [{
					spawner: 'mainPath',
					type: 'shield',
					count: 15
				}]
			}, {
				delay: 300,
				interval: 100,
				units: [{
					spawner: 'mainPath',
					type: 'archer',
					count: 12
				}]
			}]
		}, {
			wave: 5,
			phases: [{
				delay: 0,
				interval: 180,
				units: [{
					spawner: 'mainPath',
					type: 'rider',
					count: 12
				}]
			}, {
				delay: 400,
				interval: 90,
				units: [{
					spawner: 'mainPath',
					type: 'normal',
					count: 15
				}, {
					spawner: 'mainPath',
					type: 'shield',
					count: 10
				}]
			}]
		}, {
			wave: 6,
			phases: [{
				delay: 0,
				interval: 120,
				units: [{
					spawner: 'mainPath',
					type: 'shield',
					count: 18
				}]
			}, {
				delay: 700,
				interval: 400,
				units: [{
					spawner: 'mainPath',
					type: 'chieftain',
					count: 2,
					isBoss: true
				}, {
					spawner: 'mainPath',
					type: 'archer',
					count: 8
				}]
			}]
		}]
	},
	3: {
		levelName: "Level 3: Twin Pass",
		mapAsset: 'map3',
		initialGold: 750,
		initialLives: 20,
		mapLayout: ["111100000111100000111111", "111100000111100000111111", "111100000111100000111111", "111100000111100000111111", "111100000111100000111111", "111100000111100000111111", "111100000111100000111111", "111100000111100000111111", "111100000111100000111111", "111100000111100000111111", "111100000111100000111111", "111100000111100000111111", "111100000111100000111111", "111100000111100000111111", "111100000111100000111111", "111100000111100000111111", "111100000111100000111111", "111100000111100000111111", "111100000111100000111111", "111100000111100000111111", "111100000111100000111111", "111100000111100000111111", "111100000111100000111111", "111100000111100000111111", "111100000111100000111111", "111100000111100000111111", "111100000111100000111111", "111100000111100000111111", "111100000111100000111111", "111100000111100000111111"],
		castleMapLayout: ["11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111", "11111111111111111"],
		spawnPoints: [{
			id: 'leftPath',
			startX: 4,
			startY: 5,
			goalX: 4,
			goalY: 34,
			lanes: [{
				id: 'leftPath_L',
				offset: 2
			}, {
				id: 'leftPath_R',
				offset: 2
			}]
		}, {
			id: 'rightPath',
			startX: 13,
			startY: 5,
			goalX: 13,
			goalY: 34,
			lanes: [{
				id: 'rightPath_L',
				offset: -0.4
			}, {
				id: 'rightPath_R',
				offset: 0.4
			}]
		}],
		waves: [{
			wave: 1,
			phases: [{
				delay: 0,
				interval: 140,
				units: [{
					spawner: 'leftPath',
					type: 'normal',
					count: 10
				}, {
					spawner: 'rightPath',
					type: 'normal',
					count: 10
				}]
			}]
		}, {
			wave: 2,
			phases: [{
				delay: 0,
				interval: 120,
				units: [{
					spawner: 'leftPath',
					type: 'shield',
					count: 8
				}, {
					spawner: 'rightPath',
					type: 'rider',
					count: 12
				}]
			}]
		}]
	}
};
var EVENT_DATA = {
	'SUNNY': {
		name: 'Sunny Day',
		description: 'A calm day. No special effects.',
		asset: 'card_sunny'
	},
	'RAIN': {
		name: 'Rainy Day',
		description: 'Enemies drop 20% less gold.',
		asset: 'card_rain'
	},
	'NIGHT': {
		name: 'Night',
		description: 'Enemies are 10% stronger.',
		asset: 'card_night',
		modifier: {
			enemyStatMultiplier: 1.10
		}
	},
	'STORM': {
		name: 'Storm',
		description: 'Recruitment of all units is disabled for this wave.',
		asset: 'card_storm'
	},
	'FOG': {
		name: 'Fog',
		description: 'Magic is disabled. Mage Towers deal 10% less damage.',
		asset: 'card_fog'
	}
};
var WEATHER_DECK_DATA = {
	1: ['SUNNY', 'SUNNY', 'SUNNY', 'NIGHT', 'RAIN'],
	2: ['SUNNY', 'SUNNY', 'NIGHT', 'RAIN', 'FOG'],
	3: ['SUNNY', 'RAIN', 'NIGHT', 'FOG', 'STORM']
};
var UNIT_DATA = {
	'swordsman': {
		id: 'swordsman',
		name: 'Swordsman',
		cost: 25,
		speed: 1.2,
		maxHealth: 20,
		damage: 2,
		attackSpeed: 90,
		range: 1.2 * CELL_SIZE,
		detectionRange: 3 * CELL_SIZE,
		isRanged: false
	},
	'defender': {
		id: 'defender',
		name: 'Defender',
		cost: 40,
		speed: 0.9,
		maxHealth: 40,
		damage: 2,
		attackSpeed: 100,
		range: 1.2 * CELL_SIZE,
		detectionRange: 3 * CELL_SIZE,
		isRanged: false
	},
	'horseman': {
		id: 'horseman',
		name: 'Horseman',
		cost: 60,
		speed: 1.8,
		maxHealth: 50,
		damage: 5,
		attackSpeed: 80,
		range: 1.3 * CELL_SIZE,
		detectionRange: 3.5 * CELL_SIZE,
		isRanged: false
	},
	'archer': {
		id: 'archer',
		name: 'Archer',
		cost: 40,
		speed: 1.1,
		maxHealth: 15,
		damage: 6,
		attackSpeed: 48,
		range: 5 * CELL_SIZE,
		detectionRange: 6 * CELL_SIZE,
		isRanged: true
	}
};
var isBuildPhase = false;
var buildPhaseTimer = 0;
var startGameButton;
var timerText;
var pathId;
var buildingDeck;
var spellOverlay;
var spellEffectLayer;
var buildingHand;
var castleBuildings;
var castleBuildingsLayer;
var statsPanel;
var statsDetailsContainer;
var statsToggleButton;
var isStatsPanelExpanded = false;
var maxScore;
var enemies;
var towers;
var bullets;
var selectedTower;
var selectedBuilding;
var isDragging;
var isDraggingSpell;
var lastRecruitActionTick;
var panelActionTaken;
var gold;
var lives;
var mana;
var numberOfTaverns;
var levelData;
var isManaUnlocked;
var enemiesKilled;
var enemiesInCurrentWave;
var levelData;
var currentWave;
var totalWaves;
var waveTimer;
var waveInProgress;
var waveSpawned;
var nextWaveTime;
var sourceTowers;
var grid;
var specialZoneIndicators;
var wavesText;
var towerLayer;
var spawnQueue;
var waveClock;
var enemyLayer;
var debugLayer;
var buildableTilesLayer;
var castleBuildableTilesLayer;
var specialTilesLayer;
var enemyLayerBottom;
var enemyLayerMiddle;
var enemyLayerTop;
var placementPreview;
var buildPanelContainer;
var buildButton;
var rerollButton;
var isBuildPanelOpen;
var currentActiveView;
var gateContainer;
var currentLevelNumber;
var castleContainer;
var activeWeatherEvent = null;
var viewToggleButton;
var castleGrid;
var castleBuildPanel;
var magicButton;
var magicPanelContainer;
var armyButton;
var armyPanelContainer;
var mainActionPanel;
var buildPage, magicPage, armyPage;
var isMainPanelOpen = false;
var currentOpenPage = 'build';
var isArmyUnlocked;
var panelActionTaken;
var spellPreview;
var activeSpells;
friendlyUnits = [];
var friendlyUnitLayer;
var peopleRegenQueue;
var currentScreenState = '';
var titleScreenContainer = null;
var levelSelectContainer = null;
var isHidingUpgradeMenu = false;
var isMenuTransitioning = false;
function hideUpgradeMenu(menu) {
	if (isHidingUpgradeMenu) {
		return;
	}
	isHidingUpgradeMenu = true;
	isMenuTransitioning = true;
	tween(menu, {
		y: 2732 + 225
	}, {
		duration: 150,
		easing: tween.easeIn,
		onFinish: function onFinish() {
			menu.destroy();
			isHidingUpgradeMenu = false;
			isMenuTransitioning = false;
		}
	});
}
function showPageInMainPanel(pageName) {
	if (buildPage) {
		buildPage.visible = pageName === 'build';
	}
	if (magicPage) {
		magicPage.visible = pageName === 'magic';
	}
	if (armyPage) {
		armyPage.visible = pageName === 'army';
	}
}
function toggleMainPanel(pageToShow) {
	var targetY;
	var panelShouldBeOpen;
	if (isMainPanelOpen && currentOpenPage === pageToShow) {
		panelShouldBeOpen = false;
	} else {
		panelShouldBeOpen = true;
	}
	if (panelShouldBeOpen) {
		showPageInMainPanel(pageToShow);
		currentOpenPage = pageToShow;
		targetY = 2732 - 250;
		isMainPanelOpen = true;
	} else {
		targetY = 2732 + 100;
		isMainPanelOpen = false;
	}
	if (mainActionPanel) {
		tween(mainActionPanel, {
			y: targetY
		}, {
			duration: 300,
			easing: tween.backOut
		});
	}
}
function closeActiveUpgradeMenu() {
	if (isMenuTransitioning) {
		return;
	}
	game.children.forEach(function (child) {
		if (child instanceof UpgradeMenu) {
			hideUpgradeMenu(child);
		}
	});
	for (var i = gateContainer.children.length - 1; i >= 0; i--) {
		if (gateContainer.children[i].isTowerRange) {
			gateContainer.removeChild(gateContainer.children[i]);
		}
	}
	selectedTower = null;
}
function updateUI() {
	goldText.setText('Gold: ' + gold);
	livesText.setText('Lives: ' + lives);
	enemiesText.setText('Enemies: ' + enemiesKilled + '/' + enemiesInCurrentWave);
	peopleText.setText('People: ' + people + '/' + maxPeople);
	wavesText.setText('Wave: ' + currentWave + '/' + totalWaves);
	if (isManaUnlocked) {
		manaText.visible = true;
		manaText.setText('Mana: ' + mana);
	}
}
function setGold(value) {
	gold = value;
	updateUI();
}
function setMana(value) {
	if (isManaUnlocked) {
		mana = value;
		updateUI();
	}
}
function getTowerCost(towerType) {
	var cost = 0;
	if (TOWER_DATA[towerType] && TOWER_DATA[towerType][1]) {
		cost = TOWER_DATA[towerType][1].cost;
	}
	if (!isBuildPhase && currentWave > 0) {
		cost = Math.floor(cost * 1.5);
	}
	return cost;
}
function getTowerSellValue(totalValue) {
	return Math.floor(totalValue * 0.6);
}
function getBuildingCost(buildingType) {
	var count = 0;
	for (var i = 0; i < castleBuildings.length; i++) {
		if (castleBuildings[i].id === buildingType) {
			count++;
		}
	}
	var baseCost = BUILDING_DATA[buildingType] ? BUILDING_DATA[buildingType].cost : 0;
	var finalCost = {
		gold: Math.floor(baseCost * Math.pow(1.2, count)),
		people: 0 // Placeholder, if buildings cost people in the future
	};
	return finalCost;
}
function getModifiedSpellData(spellId) {
	var originalData = SPELL_DATA[spellId];
	var modifiedData = JSON.parse(JSON.stringify(originalData)); // Tworzymy głęboką kopię
	var sanctumCount = castleBuildings.filter(function (b) {
		return b.id === 'magic_sanctum';
	}).length;
	if (sanctumCount > 0) {
		var spellBonus = Math.pow(1.10, sanctumCount);
		if (modifiedData.damage) {
			modifiedData.damage = Math.round(modifiedData.damage * spellBonus);
		}
		if (modifiedData.dotDamage) {
			modifiedData.dotDamage = Math.round(modifiedData.dotDamage * spellBonus);
		}
		if (modifiedData.stunDuration) {
			modifiedData.stunDuration = Math.round(modifiedData.stunDuration * spellBonus);
		}
		if (modifiedData.heal) {
			modifiedData.heal = Math.round(modifiedData.heal * spellBonus);
		}
		if (modifiedData.duration) {
			modifiedData.duration = Math.round(modifiedData.duration * spellBonus);
		}
		// Możemy tu dodać więcej statystyk w razie potrzeby
	}
	return modifiedData;
}
function setupStatsPanel() {
	isStatsPanelExpanded = false;
	statsPanel = new Container();
	statsPanel.x = 0;
	statsPanel.y = 0;
	LK.gui.top.addChild(statsPanel);
	var panelBg = statsPanel.attachAsset('panel_topbar_background', {
		anchorX: 0.5,
		anchorY: 0
	});
	panelBg.y = -20;
	statsPanel.hitAreaWidth = panelBg.width;
	statsPanel.hitAreaHeight = 300; // Zostawiamy dla pewności
	var maxBgHeight = 260;
	var minBgHeight = 120;
	panelBg.height = maxBgHeight; // Ustawiamy na stałe maksymalną wysokość
	var initialScaleY = minBgHeight / maxBgHeight;
	panelBg.scale.y = initialScaleY; // Zaczynamy ze zmniejszoną skalą
	var textY = 35;
	goldText = new Text2('Gold: 0', {
		size: 50,
		fill: 0xFFD700,
		weight: 800
	});
	goldText.anchor.set(0.5, 0.5);
	goldText.x = -400;
	goldText.y = textY;
	statsPanel.addChild(goldText);
	livesText = new Text2('Lives: 0', {
		size: 50,
		fill: 0x00FF00,
		weight: 800
	});
	livesText.anchor.set(0.5, 0.5);
	livesText.x = 400;
	livesText.y = textY;
	statsPanel.addChild(livesText);
	timerText = new Text2('', {
		size: 45,
		fill: 0xFFD700,
		weight: 700
	});
	timerText.anchor.set(0.5, 0.5);
	timerText.x = 0;
	timerText.y = textY;
	timerText.visible = false;
	statsPanel.addChild(timerText);
	statsDetailsContainer = new Container();
	statsDetailsContainer.y = 70;
	statsDetailsContainer.visible = false;
	statsPanel.addChild(statsDetailsContainer);
	var detailsTextOptions = {
		size: 45,
		fill: 0xFFFFFF,
		weight: 600,
		align: 'center'
	};
	peopleText = new Text2('People: 0/0', detailsTextOptions);
	peopleText.anchor.set(0.5, 0.5);
	peopleText.x = -400;
	peopleText.y = 40;
	statsDetailsContainer.addChild(peopleText);
	manaText = new Text2('Mana: 0', detailsTextOptions);
	manaText.anchor.set(0.5, 0.5);
	manaText.x = -400;
	manaText.y = 90;
	manaText.visible = false;
	statsDetailsContainer.addChild(manaText);
	wavesText = new Text2('Wave: 0/0', detailsTextOptions);
	wavesText.anchor.set(0.5, 0.5);
	wavesText.x = 400;
	wavesText.y = 40;
	statsDetailsContainer.addChild(wavesText);
	enemiesText = new Text2('Enemies: 0/0', detailsTextOptions);
	enemiesText.anchor.set(0.5, 0.5);
	enemiesText.x = 400;
	enemiesText.y = 90;
	statsDetailsContainer.addChild(enemiesText);
	statsToggleButton = new Container();
	statsToggleButton.x = 0;
	statsToggleButton.y = 35;
	statsPanel.addChild(statsToggleButton);
	var arrow = statsToggleButton.attachAsset('player_arrow', {
		anchorX: 0.5,
		anchorY: 0.5,
		tint: 0xFFFFFF
	});
	arrow.scale.set(1.5, 1.5);
	arrow.rotation = Math.PI / 2;
	statsToggleButton.down = function () {
		isStatsPanelExpanded = !isStatsPanelExpanded;
		var targetScaleY = isStatsPanelExpanded ? 1.0 : initialScaleY;
		var targetArrowRotation = isStatsPanelExpanded ? -Math.PI / 2 : Math.PI / 2;
		var targetButtonY = isStatsPanelExpanded ? 225 : 35;
		if (isStatsPanelExpanded) {
			statsDetailsContainer.visible = true;
		}
		tween(panelBg, {
			scaleY: targetScaleY
		}, {
			duration: 250,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				if (!isStatsPanelExpanded) {
					statsDetailsContainer.visible = false;
				}
			}
		});
		tween(arrow, {
			rotation: targetArrowRotation
		}, {
			duration: 250,
			easing: tween.easeOut
		});
		tween(statsToggleButton, {
			y: targetButtonY
		}, {
			duration: 250,
			easing: tween.easeOut
		});
	};
}
// --- FUNKCJE EKRANÓW ---
function showTitleScreen() {
	if (titleScreenContainer) {
		titleScreenContainer.destroy();
	}
	titleScreenContainer = new Container();
	game.addChild(titleScreenContainer);
	currentScreenState = 'title';
	if (LK.gui.top) {
		LK.gui.top.visible = false;
	}
	var bg = titleScreenContainer.attachAsset('title_background', {});
	bg.scaleX = 1.1;
	bg.scaleY = 1.1;
	bg.x = -100;
	var gameTitleGraphic = titleScreenContainer.attachAsset('title_graphic', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	gameTitleGraphic.x = 2048 / 2;
	gameTitleGraphic.y = 2732 / 2 - 400;
	gameTitleGraphic.alpha = 0;
	var startButton = titleScreenContainer.attachAsset('start_button_graphic', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	startButton.x = 2048 / 2;
	startButton.y = 2732 / 2 + 200;
	startButton.interactive = true;
	startButton.alpha = 0;
	startButton.down = function () {
		gameTitleGraphic.destroy();
		startButton.destroy();
		showLevelSelectScreen();
	};
	tween(gameTitleGraphic, {
		alpha: 1
	}, {
		duration: 2000,
		delay: 3000,
		easing: tween.easeIn
	});
	tween(startButton, {
		alpha: 1
	}, {
		duration: 1000,
		delay: 5000,
		easing: tween.easeIn
	});
	function animateBg() {
		if (!bg.parent) {
			return;
		}
		tween(bg, {
			x: 0
		}, {
			duration: 14000,
			easing: tween.easeInOut,
			onFinish: function onFinish() {
				tween(bg, {
					x: -100
				}, {
					duration: 14000,
					easing: tween.easeInOut,
					onFinish: animateBg
				});
			}
		});
	}
	animateBg();
}
function showLevelSelectScreen() {
	if (levelSelectContainer) {
		levelSelectContainer.destroy();
	}
	levelSelectContainer = new Container();
	game.addChild(levelSelectContainer);
	currentScreenState = 'levelSelect';
	var parchment = levelSelectContainer.attachAsset('level_select_parchment', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	parchment.x = 2048 / 2;
	parchment.y = 2732 / 2;
	parchment.alpha = 0;
	tween(parchment, {
		alpha: 1
	}, {
		duration: 500
	});
	var selectTitle = new Text2("SELECT LEVEL", {
		size: 100,
		fill: 0x332211,
		weight: 700
	});
	selectTitle.anchor.set(0.5, 0.5);
	selectTitle.x = 2048 / 2;
	selectTitle.y = 350;
	levelSelectContainer.addChild(selectTitle);
	var levelKeys = Object.keys(LEVEL_DATA_ALL);
	var startY = 800;
	var buttonSpacing = 250;
	for (var i = 0; i < levelKeys.length; i++) {
		var levelKey = levelKeys[i];
		var levelData = LEVEL_DATA_ALL[levelKey];
		var levelButton = new Container();
		levelButton.x = 2048 / 2;
		levelButton.y = startY + i * buttonSpacing;
		levelSelectContainer.addChild(levelButton);
		var levelButtonBg = levelButton.attachAsset('notification', {
			anchorX: 0.5,
			anchorY: 0.5,
			width: 700,
			height: 180,
			tint: 0x0088CC
		});
		var levelButtonText = new Text2(levelData.levelName, {
			size: 60,
			fill: 0xFFFFFF
		});
		levelButtonText.anchor.set(0.5, 0.5);
		levelButton.addChild(levelButtonText);
		levelButton.interactive = true;
		(function (key) {
			levelButton.down = function () {
				if (titleScreenContainer) {
					titleScreenContainer.destroy();
				}
				levelSelectContainer.destroy();
				startGame(key);
			};
		})(levelKey);
	}
}
function getPeopleRegenTime() {
	var hasInfirmary = castleBuildings.some(function (b) {
		return b.id === 'infirmary';
	});
	return hasInfirmary ? 5 * 60 : 10 * 60;
}
function toggleBuildPanel(panelOrState, stateOrPanel) {
	var panel, forceState;
	if (typeof panelOrState === 'string') {
		forceState = panelOrState;
		panel = stateOrPanel;
	} else {
		panel = panelOrState;
		forceState = stateOrPanel;
	}
	var targetY;
	var shouldBeOpen;
	if (!panel) {
		return;
	}
	if (forceState === 'open') {
		shouldBeOpen = true;
	} else if (forceState === 'close') {
		shouldBeOpen = false;
	} else {
		shouldBeOpen = !isBuildPanelOpen;
	}
	if (shouldBeOpen) {
		targetY = 2732 - 250;
		isBuildPanelOpen = true;
	} else {
		targetY = 2732 + 100;
		isBuildPanelOpen = false;
	}
	tween(panel, {
		y: targetY
	}, {
		duration: 300,
		easing: tween.backOut
	});
}
function toggleMagicPanel(panel, forceState) {
	var targetY;
	var shouldBeOpen;
	if (!panel) {
		return;
	}
	if (forceState === 'open') {
		shouldBeOpen = true;
	} else if (forceState === 'close') {
		shouldBeOpen = false;
	} else {
		shouldBeOpen = !isMagicPanelOpen;
	}
	if (shouldBeOpen) {
		targetY = 2732 - 250;
		isMagicPanelOpen = true;
	} else {
		targetY = 2732 + 100;
		isMagicPanelOpen = false;
	}
	tween(panel, {
		y: targetY
	}, {
		duration: 300,
		easing: tween.backOut
	});
}
function toggleArmyPanel(panel, forceState) {
	var targetY;
	var shouldBeOpen;
	if (!panel) {
		return;
	}
	if (forceState === 'open') {
		shouldBeOpen = true;
	} else if (forceState === 'close') {
		shouldBeOpen = false;
	} else {
		shouldBeOpen = !isArmyPanelOpen;
	}
	if (shouldBeOpen) {
		targetY = 2732 - 250;
		isArmyPanelOpen = true;
	} else {
		targetY = 2732 + 100;
		isArmyPanelOpen = false;
		isDraggingSpell = false;
		activeSpells = [];
		isDraggingSpell = false;
	}
	tween(panel, {
		y: targetY
	}, {
		duration: 300,
		easing: tween.backOut
	});
}
function drawNewBuildingHand() {
	while (castleBuildPanel.children.length > 1) {
		castleBuildPanel.removeChildAt(1);
	}
	buildingHand = [];
	var availableBuildings = buildingDeck.filter(function (buildingType) {
		if (buildingType === 'home') {
			return true;
		}
		var alreadyBuilt = castleBuildings.some(function (b) {
			return b.id === buildingType;
		});
		return !alreadyBuilt;
	});
	var handToDraw = availableBuildings.slice();
	for (var i = 0; i < 3; i++) {
		if (handToDraw.length === 0) {
			break;
		}
		var randomIndex = Math.floor(Math.random() * handToDraw.length);
		var drawnBuilding = handToDraw.splice(randomIndex, 1)[0];
		buildingHand.push(drawnBuilding);
	}
	var buildingIconSpacing = 280;
	var totalBuildingWidth = (buildingHand.length - 1) * buildingIconSpacing;
	var buildingStartX = -totalBuildingWidth / 2;
	for (var i = 0; i < buildingHand.length; i++) {
		var building = new SourceBuilding(buildingHand[i]);
		building.x = buildingStartX + i * buildingIconSpacing;
		building.y = 0;
		castleBuildPanel.addChild(building);
	}
}
function placeBuilding(buildingType, gridX, gridY) {
	var cost = getBuildingCost(buildingType);
	var buildingSize = BUILDING_DATA[buildingType].size;
	if (gold >= cost.gold) {
		// Logika "Puff!" dla NPC
		var buildArea = {
			x: castleGrid.x + gridX * CELL_SIZE,
			y: castleGrid.y + gridY * CELL_SIZE,
			width: buildingSize.w * CELL_SIZE,
			height: buildingSize.h * CELL_SIZE
		};
		for (var i = npcs.length - 1; i >= 0; i--) {
			var npc = npcs[i];
			if (npc.x > buildArea.x && npc.x < buildArea.x + buildArea.width && npc.y > buildArea.y && npc.y < buildArea.y + buildArea.height) {
				// Prosty efekt "Puff!"
				var puff = new Explosion(npc.x, npc.y, 0.5);
				npcLayer.addChild(puff);
				// Znajdź nową pozycję i przenieś
				var validCells = [];
				for (var ci = 0; ci < castleGrid.cells.length; ci++) {
					for (var cj = 0; cj < castleGrid.cells[ci].length; cj++) {
						if (castleGrid.cells[ci][cj].type === 1) {
							validCells.push(castleGrid.cells[ci][cj]);
						}
					}
				}
				if (validCells.length > 0) {
					var targetCell = validCells[Math.floor(Math.random() * validCells.length)];
					npc.x = castleGrid.x + targetCell.x * CELL_SIZE + CELL_SIZE / 2;
					npc.y = castleGrid.y + targetCell.y * CELL_SIZE + CELL_SIZE / 2;
					npc.state = 'IDLE';
					npc.stateTimer = 60;
				} else {
					npc.destroy(); // Na wszelki wypadek, jakby nie było miejsca
				}
			}
		}
		setGold(gold - cost.gold);
		var newBuilding = new Building(buildingType, buildingSize);
		newBuilding.x = castleGrid.x + gridX * CELL_SIZE;
		newBuilding.y = castleGrid.y + gridY * CELL_SIZE;
		castleBuildingsLayer.addChild(newBuilding);
		castleBuildings.push(newBuilding);
		for (var i = 0; i < buildingSize.w; i++) {
			for (var j = 0; j < buildingSize.h; j++) {
				var cell = castleGrid.getCell(gridX + i, gridY + j);
				if (cell) {
					cell.type = 5;
				}
			}
		}
		if (buildingType === 'home') {
			maxPeople += 5;
			updateUI();
			// Dodaj 2 nowych NPC
			var npcGraphics = ['npc_man_1', 'npc_man_2', 'npc_woman_1', 'npc_woman_2'];
			for (var k = 0; k < 2; k++) {
				var spawnCell = castleGrid.getCell(8, 20); // Przykładowy punkt spawnu
				var spawnX = castleGrid.x + 8 * CELL_SIZE + CELL_SIZE / 2;
				var spawnY = castleGrid.y + 20 * CELL_SIZE + CELL_SIZE / 2;
				var randomGraphic = npcGraphics[Math.floor(Math.random() * npcGraphics.length)];
				var newNpc = new NPC(spawnX, spawnY, randomGraphic);
				npcs.push(newNpc);
				npcLayer.addChild(newNpc);
			}
		}
		if (buildingType === 'magic_academy' && !isManaUnlocked) {
			isManaUnlocked = true;
			manaText.visible = true;
			magicButton.visible = true;
			updateUI();
		}
		if (buildingType === 'barracks' && !isArmyUnlocked) {
			isArmyUnlocked = true;
			armyButton.visible = true;
		}
		var handIndex = buildingHand.indexOf(buildingType);
		if (handIndex > -1) {
			buildingHand.splice(handIndex, 1);
		}
		for (var i = castleBuildPanel.children.length - 1; i >= 0; i--) {
			var child = castleBuildPanel.children[i];
			if (child.buildingType === buildingType) {
				child.destroy();
				break;
			}
		}
		if (buildingHand.length === 0) {
			drawNewBuildingHand();
		}
		return true;
	} else {
		var notification = game.addChild(new Notification("Not enough gold!"));
		notification.x = 2048 / 2;
		notification.y = grid.height - 50;
		return false;
	}
}
function placeTower(gridX, gridY, towerType) {
	var towerCost = getTowerCost(towerType);
	if (gold >= towerCost) {
		var tower = new Tower(towerType || 'default');
		tower.placeOnGrid(gridX, gridY);
		towerLayer.addChild(tower);
		towers.push(tower);
		setGold(gold - towerCost);
		tower.startConstructionAnimation(5, function () {});
		if (activeWeatherEvent === 'FOG' && tower.towerType === 'mage') {
			tower.addBuff({
				source: 'FOG_DEBUFF',
				effect: {
					damage: EVENT_DATA.FOG.modifier.mageTowerDebuff
				}
			});
		}
		return true;
	} else {
		var notification = game.addChild(new Notification("Not enough gold!"));
		notification.x = 2048 / 2;
		notification.y = grid.height - 50;
		return false;
	}
}
function initializeGameState(levelData) {
	pathId = 1;
	maxScore = 0;
	enemies = [];
	towers = [];
	bullets = [];
	friendlyUnits = [];
	peopleRegenQueue = [];
	activeSpells = [];
	npcs = [];
	specialZoneIndicators = []; // NOWA LINIA
	selectedTower = null;
	castleBuildings = [];
	gold = levelData.initialGold;
	lives = levelData.initialLives;
	mana = 0;
	isManaUnlocked = false;
	isArmyUnlocked = false;
	enemiesKilled = 0;
	enemiesInCurrentWave = 0;
	currentWave = 1;
	totalWaves = levelData.waves.length;
	waveInProgress = false;
	waveSpawned = false;
	waveTimer = 0;
	nextWaveTime = 1200;
	sourceTowers = [];
	isBuildPanelOpen = false;
	isMagicPanelOpen = false;
	isArmyPanelOpen = false;
	people = 5;
	maxPeople = 5;
	currentActiveView = 'gate';
	lastRecruitActionTick = 0;
}
function setupScene(levelData) {
	gateContainer = new Container();
	game.addChild(gateContainer);
	castleContainer = new Container();
	npcLayer = new Container(); // NOWA LINIA
	castleBuildingsLayer = new Container();
	castleContainer.addChild(castleBuildingsLayer);
	castleContainer.addChild(npcLayer); // NOWA LINIA
	game.addChild(castleContainer);
	castleContainer.visible = false;
	var castleMainBg = LK.getAsset('castle_bg_image', {});
	castleContainer.addChildAt(castleMainBg, 0);
	castleMainBg.x = -100;
	castleMainBg.y = -300;
	gateContainer.addChild(LK.getAsset(levelData.mapAsset, {
		scaleMode: 'nearest'
	}));
	debugLayer = new Container();
	specialTilesLayer = new Container();
	towerLayer = new Container();
	friendlyUnitLayer = new Container();
	buildableTilesLayer = new Container();
	enemyLayerBottom = new Container();
	enemyLayerMiddle = new Container();
	enemyLayerTop = new Container();
	enemyLayer = new Container();
	enemyLayer.addChild(enemyLayerBottom);
	enemyLayer.addChild(enemyLayerMiddle);
	enemyLayer.addChild(enemyLayerTop);
	spellOverlay = new Container();
	spellOverlay.attachAsset('cell', {
		width: 2048,
		height: 2732,
		tint: 0x000000
	});
	spellOverlay.alpha = 0;
	spellOverlay.visible = false;
	spellEffectLayer = new Container();
	gateContainer.addChild(buildableTilesLayer);
	gateContainer.addChild(debugLayer);
	gateContainer.addChild(specialTilesLayer);
	gateContainer.addChild(towerLayer);
	gateContainer.addChild(friendlyUnitLayer);
	gateContainer.addChild(enemyLayer);
	gateContainer.addChild(spellOverlay);
	gateContainer.addChild(spellEffectLayer);
	buildableTilesLayer.visible = false;
}
function setupGrid(levelData) {
	grid = new Grid(24, 29 + 6);
	grid.x = 140;
	grid.y = 200 - CELL_SIZE * 4;
	if (levelData.mapAsset === 'map3') {
		grid.x = 235;
	}
	for (var y = 0; y < levelData.mapLayout.length; y++) {
		for (var x = 0; x < levelData.mapLayout[y].length; x++) {
			var tileChar = levelData.mapLayout[y][x];
			var cell = grid.getCell(x, y + 5);
			if (cell) {
				cell.specialEffect = null;
				if (tileChar === '0') {
					cell.type = 0;
				} else if (tileChar === '1' || tileChar === 'A' || tileChar === 'C') {
					cell.type = 1;
					if (tileChar === 'A' || tileChar === 'C') {
						cell.specialEffect = tileChar === 'A' ? 'amplifier' : 'catalyst';
						var isTopLeft = (x === 0 || levelData.mapLayout[y][x - 1] !== tileChar) && (y === 0 || !levelData.mapLayout[y - 1] || levelData.mapLayout[y - 1][x] !== tileChar);
						if (isTopLeft) {
							var zoneWidth = 1;
							var zoneHeight = 1;
							while (x + zoneWidth < levelData.mapLayout[y].length && levelData.mapLayout[y][x + zoneWidth] === tileChar) {
								zoneWidth++;
							}
							while (y + zoneHeight < levelData.mapLayout.length && levelData.mapLayout[y + zoneHeight][x] === tileChar) {
								zoneHeight++;
							}
							var zoneSize = Math.max(zoneWidth, zoneHeight);
							var assetName = tileChar === 'A' ? 'buff_amplifier_zone' : 'buff_catalyst_zone';
							var zoneIndicator = new Container();
							var indicatorGraphic = zoneIndicator.attachAsset(assetName, {
								anchorX: 0.5,
								anchorY: 0.5,
								width: CELL_SIZE * (zoneSize + 0.5),
								height: CELL_SIZE * (zoneSize + 0.5),
								alpha: 0.7 // Ustawiamy stałą przezroczystość
							});
							zoneIndicator.x = grid.x + x * CELL_SIZE + CELL_SIZE * zoneWidth / 2;
							zoneIndicator.y = grid.y + (y + 5) * CELL_SIZE + CELL_SIZE * zoneHeight / 2;
							specialTilesLayer.addChild(zoneIndicator);
							specialZoneIndicators.push(zoneIndicator);
							// USUNIĘTO CAŁĄ FUNKCJĘ PULSOWANIA
						}
					}
					var tilePlaceholder = buildableTilesLayer.attachAsset('cell', {
						anchorX: 0.5,
						anchorY: 0.5
					});
					tilePlaceholder.alpha = 0.25;
					tilePlaceholder.x = grid.x + x * CELL_SIZE + CELL_SIZE / 2;
					tilePlaceholder.y = grid.y + (y + 5) * CELL_SIZE + CELL_SIZE / 2;
				} else if (tileChar === 'S') {
					cell.type = 3;
				} else if (tileChar === 'E') {
					cell.type = 4;
				} else {
					cell.type = 2;
				}
			}
		}
	}
	var castleGridWidth = 17;
	var castleGridHeight = 22;
	castleGrid = new Grid(castleGridWidth, castleGridHeight);
	castleGrid.x = (2048 - castleGridWidth * CELL_SIZE) / 2 - 30;
	castleGrid.y = (2732 - castleGridHeight * CELL_SIZE) / 2 - 100;
	castleBuildableTilesLayer = new Container();
	castleContainer.addChild(castleBuildableTilesLayer);
	for (var y = 0; y < levelData.castleMapLayout.length; y++) {
		for (var x = 0; x < levelData.castleMapLayout[y].length; x++) {
			var tileChar = levelData.castleMapLayout[y][x];
			var cell = castleGrid.getCell(x, y);
			if (cell) {
				if (tileChar === '1') {
					cell.type = 1;
					var tilePlaceholder = castleBuildableTilesLayer.attachAsset('cell', {
						anchorX: 0.5,
						anchorY: 0.5
					});
					tilePlaceholder.alpha = 0.25;
					tilePlaceholder.x = castleGrid.x + x * CELL_SIZE + CELL_SIZE / 2;
					tilePlaceholder.y = castleGrid.y + y * CELL_SIZE + CELL_SIZE / 2;
				} else {
					cell.type = 2;
				}
			}
		}
	}
}
function setupUIAndPanels() {
	updateUI();
	startGameButton = new Container();
	var startBuildingBg = startGameButton.attachAsset('button_start_wave', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	startGameButton.x = 2048 / 2;
	startGameButton.y = 2732 / 2;
	gateContainer.addChild(startGameButton);
	startGameButton.interactive = true;
	startGameButton.down = function () {
		var weatherSelection = new WeatherSelection(currentLevelNumber, function () {
			// Ta funkcja wykona się, gdy okno z pogodą zniknie
			isBuildPhase = true;
			buildPhaseTimer = 60 * 10; // Nadal dajemy czas na budowę po evencie
			timerText.visible = true;
		});
		game.addChild(weatherSelection);
		weatherSelection.startSelection();
		startGameButton.destroy();
	};
	castleBuildPanel = new Container();
	castleContainer.addChild(castleBuildPanel);
	castleBuildPanel.x = 2048 / 2;
	castleBuildPanel.y = 2732 + 100;
	var castlePanelBackground = castleBuildPanel.attachAsset('panel_popup_background', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 1800,
		height: 400
	});
	mainActionPanel = new Container();
	gateContainer.addChild(mainActionPanel);
	mainActionPanel.x = 2048 / 2;
	mainActionPanel.y = 2732 + 100;
	var panelBackground = mainActionPanel.attachAsset('panel_popup_background', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 1800,
		height: 400
	});
	buildPage = new Container();
	mainActionPanel.addChild(buildPage);
	var towerTypes = ['guard', 'crossbow', 'mage', 'banner'];
	var towerIconSpacing = 280;
	var totalWidth = (towerTypes.length - 1) * towerIconSpacing;
	var towerStartX = -totalWidth / 2;
	for (var i = 0; i < towerTypes.length; i++) {
		var tower = new SourceTower(towerTypes[i]);
		tower.x = towerStartX + i * towerIconSpacing;
		tower.y = 0;
		buildPage.addChild(tower);
		sourceTowers.push(tower);
	}
	magicPage = new Container();
	mainActionPanel.addChild(magicPage);
	var spellTypes = Object.keys(SPELL_DATA);
	var spellIconSpacing = 280;
	var totalSpellsWidth = (spellTypes.length - 1) * spellIconSpacing;
	var spellStartX = -totalSpellsWidth / 2;
	for (var i = 0; i < spellTypes.length; i++) {
		var spell = new SourceSpell(spellTypes[i]);
		spell.x = spellStartX + i * spellIconSpacing;
		spell.y = 0;
		magicPage.addChild(spell);
	}
	armyPage = new Container();
	mainActionPanel.addChild(armyPage);
	var unitTypes = Object.keys(UNIT_DATA);
	var unitIconSpacing = 280;
	var totalUnitsWidth = (unitTypes.length - 1) * unitIconSpacing;
	var unitStartX = -totalUnitsWidth / 2;
	for (var i = 0; i < unitTypes.length; i++) {
		var unit = new SourceUnit(unitTypes[i]);
		unit.x = unitStartX + i * unitIconSpacing;
		unit.y = 0;
		armyPage.addChild(unit);
	}
	showPageInMainPanel('build');
	buildButton = new Container();
	game.addChild(buildButton);
	buildButton.interactive = true;
	buildButton.x = 2048 / 2 - 400;
	buildButton.y = 2732 - 100;
	var buildButtonBg = buildButton.attachAsset('button_build', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	buildButton.down = function () {
		if (currentActiveView === 'gate') {
			toggleMainPanel('build');
		} else {
			toggleBuildPanel(castleBuildPanel);
		}
	};
	magicButton = new Container();
	game.addChild(magicButton);
	magicButton.interactive = true;
	magicButton.x = 2048 / 2;
	magicButton.y = 2732 - 100;
	magicButton.visible = false;
	var magicButtonBg = magicButton.attachAsset('button_magic', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	magicButton.down = function () {
		if (currentActiveView === 'gate') {
			toggleMainPanel('magic');
		}
	};
	armyButton = new Container();
	game.addChild(armyButton);
	armyButton.interactive = true;
	armyButton.x = 2048 / 2 + 400;
	armyButton.y = 2732 - 100;
	armyButton.visible = false;
	var armyButtonBg = armyButton.attachAsset('button_army', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	armyButton.down = function () {
		if (currentActiveView === 'gate') {
			toggleMainPanel('army');
		}
	};
	viewToggleButton = new Container();
	game.addChild(viewToggleButton);
	viewToggleButton.interactive = true;
	viewToggleButton.x = 250;
	viewToggleButton.y = 2732 - 100;
	var viewToggleButtonBg = viewToggleButton.attachAsset('button_castle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	viewToggleButton.down = function () {
		if (currentActiveView === 'gate') {
			currentActiveView = 'castle';
			rerollButton.visible = true;
			gateContainer.visible = false;
			castleContainer.visible = true;
		} else {
			currentActiveView = 'gate';
			rerollButton.visible = false;
			gateContainer.visible = true;
			castleContainer.visible = false;
		}
	};
	rerollButton = new Container();
	game.addChild(rerollButton);
	rerollButton.interactive = true;
	rerollButton.x = 2048 - 250;
	rerollButton.y = 2732 - 100;
	rerollButton.visible = false;
	var rerollButtonBg = rerollButton.attachAsset('button_reroll', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	rerollButton.down = function () {
		if (currentActiveView === 'castle') {
			drawNewBuildingHand();
		}
	};
	placementPreview = new PlacementPreview();
	game.addChild(placementPreview);
	placementPreview.visible = false;
	spellPreview = new SpellPreview();
	game.addChild(spellPreview);
	spellPreview.visible = false;
	buildingDeck = ['home', 'workshop', 'barracks', 'magic_academy', 'tavern', 'smithy', 'infirmary'];
	buildingHand = [];
	drawNewBuildingHand();
}
function handleUIClick(x, y) {
	var buttons = [{
		btn: buildButton,
		visible: true
	}, {
		btn: magicButton,
		visible: magicButton.visible
	}, {
		btn: armyButton,
		visible: armyButton.visible
	}, {
		btn: viewToggleButton,
		visible: true
	}, {
		btn: rerollButton,
		visible: rerollButton.visible
	}];
	for (var i = 0; i < buttons.length; i++) {
		var b = buttons[i];
		if (!b.visible) {
			continue;
		}
		// Nowa, niezawodna metoda sprawdzania granic
		var width = b.btn.hitAreaWidth;
		var height = b.btn.hitAreaHeight;
		var left = b.btn.x - width / 2;
		var right = b.btn.x + width / 2;
		var top = b.btn.y - height / 2;
		var bottom = b.btn.y + height / 2;
		if (x >= left && x <= right && y >= top && y <= bottom) {
			b.btn.down();
			return true;
		}
	}
	return false;
}
function startGame(levelNumber) {
	currentLevelNumber = levelNumber;
	console.log("Rozpoczynam ładowanie poziomu: " + levelNumber);
	if (titleScreenContainer) {
		titleScreenContainer.destroy();
		titleScreenContainer = null;
	}
	if (levelSelectContainer) {
		levelSelectContainer.destroy();
		levelSelectContainer = null;
	}
	currentScreenState = 'gameplay';
	if (LK.gui.top) {
		LK.gui.top.visible = true;
	}
	levelData = LEVEL_DATA_ALL[levelNumber];
	if (!levelData) {
		console.error("Nie znaleziono danych dla poziomu: " + levelNumber);
		return;
	}
	initializeGameState(levelData);
	setupScene(levelData);
	setupGrid(levelData);
	if (levelData.spawnPoints) {
		levelData.spawnPoints.forEach(function (spawner) {
			spawner.lanes.forEach(function (lane) {
				var pathId = spawner.id + "_" + lane.id;
				var goalCell = grid.getCell(spawner.goalX, spawner.goalY); // USUNIĘTO LANE.OFFSET
				if (goalCell && goalCell.type === 0) {
					grid.calculatePath(pathId, goalCell);
				}
			});
		});
	}
	setupStatsPanel();
	setupUIAndPanels();
}
function handlePanelClick(x, y) {
	var activePanel = null;
	if (currentActiveView === 'gate' && isMainPanelOpen) {
		activePanel = mainActionPanel;
	} else if (currentActiveView === 'castle' && isBuildPanelOpen) {
		activePanel = castleBuildPanel;
	}
	if (!activePanel) {
		return false;
	}
	var itemsContainer = null;
	if (activePanel === mainActionPanel) {
		if (buildPage.visible) {
			itemsContainer = buildPage;
		} else if (magicPage.visible) {
			itemsContainer = magicPage;
		} else if (armyPage.visible) {
			itemsContainer = armyPage;
		}
	} else {
		itemsContainer = castleBuildPanel;
	}
	if (!itemsContainer) {
		return false;
	}
	var localClickPos = {
		x: x - activePanel.x,
		y: y - activePanel.y
	};
	for (var i = 0; i < itemsContainer.children.length; i++) {
		var item = itemsContainer.children[i];
		var itemLeft = item.x - item.width / 2;
		var itemRight = item.x + item.width / 2;
		var itemTop = item.y - item.height / 2;
		var itemBottom = item.y + item.height / 2;
		if (localClickPos.x >= itemLeft && localClickPos.x <= itemRight && localClickPos.y >= itemTop && localClickPos.y <= itemBottom) {
			console.log("DEBUG: Kliknięto na item w panelu!", item);
			if (item instanceof SourceUnit) {
				item.down();
				return true;
			}
			if (item instanceof SourceTower || item instanceof SourceBuilding) {
				isDragging = true;
				placementPreview.visible = true;
				var activeGrid = currentActiveView === 'gate' ? grid : castleGrid;
				var itemSubType = item.towerType || item.buildingType;
				placementPreview.itemType = item.towerType ? 'tower' : 'building';
				placementPreview.subType = itemSubType;
				if (placementPreview.itemType === 'tower') {
					placementPreview.itemSize = {
						w: 2,
						h: 2
					};
				} else {
					placementPreview.itemSize = BUILDING_DATA[itemSubType].size;
				}
				placementPreview.updateAppearance();
				if (currentActiveView === 'gate') {
					buildableTilesLayer.visible = true;
				} else {
					castleBuildableTilesLayer.visible = true;
				}
				placementPreview.snapToGrid(x, y, activeGrid);
				return true;
			}
			if (item instanceof SourceSpell) {
				if (activeWeatherEvent === 'FOG') {
					var notification = game.addChild(new Notification("Magic is disabled during a fog!"));
					notification.x = 2048 / 2;
					notification.y = grid.height - 50;
					return true;
				}
				var spellData = getModifiedSpellData(item.spellId);
				if (mana >= spellData.cost) {
					isDraggingSpell = true;
					spellPreview.spellId = item.spellId;
					spellPreview.updateAppearance(spellData, true);
					spellPreview.updatePosition(x, y);
					showSpellOverlay();
				} else {
					var notification = game.addChild(new Notification("Not enough mana!"));
					notification.x = 2048 / 2;
					notification.y = grid.height - 50;
				}
				return true;
			}
		}
	}
	return false;
}
function handleClickOnMap(x, y) {
	if (rerollButton.visible) {
		var width = 300;
		var height = 120;
		var left = rerollButton.x - width / 2;
		var right = rerollButton.x + width / 2;
		var top = rerollButton.y - height / 2;
		var bottom = rerollButton.y + height / 2;
		if (x >= left && x <= right && y >= top && y <= bottom) {
			return;
		}
	}
	if (isMenuTransitioning) {
		return;
	}
	var upgradeMenuVisible = game.children.some(function (child) {
		return child instanceof UpgradeMenu || child instanceof BuildingInfoMenu;
	});
	if (upgradeMenuVisible) {
		return;
	}
	var aPanelIsOpen = isBuildPanelOpen || isMagicPanelOpen || isArmyPanelOpen;
	if (aPanelIsOpen) {
		var activePanel;
		if (isBuildPanelOpen) {
			activePanel = currentActiveView === 'gate' ? buildPanelContainer : castleBuildPanel;
		} else if (isMagicPanelOpen) {
			activePanel = magicPanelContainer;
		} else if (isArmyPanelOpen) {
			activePanel = armyPanelContainer;
		}
		if (activePanel && !activePanel.getBounds().contains(x, y)) {
			if (isBuildPanelOpen) {
				toggleBuildPanel(activePanel, 'close');
			}
			if (isMagicPanelOpen) {
				toggleMagicPanel(magicPanelContainer, 'close');
			}
			if (isArmyPanelOpen) {
				toggleArmyPanel(armyPanelContainer, 'close');
			}
			return;
		}
	}
	var clickedOnSomething = false;
	if (currentActiveView === 'gate') {
		for (var i = 0; i < towers.length; i++) {
			var tower = towers[i];
			var towerBounds = tower.getBounds();
			if (towerBounds.contains(x - tower.x + tower.width / 2, y - tower.y + tower.height / 2)) {
				tower.down(x, y);
				clickedOnSomething = true;
				break;
			}
		}
	} else {
		for (var i = 0; i < castleBuildings.length; i++) {
			var building = castleBuildings[i];
			var buildingWidth = building.size.w * CELL_SIZE;
			var buildingHeight = building.size.h * CELL_SIZE;
			if (x > building.x && x < building.x + buildingWidth && y > building.y && y < building.y + buildingHeight) {
				if (typeof building.down === 'function') {
					building.down();
				}
				clickedOnSomething = true;
				break;
			}
		}
	}
	if (!clickedOnSomething) {
		closeActiveUpgradeMenu();
		game.children.forEach(function (child) {
			if (child instanceof BuildingInfoMenu) {
				hideBuildingInfoMenu(child);
			}
		});
	}
}
function handleItemDrop(x, y) {
	if (isDragging) {
		isDragging = false;
		placementPreview.visible = false;
		if (currentActiveView === 'gate') {
			buildableTilesLayer.visible = false;
			if (placementPreview.canPlace) {
				placeTower(placementPreview.gridX, placementPreview.gridY, placementPreview.subType);
			}
		} else {
			castleBuildableTilesLayer.visible = false;
			if (placementPreview.canPlace) {
				placeBuilding(placementPreview.subType, placementPreview.gridX, placementPreview.gridY);
			}
		}
		if (isBuildPanelOpen) {
			var targetPanel = currentActiveView === 'gate' ? buildPanelContainer : castleBuildPanel;
			toggleBuildPanel(targetPanel, 'close');
		}
		return true;
	}
	return false;
}
function handleSpellCast(x, y) {
	if (isDraggingSpell) {
		isDraggingSpell = false;
		spellPreview.visible = false;
		spellPreview.children[0].tint = 0x00BFFF;
		LK.setTimeout(function () {
			hideSpellOverlay();
		}, 1500);
		var spellData = getModifiedSpellData(spellPreview.spellId); // ZMIANA JEST TUTAJ
		if (mana >= spellData.cost) {
			var spellEffect;
			if (spellPreview.spellId === 'summon_golem') {
				var gridX = Math.floor((x - grid.x) / CELL_SIZE);
				var gridY = Math.floor((y - grid.y) / CELL_SIZE);
				var cell = grid.getCell(gridX, gridY);
				if (cell && cell.type === 0) {
					setMana(mana - spellData.cost);
					var golemX = grid.x + gridX * CELL_SIZE + CELL_SIZE / 2;
					var golemY = grid.y + gridY * CELL_SIZE + CELL_SIZE / 2;
					var golemUnit = new Golem(golemX, golemY);
					golemUnit.visible = false;
					friendlyUnitLayer.addChild(golemUnit);
					friendlyUnits.push(golemUnit);
					var summonEffect = new GolemSummonEffect(golemX, golemY, function () {
						golemUnit.visible = true;
					});
					spellEffectLayer.addChild(summonEffect);
				} else {
					var notification = game.addChild(new Notification("Cannot summon here!"));
					notification.x = 2048 / 2;
					notification.y = grid.height - 50;
				}
			} else {
				setMana(mana - spellData.cost);
				switch (spellPreview.spellId) {
					case 'fire_wall':
						spellEffect = new FireWall(x, y, spellData);
						var visualSize = spellData.radius * 1.5;
						var visualCenter = new FireWallVisual(x, y - 90, visualSize);
						var visualBottom = new FireWallVisual(x, y + spellData.radius * 0.8 - 90, visualSize);
						spellEffectLayer.addChild(visualCenter);
						spellEffectLayer.addChild(visualBottom);
						break;
					case 'lightning_stun':
						spellEffect = new ThunderstormEffect(x, y, spellData);
						break;
					case 'healing_field':
						spellEffect = new HealingFieldEffect(x, y, spellData);
						break;
					case 'curse':
						spellEffect = new CurseEffect(x, y, spellData);
						break;
				}
				if (spellEffect) {
					if (spellPreview.spellId === 'lightning_stun') {
						game.addChild(spellEffect);
					} else {
						spellEffectLayer.addChild(spellEffect);
					}
					if (spellPreview.spellId === 'fire_wall') {
						activeSpells.push(spellEffect);
					}
				}
			}
		}
		if (isMagicPanelOpen) {
			toggleMagicPanel(magicPanelContainer, 'close');
		}
		return true;
	}
	return false;
}
game.down = function (x, y, obj) {
	if (currentScreenState !== 'gameplay') {
		if (obj && obj.down) {
			obj.down();
		}
		return;
	}
	if (obj && typeof obj.down === 'function') {
		obj.down();
		return;
	}
	if (handlePanelClick(x, y)) {
		return;
	}
	handleClickOnMap(x, y);
};
game.move = function (x, y, obj) {
	if (currentScreenState !== 'gameplay') {
		return;
	}
	if (isDragging) {
		var activeGrid = currentActiveView === 'gate' ? grid : castleGrid;
		var yOffset = currentActiveView === 'gate' ? CELL_SIZE * 1.5 : 0;
		placementPreview.snapToGrid(x, y - yOffset, activeGrid);
	} else if (isDraggingSpell) {
		spellPreview.updatePosition(x, y);
		if (spellPreview.spellId === 'summon_golem') {
			var gridX = Math.floor((x - grid.x) / CELL_SIZE);
			var gridY = Math.floor((y - grid.y) / CELL_SIZE);
			var cell = grid.getCell(gridX, gridY);
			var canPlace = cell && cell.type === 0;
			var activeGraphic = spellPreview.getActiveGraphic();
			if (activeGraphic) {
				activeGraphic.tint = canPlace ? 0x00BFFF : 0xFF0000;
			}
		}
	}
};
game.up = function (x, y, obj) {
	if (currentScreenState !== 'gameplay') {
		return;
	}
	if (panelActionTaken) {
		panelActionTaken = false;
		return;
	}
	if (handleItemDrop(x, y)) {
		return;
	}
	if (handleSpellCast(x, y)) {
		return;
	}
	if (isDraggingSpell) {
		isDraggingSpell = false;
		spellPreview.visible = false;
		hideSpellOverlay();
	}
	var clickedOnMenu = false;
	var upgradeMenus = game.children.filter(function (child) {
		return child instanceof UpgradeMenu;
	});
	if (upgradeMenus.length > 0) {
		for (var i = 0; i < upgradeMenus.length; i++) {
			var menu = upgradeMenus[i];
			var menuBounds = menu.getBounds();
			if (menuBounds.contains(x, y)) {
				clickedOnMenu = true;
				break;
			}
		}
	}
	if (!clickedOnMenu && selectedTower) {
		closeActiveUpgradeMenu();
	}
};
function updateGameLogic() {
	if (isBuildPhase) {
		if (buildPhaseTimer > 0) {
			buildPhaseTimer--;
			timerText.setText("Build Time: " + Math.ceil(buildPhaseTimer / 60));
		} else {
			isBuildPhase = false;
			timerText.visible = false;
			waveInProgress = true;
			waveSpawned = false;
		}
	} else if (waveInProgress) {
		if (!waveSpawned) {
			spawnQueue = [];
			waveClock = 0;
			enemiesKilled = 0;
			var waveData = levelData.waves[currentWave - 1];
			if (waveData && waveData.phases) {
				var allEnemiesInWave = [];
				var currentTimeOffset = 0;
				// NOWA LOGIKA DLA MAPY 3, FALE 1-2
				if (levelData.levelName === 'Level 3: Twin Pass' && currentWave < 3) {
					waveData.phases.forEach(function (phase) {
						// W logice sekwencyjnej ignorujemy delay fazy, bo czas jest liczony ciągle
						phase.units.forEach(function (unitGroup) {
							var spawner = levelData.spawnPoints.find(function (sp) {
								return sp.id === unitGroup.spawner;
							});
							if (!spawner) {
								return;
							}
							// Używamy tylko jednego pasa (pierwszego z brzegu) dla pojedynczego szeregu
							var laneToUse = spawner.lanes[0];
							for (var i = 0; i < unitGroup.count; i++) {
								var spawnTime = currentTimeOffset + i * (phase.interval || 120);
								spawnQueue.push({
									unitData: {
										spawner: unitGroup.spawner,
										type: unitGroup.type,
										laneId: laneToUse.id
									},
									spawnTime: spawnTime
								});
								allEnemiesInWave.push(unitGroup.type);
							}
							// Przesuwamy czas startu następnej grupy o czas trwania obecnej
							currentTimeOffset += unitGroup.count * (phase.interval || 120) + 60; // +1s przerwy
						});
					});
				} else {
					// STARA/STANDARDOWA LOGIKA DLA INNYCH MAP I FALI 3+
					waveData.phases.forEach(function (phase) {
						currentTimeOffset += phase.delay || 0;
						var timeInThisPhase = 0;
						phase.units.forEach(function (unitGroup) {
							var spawner = levelData.spawnPoints.find(function (sp) {
								return sp.id === unitGroup.spawner;
							});
							if (!spawner) {
								return;
							}
							var lanesToUse = spawner.lanes;
							// Dla fali 3+ na mapie z wieloma pasami, spawnuj w parach/grupach
							if (currentWave >= 3 && lanesToUse.length > 1) {
								for (var i = 0; i < unitGroup.count; i += lanesToUse.length) {
									var pairIndex = i / lanesToUse.length;
									var spawnTimeForPair = currentTimeOffset + pairIndex * (phase.interval || 120);
									for (var j = 0; j < lanesToUse.length; j++) {
										if (i + j < unitGroup.count) {
											spawnQueue.push({
												unitData: {
													spawner: unitGroup.spawner,
													type: unitGroup.type,
													laneId: lanesToUse[j].id
												},
												spawnTime: spawnTimeForPair
											});
											allEnemiesInWave.push(unitGroup.type);
										}
									}
								}
								timeInThisPhase += Math.ceil(unitGroup.count / lanesToUse.length) * (phase.interval || 120);
							} else {
								// Standardowe spawnowanie w pojedynczym szeregu (ale na wielu pasach, jeśli są)
								for (var i = 0; i < unitGroup.count; i++) {
									var spawnTime = currentTimeOffset + i * (phase.interval || 60);
									var lane = lanesToUse[i % lanesToUse.length];
									spawnQueue.push({
										unitData: {
											spawner: unitGroup.spawner,
											type: unitGroup.type,
											laneId: lane.id
										},
										spawnTime: spawnTime
									});
									allEnemiesInWave.push(unitGroup.type);
								}
								timeInThisPhase += unitGroup.count * (phase.interval || 60);
							}
						});
						currentTimeOffset += timeInThisPhase;
					});
				}
				enemiesInCurrentWave = allEnemiesInWave.length;
				updateUI();
			}
			waveSpawned = true;
		}
		waveClock++;
		if (spawnQueue.length > 0 && waveClock >= spawnQueue[0].spawnTime) {
			var spawnData = spawnQueue.shift();
			var spawner = levelData.spawnPoints.find(function (sp) {
				return sp.id === spawnData.unitData.spawner;
			});
			var lane = spawner.lanes.find(function (l) {
				return l.id === spawnData.unitData.laneId;
			});
			if (spawner && lane) {
				var enemy = new Enemy(spawnData.unitData.type, spawner.id, lane.id);
				enemy.laneOffset = lane.offset;
				enemy.cellX = spawner.startX;
				enemy.cellY = spawner.startY;
				enemy.x = grid.x + (enemy.cellX + enemy.laneOffset) * CELL_SIZE + CELL_SIZE / 2;
				enemy.y = grid.y + enemy.cellY * CELL_SIZE + CELL_SIZE / 2;
				enemy.waveNumber = currentWave;
				var healthMultiplier = Math.pow(1.15, currentWave);
				enemy.maxHealth = Math.round(enemy.maxHealth * healthMultiplier);
				if (activeWeatherEvent === 'NIGHT') {
					var nightMultiplier = EVENT_DATA.NIGHT.modifier.enemyStatMultiplier;
					enemy.maxHealth = Math.round(enemy.maxHealth * nightMultiplier);
					enemy.damage = Math.round(enemy.damage * nightMultiplier);
				}
				enemy.health = enemy.maxHealth;
				enemy.healthBar.width = enemy.health / enemy.maxHealth * 70;
				enemyLayerBottom.addChild(enemy);
				enemies.push(enemy);
			}
		}
		if (spawnQueue.length === 0 && enemies.length === 0) {
			waveInProgress = false;
			clearActiveWeatherModifiers();
			activeWeatherEvent = null; // Resetujemy pogodę
			if (numberOfTaverns > 0) {
				// ... logika tawern (zostaje bez zmian)
			}
			currentWave++;
			if (currentWave > totalWaves) {
				LK.showYouWin();
			} else {
				// Wywołujemy nasze nowe okno wyboru pogody!
				var weatherSelection = new WeatherSelection(currentLevelNumber, function () {
					// Ta funkcja wykona się, gdy okno z pogodą zniknie
					isBuildPhase = true;
					buildPhaseTimer = 60 * 10;
				});
				game.addChild(weatherSelection);
				weatherSelection.startSelection();
			}
		}
	}
}
function updateGameObjects() {
	if (friendlyUnits) {
		for (var i = 0; i < friendlyUnits.length; i++) {
			friendlyUnits[i].update();
		}
	}
	if (activeSpells) {
		for (var i = activeSpells.length - 1; i >= 0; i--) {
			if (activeSpells[i]) {
				activeSpells[i].update();
			}
		}
	}
	if (peopleRegenQueue) {
		for (var i = peopleRegenQueue.length - 1; i >= 0; i--) {
			var regenTime = getPeopleRegenTime();
			if (LK.ticks - peopleRegenQueue[i] >= regenTime) {
				if (people < maxPeople) {
					people++;
					updateUI();
				}
				peopleRegenQueue.splice(i, 1);
			}
		}
	}
	for (var i = 0; i < towers.length; i++) {
		towers[i].update();
	}
	for (var i = bullets.length - 1; i >= 0; i--) {
		var bullet = bullets[i];
		if (!bullet.parent) {
			bullets.splice(i, 1);
		} else {
			bullet.update();
		}
	}
	// NOWA SEKSCJA - Aktualizacja NPC
	if (currentActiveView === 'castle' && npcs) {
		for (var i = npcs.length - 1; i >= 0; i--) {
			var npc = npcs[i];
			if (!npc.parent) {
				npcs.splice(i, 1);
			} else {
				npc.update();
			}
		}
	}
	for (var a = enemies.length - 1; a >= 0; a--) {
		var enemy = enemies[a];
		if (enemy.health <= 0) {
			enemiesKilled++;
			updateUI();
			var goldEarned = enemy.goldValue || 0;
			setGold(gold + goldEarned);
			if (isManaUnlocked) {
				var manaEarned = 0;
				switch (enemy.manaCategory) {
					case 'weak':
						manaEarned = 1;
						break;
					case 'strong':
						manaEarned = 2;
						break;
					case 'special':
						manaEarned = 5;
						break;
					case 'boss':
						manaEarned = 25;
						break;
				}
				setMana(mana + manaEarned);
			}
			gateContainer.addChild(new GoldIndicator(goldEarned, enemy.x, enemy.y));
			if (enemy.parent) {
				enemy.parent.removeChild(enemy);
			}
			if (enemy.shadow && enemy.shadow.parent) {
				enemy.shadow.parent.removeChild(enemy.shadow);
			}
			enemies.splice(a, 1);
			continue;
		}
		if (enemy.update()) {
			if (enemy.parent) {
				enemy.parent.removeChild(enemy);
			}
			if (enemy.shadow && enemy.shadow.parent) {
				enemy.shadow.parent.removeChild(enemy.shadow);
			}
			enemies.splice(a, 1);
			lives = Math.max(0, lives - 1);
			updateUI();
			if (lives <= 0) {
				LK.showGameOver();
			}
		}
	}
	towerLayer.children.sort(function (a, b) {
		return a.y - b.y;
	});
	friendlyUnitLayer.children.sort(function (a, b) {
		return a.y - b.y;
	});
	enemyLayerBottom.children.sort(function (a, b) {
		return a.y - b.y;
	});
}
function updatePreviews() {
	if (placementPreview.visible) {
		var activeGrid = currentActiveView === 'gate' ? grid : castleGrid;
		placementPreview.updatePlacementStatus(activeGrid);
	}
}
game.update = function () {
	if (currentScreenState !== 'gameplay') {
		return;
	}
	updateGameLogic();
	updateGameObjects();
	updatePreviews();
	if (specialZoneIndicators) {
		for (var i = 0; i < specialZoneIndicators.length; i++) {
			specialZoneIndicators[i].rotation += 0.001;
		}
	}
};
showTitleScreen();

===================================================================
--- original.js
+++ change.js
@@ -1543,16 +1543,15 @@
 	self.stateTimer = Math.random() * 90 + 30;
 	self.path = [];
 	self.currentTargetPos = null;
 	self.interactionPartner = null;
-	self.clickCount = 0; // Każdy NPC ma licznik kliknięć
+	self.clickCount = 0;
 	var npcGraphics = self.attachAsset(graphicAsset, {
 		anchorX: 0.5,
 		anchorY: 0.9
 	});
 	npcGraphics.scale.set(0.6);
 	self.down = function () {
-		// Logika działa teraz dla każdego NPC, bez warunku isSpecial
 		self.clickCount++;
 		var message = "";
 		if (self.clickCount === 1) {
 			message = "Don't click me!";
@@ -1577,27 +1576,34 @@
 		if (!startCell || !targetCell || startCell === targetCell) {
 			return [];
 		}
 		var queue = [[startCell]];
-		var visited = new Set([startCell]);
+		var visited = {}; // ZMIANA: Zamiast new Set()
+		var startKey = startCell.x + ',' + startCell.y;
+		visited[startKey] = true;
 		while (queue.length > 0) {
 			var path = queue.shift();
 			var lastCell = path[path.length - 1];
 			if (lastCell === targetCell) {
 				return path;
 			}
 			var neighbors = [lastCell.up, lastCell.down, lastCell.left, lastCell.right].filter(function (n) {
-				return n && n.type === 1 && !visited.has(n);
+				if (!n || n.type !== 1) {
+					return false;
+				}
+				var key = n.x + ',' + n.y;
+				return !visited[key]; // ZMIANA: Sprawdzanie w obiekcie
 			});
 			for (var i = 0; i < neighbors.length; i++) {
 				var neighbor = neighbors[i];
-				visited.add(neighbor);
+				var key = neighbor.x + ',' + neighbor.y;
+				visited[key] = true; // ZMIANA: Dodawanie do obiektu
 				var newPath = path.slice();
 				newPath.push(neighbor);
 				queue.push(newPath);
 			}
 		}
-		return []; // No path found
+		return [];
 	};
 	self.findWanderTarget = function () {
 		var validCells = [];
 		for (var i = 0; i < castleGrid.cells.length; i++) {
@@ -1785,40 +1791,67 @@
 		alpha: 0.3
 	});
 	var previewHolder = new Container();
 	self.addChild(previewHolder);
-	self.updateAppearance = function () {
-		while (previewHolder.children.length) {
-			previewHolder.removeChildAt(0);
-		}
-		var previewGraphics;
-		// Używamy niezawodnego kształtu 'cell' jako bazy dla podglądu
-		previewGraphics = previewHolder.attachAsset('cell', {
-			anchorX: 0.5,
-			anchorY: 0.5
-		});
-		// Ustawiamy prawidłowy rozmiar i przezroczystość
+	var previewGraphics = previewHolder.attachAsset('cell', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	// NOWA LOGIKA: Cień + Tekst
+	var textStyle = {
+		size: 60,
+		weight: 900,
+		align: 'center'
+	};
+	var bonusTextShadow = new Text2("", Object.assign({}, textStyle, {
+		fill: 0x000000
+	}));
+	bonusTextShadow.anchor.set(0.5, 0.5);
+	bonusTextShadow.x = 3;
+	bonusTextShadow.y = 3;
+	previewHolder.addChild(bonusTextShadow);
+	var bonusText = new Text2("", Object.assign({}, textStyle, {
+		fill: 0xFFFFFF
+	}));
+	bonusText.anchor.set(0.5, 0.5);
+	previewHolder.addChild(bonusText);
+	self.updateAppearance = function (specialEffect) {
 		previewGraphics.width = CELL_SIZE * self.itemSize.w;
 		previewGraphics.height = CELL_SIZE * self.itemSize.h;
-		previewGraphics.alpha = 0.5;
-		// Domyślny, niebieski kolor dla prawidłowego miejsca
+		previewGraphics.alpha = 0.6; // Lepsza czytelność na lekko ciemniejszym tle
+		bonusText.setText("");
+		bonusTextShadow.setText("");
 		previewGraphics.tint = 0x00BFFF;
+		if (specialEffect && self.canPlace && self.hasEnoughGold) {
+			var textToShow = "";
+			if (specialEffect === 'amplifier') {
+				previewGraphics.tint = 0xFFD700;
+				textToShow = "+15% DMG";
+			} else if (specialEffect === 'catalyst') {
+				previewGraphics.tint = 0x9370DB;
+				textToShow = "+30% ATS";
+			}
+			bonusText.setText(textToShow);
+			bonusTextShadow.setText(textToShow);
+		}
 		rangeIndicator.visible = false;
 		if (self.itemType === 'tower') {
 			var stats = TOWER_DATA[self.subType] ? TOWER_DATA[self.subType][1] : null;
 			if (stats && stats.range) {
 				rangeIndicator.width = rangeIndicator.height = stats.range * 2;
 				rangeIndicator.visible = true;
 			}
 		}
-		// Jeśli miejsce jest nieprawidłowe, zmieniamy kolor na czerwony
 		if (!self.canPlace || !self.hasEnoughGold) {
 			previewGraphics.tint = 0xFF0000;
+			bonusText.setText("");
+			bonusTextShadow.setText("");
 		}
 	};
 	self.updatePlacementStatus = function (targetGrid) {
 		var validGridPlacement = true;
 		var currentGrid = targetGrid || grid;
+		var currentSpecialEffect = null;
 		if (self.gridY <= 4 && self.itemType === 'tower') {
 			validGridPlacement = false;
 		}
 		if (self.gridY + self.itemSize.h > currentGrid.cells[0].length && self.itemType === 'building') {
@@ -1829,12 +1862,15 @@
 				for (var j = 0; j < self.itemSize.h; j++) {
 					var cell = currentGrid.getCell(self.gridX + i, self.gridY + j);
 					if (!cell || cell.type !== 1) {
 						validGridPlacement = false;
+					}
+					if (cell && cell.specialEffect) {
+						currentSpecialEffect = cell.specialEffect;
 						break;
 					}
 				}
-				if (!validGridPlacement) {
+				if (currentSpecialEffect) {
 					break;
 				}
 			}
 		}
@@ -1846,9 +1882,9 @@
 			cost = buildingCost.gold;
 		}
 		self.hasEnoughGold = gold >= cost;
 		self.canPlace = validGridPlacement;
-		self.updateAppearance();
+		self.updateAppearance(currentSpecialEffect);
 	};
 	self.snapToGrid = function (x, y, targetGrid) {
 		var currentGrid = targetGrid || grid;
 		var gridPosX = x - currentGrid.x;
@@ -2289,17 +2325,18 @@
 	self.levelPath = '';
 	self.maxLevel = 3;
 	self.gridX = 0;
 	self.gridY = 0;
-	self.targetEnemies = []; // ZMIANA: z targetEnemy na tablicę targetEnemies
+	self.targetEnemies = [];
 	self.lastFired = 0;
 	self.totalValue = 0;
 	self.isConstructing = false;
 	self.constructionContainer = null;
 	self.timerText = null;
 	self.auraEffectContainer = null;
 	self.baseStats = {};
 	self.buffs = [];
+	self.tileBuff = null; // NOWA WŁAŚCIWOŚĆ
 	self.towersInAura = [];
 	if (self.towerType === 'banner') {
 		self.auraCheckTimer = 0;
 		self.particleSpawnTimer = 0;
@@ -2318,8 +2355,18 @@
 	}
 	self.recalculateStats = function () {
 		self.damage = self.baseStats.damage;
 		self.fireRate = self.baseStats.fireRate;
+		// Aplikuj buff z pola
+		if (self.tileBuff) {
+			if (self.tileBuff.damage) {
+				self.damage *= self.tileBuff.damage;
+			}
+			if (self.tileBuff.attackSpeed) {
+				self.fireRate /= self.tileBuff.attackSpeed;
+			}
+		}
+		// Aplikuj buffy z innych źródeł (np. Banner)
 		self.buffs.forEach(function (buff) {
 			if (buff.effect.damage) {
 				self.damage *= buff.effect.damage;
 			}
@@ -2376,9 +2423,9 @@
 			self.level++;
 			self.levelPath = path;
 			self.totalValue += upgradeData.cost;
 			var stats = TOWER_DATA[self.towerType][self.level + self.levelPath];
-			applyStats(stats);
+			applyStats(stats); // Stosuje bazowe staty i przelicza z buffami
 			var oldGraphics = self.children[0];
 			if (oldGraphics.isTowerBase) {
 				oldGraphics.destroy();
 			}
@@ -2413,28 +2460,48 @@
 			if (towerGraphic) {
 				towerGraphic.scale.x = -1;
 			}
 		}
+		// Sprawdź bonus z pola i go przypisz
 		for (var i = 0; i < 2; i++) {
 			for (var j = 0; j < 2; j++) {
 				var cell = grid.getCell(gridX + i, gridY + j);
-				if (cell) {
-					cell.type = 5;
+				if (cell && cell.specialEffect) {
+					if (cell.specialEffect === 'amplifier') {
+						self.tileBuff = {
+							damage: 1.15
+						};
+					} else if (cell.specialEffect === 'catalyst') {
+						self.tileBuff = {
+							attackSpeed: 1.30
+						};
+					}
+					self.recalculateStats();
+					break; // Znaleziono bonus, przerywamy pętlę
 				}
 			}
+			if (self.tileBuff) {
+				break;
+			}
 		}
+		for (var i = 0; i < 2; i++) {
+			for (var j = 0; j < 2; j++) {
+				var cellToOccupy = grid.getCell(gridX + i, gridY + j);
+				if (cellToOccupy) {
+					cellToOccupy.type = 5;
+				}
+			}
+		}
 		if (self.aura) {
 			self.applyAuraToTowers();
 		}
 	};
 	self.findTargets = function () {
-		// ZMIANA: Nazwa funkcji i jej logika
 		var maxTargets = self.multiShot || 1;
 		var potentialTargets = [];
 		if (self.damage === 0) {
 			return [];
 		}
-		// Logika dla Water Mage
 		if (self.bulletType === 'slow') {
 			var unslowedTargets = [];
 			var slowedTargets = [];
 			enemies.forEach(function (enemy) {
@@ -2449,9 +2516,8 @@
 				}
 			});
 			potentialTargets = unslowedTargets.concat(slowedTargets);
 		} else {
-			// Domyślna logika (najbliższy wróg)
 			enemies.forEach(function (enemy) {
 				var dx = enemy.x - self.x;
 				var dy = enemy.y - self.y;
 				if (dx * dx + dy * dy < self.range * self.range) {
@@ -2466,9 +2532,8 @@
 		}
 		return potentialTargets.slice(0, maxTargets);
 	};
 	self.fire = function () {
-		// ZMIANA: Logika strzelania
 		self.targetEnemies.forEach(function (targetEnemy) {
 			if (targetEnemy && targetEnemy.health > 0) {
 				var dx = targetEnemy.x - self.x;
 				var dy = targetEnemy.y - self.y;
@@ -2580,9 +2645,8 @@
 		}
 		animateStep(1);
 	};
 	self.update = function () {
-		// ZMIANA: Logika aktualizacji
 		if (self.isConstructing) {
 			return;
 		}
 		if (self.towerType === 'banner') {
@@ -2697,9 +2761,9 @@
 	self.addChild(closeButton);
 	closeButton.down = function () {
 		hideUpgradeMenu(self);
 	};
-	function createStatLine(label, value, yPos) {
+	function createStatLine(label, value, yPos, isBuffed) {
 		var statLabel = new Text2(label + ':', {
 			size: 55,
 			fill: 0xFFFFFF,
 			weight: 600,
@@ -2710,9 +2774,10 @@
 		statLabel.y = yPos;
 		self.addChild(statLabel);
 		var statValue = new Text2(value, {
 			size: 55,
-			fill: 0xFFD700,
+			fill: isBuffed ? 0x00FF00 : 0xFFD700,
+			// ZIELONY jeśli wzmocnione
 			weight: 800,
 			align: 'left'
 		});
 		statValue.anchor.set(0, 0.5);
@@ -2720,17 +2785,15 @@
 		statValue.y = yPos;
 		self.addChild(statValue);
 	}
 	function populateStats() {
-		var currentStats = TOWER_DATA[self.tower.towerType][self.tower.level + self.tower.levelPath];
-		if (!currentStats) {
-			return;
-		}
 		var yStart = -120;
 		var yStep = 70;
-		createStatLine('Damage', Math.round(self.tower.damage), yStart);
-		createStatLine('Fire Rate', Math.round(60 / self.tower.fireRate * 100) / 100 + '/s', yStart + yStep);
-		createStatLine('Range', Math.round(self.tower.range / CELL_SIZE * 10) / 10, yStart + yStep * 2);
+		var isDamageBuffed = self.tower.tileBuff && self.tower.tileBuff.damage;
+		var isSpeedBuffed = self.tower.tileBuff && self.tower.tileBuff.attackSpeed;
+		createStatLine('Damage', Math.round(self.tower.damage), yStart, isDamageBuffed);
+		createStatLine('Fire Rate', Math.round(60 / self.tower.fireRate * 100) / 100 + '/s', yStart + yStep, isSpeedBuffed);
+		createStatLine('Range', Math.round(self.tower.range / CELL_SIZE * 10) / 10, yStart + yStep * 2, false); // Zakładamy, że zasięg nie jest buffowany z pola
 	}
 	populateStats();
 	function createUpgradeButton(upgradeKey, position, totalButtons) {
 		var upgradeData = TOWER_DATA[self.tower.towerType][upgradeKey];
@@ -2847,13 +2910,13 @@
 	self.levelNumber = levelNumber;
 	self.onComplete = onComplete;
 	self.cards = [];
 	self.animationTicker = 0;
-	self.animationDelay = 5; // Początkowe opóźnienie (w klatkach)
+	self.animationDelay = 5;
 	self.currentStep = 0;
 	self.winningEventId = null;
 	self.winningCardIndex = -1;
-	// Tło przyciemniające
+	self.stepsToGo = -1; // ZMIANA: Inicjalizujemy na -1, żeby update nie ruszył za wcześnie
 	var bg = self.attachAsset('cell', {
 		width: 2048,
 		height: 2732,
 		tint: 0x000000,
@@ -2863,58 +2926,114 @@
 		alpha: 0.7
 	}, {
 		duration: 300
 	});
-	// Wizualne karty do wyświetlenia (zawsze 5 unikalnych)
 	var visualCardTypes = ['SUNNY', 'RAIN', 'FOG', 'NIGHT', 'STORM'];
 	var cardContainer = new Container();
 	self.addChild(cardContainer);
 	var cardSpacing = 240;
 	var totalWidth = (visualCardTypes.length - 1) * cardSpacing;
 	var startX = -totalWidth / 2;
+	cardContainer.x = 2048 / 2;
+	cardContainer.y = 2732 / 2 - 200;
 	for (var i = 0; i < visualCardTypes.length; i++) {
 		var eventId = visualCardTypes[i];
 		var cardAsset = EVENT_DATA[eventId].asset;
 		var card = cardContainer.attachAsset(cardAsset, {
 			anchorX: 0.5,
 			anchorY: 0.5
 		});
 		card.x = startX + i * cardSpacing;
-		card.tint = 0x777777; // Przyciemnienie nieaktywnych
+		card.y = 500;
+		card.alpha = 0;
+		card.tint = 0x777777;
 		self.cards.push(card);
+		var tweenOptions = {
+			duration: 400,
+			delay: 100 + i * 150,
+			easing: tween.backOut
+		};
+		// ZMIANA: Uruchom losowanie po zakończeniu animacji ostatniej karty
+		if (i === visualCardTypes.length - 1) {
+			tweenOptions.onFinish = function () {
+				self.startSelection();
+			};
+		}
+		tween(card, {
+			y: 0,
+			alpha: 1
+		}, tweenOptions);
 	}
-	cardContainer.x = 2048 / 2;
-	cardContainer.y = 2732 / 2 - 200;
 	self.startSelection = function () {
 		var deck = WEATHER_DECK_DATA[self.levelNumber] || WEATHER_DECK_DATA[1];
 		self.winningEventId = deck[Math.floor(Math.random() * deck.length)];
 		self.winningCardIndex = visualCardTypes.indexOf(self.winningEventId);
-		// Ustawiamy liczbę kroków animacji
 		var fullLoops = 2;
-		self.stepsToGo = fullLoops * self.cards.length + self.winningCardIndex + 1;
+		self.stepsToGo = fullLoops * self.cards.length + self.winningCardIndex; // ZMIANA: Poprawiona kalkulacja kroków
 	};
 	self.showResult = function () {
 		activeWeatherEvent = self.winningEventId;
 		applyActiveWeatherModifiers();
 		var winningCard = self.cards[self.winningCardIndex];
-		// Ukrywamy pozostałe karty
+		winningCard.tint = 0xFFFFFF; // ZMIANA: Gwarancja podświetlenia
+		var flash = self.attachAsset('cell', {
+			width: 2048,
+			height: 2732,
+			tint: 0xFFFFFF,
+			alpha: 0
+		});
+		tween(flash, {
+			alpha: 0.7
+		}, {
+			duration: 100,
+			onFinish: function onFinish() {
+				tween(flash, {
+					alpha: 0
+				}, {
+					duration: 150,
+					onFinish: function onFinish() {
+						flash.destroy();
+					}
+				});
+			}
+		});
+		shakeScreen(15, 200);
+		for (var i = 0; i < 30; i++) {
+			var particle = self.attachAsset('star_particle', {
+				anchorX: 0.5,
+				anchorY: 0.5
+			});
+			particle.x = winningCard.x + cardContainer.x + (Math.random() - 0.5) * 200;
+			particle.y = winningCard.y + cardContainer.y + (Math.random() - 0.5) * 200;
+			particle.scale.set(Math.random() * 0.5 + 0.3);
+			tween(particle, {
+				x: particle.x + (Math.random() - 0.5) * 400,
+				y: particle.y + (Math.random() - 0.5) * 400,
+				alpha: 0,
+				scaleX: 0.1,
+				scaleY: 0.1
+			}, {
+				duration: 800 + Math.random() * 500,
+				onFinish: particle.destroy.bind(particle)
+			});
+		}
 		for (var i = 0; i < self.cards.length; i++) {
 			if (i !== self.winningCardIndex) {
 				tween(self.cards[i], {
-					alpha: 0
+					alpha: 0,
+					y: 50
 				}, {
 					duration: 300
 				});
 			}
 		}
-		// Powiększamy zwycięską kartę i pokazujemy opis
 		tween(winningCard, {
 			x: 0,
 			y: -100,
 			scaleX: 1.5,
 			scaleY: 1.5
 		}, {
-			duration: 400,
+			duration: 800,
 			easing: tween.easeOut
 		});
 		var eventInfo = EVENT_DATA[self.winningEventId];
 		var descriptionContainer = new Container();
@@ -2945,9 +3064,8 @@
 		}, {
 			duration: 400,
 			delay: 200
 		});
-		// Kończymy i niszczymy okno po chwili
 		LK.setTimeout(function () {
 			tween(self, {
 				alpha: 0
 			}, {
@@ -2958,31 +3076,40 @@
 					}
 					self.destroy();
 				}
 			});
-		}, 4000); // Czas na przeczytanie opisu
+		}, 4000);
 	};
 	self.update = function () {
-		if (self.stepsToGo > 0) {
+		if (self.stepsToGo > -1) {
+			// ZMIANA: Sprawdzamy czy losowanie się zaczęło
 			self.animationTicker++;
 			if (self.animationTicker >= self.animationDelay) {
 				self.animationTicker = 0;
-				var prevIndex = (self.currentStep - 1 + self.cards.length) % self.cards.length;
-				self.cards[prevIndex].tint = 0x777777;
+				// ZMIANA: Uproszczona i bardziej niezawodna logika podświetlania
+				self.cards.forEach(function (card) {
+					card.tint = 0x777777;
+				});
 				var currentIndex = self.currentStep % self.cards.length;
 				self.cards[currentIndex].tint = 0xFFFFFF;
-				self.currentStep++;
-				self.stepsToGo--;
-				if (self.stepsToGo < 8) {
-					self.animationDelay += 4;
-				} else if (self.stepsToGo < 15) {
-					self.animationDelay += 1;
-				}
-				if (self.stepsToGo === 0) {
-					self.stepsToGo = -1;
+				if (self.currentStep >= self.stepsToGo) {
+					self.stepsToGo = -1; // Zatrzymaj pętlę losowania
+					// Ostatnie podświetlenie na właściwej karcie
+					self.cards.forEach(function (card) {
+						card.tint = 0x777777;
+					});
+					self.cards[self.winningCardIndex].tint = 0xFFFFFF;
 					LK.setTimeout(function () {
 						self.showResult();
 					}, 1000);
+				} else {
+					self.currentStep++;
+					// Zwalnianie animacji
+					if (self.stepsToGo - self.currentStep < 5) {
+						self.animationDelay += 4;
+					} else if (self.stepsToGo - self.currentStep < 10) {
+						self.animationDelay += 1;
+					}
 				}
 			}
 		}
 	};
@@ -3020,8 +3147,28 @@
 			isMenuTransitioning = false;
 		}
 	});
 }
+function shakeScreen(intensity, duration) {
+	var initialX = game.x;
+	var initialY = game.y;
+	var shakeTicker = 0;
+	var shakeDuration = Math.ceil(duration / 10); // Czas trwania w cyklach
+	function doShake() {
+		if (shakeTicker >= shakeDuration) {
+			game.x = initialX;
+			game.y = initialY;
+			return;
+		}
+		var shakeX = (Math.random() - 0.5) * intensity;
+		var shakeY = (Math.random() - 0.5) * intensity;
+		game.x = initialX + shakeX;
+		game.y = initialY + shakeY;
+		shakeTicker++;
+		LK.setTimeout(doShake, 10);
+	}
+	doShake();
+}
 function createHitSparks(x, y) {
 	var numSparks = 5;
 	for (var i = 0; i < numSparks; i++) {
 		var spark = new Container();
@@ -3924,8 +4071,9 @@
 var waveSpawned;
 var nextWaveTime;
 var sourceTowers;
 var grid;
+var specialZoneIndicators;
 var wavesText;
 var towerLayer;
 var spawnQueue;
 var waveClock;
@@ -4634,9 +4782,10 @@
 	bullets = [];
 	friendlyUnits = [];
 	peopleRegenQueue = [];
 	activeSpells = [];
-	npcs = []; // NOWA LINIA
+	npcs = [];
+	specialZoneIndicators = []; // NOWA LINIA
 	selectedTower = null;
 	castleBuildings = [];
 	gold = levelData.initialGold;
 	lives = levelData.initialLives;
@@ -4715,82 +4864,61 @@
 	if (levelData.mapAsset === 'map3') {
 		grid.x = 235;
 	}
 	for (var y = 0; y < levelData.mapLayout.length; y++) {
-		var _loop = function _loop() {
-				tileChar = levelData.mapLayout[y][x];
-				cell = grid.getCell(x, y + 5);
-				if (cell) {
-					cell.specialEffect = null;
-					if (tileChar === '0') {
-						cell.type = 0;
-					} else if (tileChar === '1' || tileChar === 'A' || tileChar === 'C') {
-						cell.type = 1;
-						if (tileChar === 'A' || tileChar === 'C') {
-							cell.specialEffect = tileChar === 'A' ? 'amplifier' : 'catalyst';
-							// Sprawdzamy, czy to lewy-górny róg strefy 2x2, by narysować tylko jeden wskaźnik
-							isTopLeft = levelData.mapLayout[y][x - 1] !== tileChar && levelData.mapLayout[y - 1] && levelData.mapLayout[y - 1][x] !== tileChar;
-							if (isTopLeft) {
-								// Animacja pulsowania
-								var _pulse = function pulse() {
-									if (!zoneIndicator.parent) return;
-									tween(indicatorGraphic, {
-										alpha: 0.4
-									}, {
-										duration: 1500,
-										easing: tween.easeInOut,
-										onFinish: function onFinish() {
-											tween(indicatorGraphic, {
-												alpha: 0.2
-											}, {
-												duration: 1500,
-												easing: tween.easeInOut,
-												onFinish: _pulse
-											});
-										}
-									});
-								};
-								zoneIndicator = new Container();
-								indicatorGraphic = zoneIndicator.attachAsset('rangeCircle', {
-									// Placeholder, użyjemy grafiki od Ciebie
-									anchorX: 0,
-									anchorY: 0,
-									width: CELL_SIZE * 2,
-									height: CELL_SIZE * 2,
-									tint: tileChar === 'A' ? 0xFFD700 : 0x9370DB,
-									// Złoty lub fioletowy
-									alpha: 0.25
-								});
-								zoneIndicator.x = grid.x + x * CELL_SIZE;
-								zoneIndicator.y = grid.y + (y + 5) * CELL_SIZE;
-								specialTilesLayer.addChild(zoneIndicator);
-								_pulse();
+		for (var x = 0; x < levelData.mapLayout[y].length; x++) {
+			var tileChar = levelData.mapLayout[y][x];
+			var cell = grid.getCell(x, y + 5);
+			if (cell) {
+				cell.specialEffect = null;
+				if (tileChar === '0') {
+					cell.type = 0;
+				} else if (tileChar === '1' || tileChar === 'A' || tileChar === 'C') {
+					cell.type = 1;
+					if (tileChar === 'A' || tileChar === 'C') {
+						cell.specialEffect = tileChar === 'A' ? 'amplifier' : 'catalyst';
+						var isTopLeft = (x === 0 || levelData.mapLayout[y][x - 1] !== tileChar) && (y === 0 || !levelData.mapLayout[y - 1] || levelData.mapLayout[y - 1][x] !== tileChar);
+						if (isTopLeft) {
+							var zoneWidth = 1;
+							var zoneHeight = 1;
+							while (x + zoneWidth < levelData.mapLayout[y].length && levelData.mapLayout[y][x + zoneWidth] === tileChar) {
+								zoneWidth++;
 							}
+							while (y + zoneHeight < levelData.mapLayout.length && levelData.mapLayout[y + zoneHeight][x] === tileChar) {
+								zoneHeight++;
+							}
+							var zoneSize = Math.max(zoneWidth, zoneHeight);
+							var assetName = tileChar === 'A' ? 'buff_amplifier_zone' : 'buff_catalyst_zone';
+							var zoneIndicator = new Container();
+							var indicatorGraphic = zoneIndicator.attachAsset(assetName, {
+								anchorX: 0.5,
+								anchorY: 0.5,
+								width: CELL_SIZE * (zoneSize + 0.5),
+								height: CELL_SIZE * (zoneSize + 0.5),
+								alpha: 0.7 // Ustawiamy stałą przezroczystość
+							});
+							zoneIndicator.x = grid.x + x * CELL_SIZE + CELL_SIZE * zoneWidth / 2;
+							zoneIndicator.y = grid.y + (y + 5) * CELL_SIZE + CELL_SIZE * zoneHeight / 2;
+							specialTilesLayer.addChild(zoneIndicator);
+							specialZoneIndicators.push(zoneIndicator);
+							// USUNIĘTO CAŁĄ FUNKCJĘ PULSOWANIA
 						}
-						tilePlaceholder = buildableTilesLayer.attachAsset('cell', {
-							anchorX: 0.5,
-							anchorY: 0.5
-						});
-						tilePlaceholder.alpha = 0.25;
-						tilePlaceholder.x = grid.x + x * CELL_SIZE + CELL_SIZE / 2;
-						tilePlaceholder.y = grid.y + (y + 5) * CELL_SIZE + CELL_SIZE / 2;
-					} else if (tileChar === 'S') {
-						cell.type = 3;
-					} else if (tileChar === 'E') {
-						cell.type = 4;
-					} else {
-						cell.type = 2;
 					}
+					var tilePlaceholder = buildableTilesLayer.attachAsset('cell', {
+						anchorX: 0.5,
+						anchorY: 0.5
+					});
+					tilePlaceholder.alpha = 0.25;
+					tilePlaceholder.x = grid.x + x * CELL_SIZE + CELL_SIZE / 2;
+					tilePlaceholder.y = grid.y + (y + 5) * CELL_SIZE + CELL_SIZE / 2;
+				} else if (tileChar === 'S') {
+					cell.type = 3;
+				} else if (tileChar === 'E') {
+					cell.type = 4;
+				} else {
+					cell.type = 2;
 				}
-			},
-			tileChar,
-			cell,
-			isTopLeft,
-			zoneIndicator,
-			indicatorGraphic,
-			tilePlaceholder;
-		for (var x = 0; x < levelData.mapLayout[y].length; x++) {
-			_loop();
+			}
 		}
 	}
 	var castleGridWidth = 17;
 	var castleGridHeight = 22;
@@ -5684,6 +5812,11 @@
 	}
 	updateGameLogic();
 	updateGameObjects();
 	updatePreviews();
+	if (specialZoneIndicators) {
+		for (var i = 0; i < specialZoneIndicators.length; i++) {
+			specialZoneIndicators[i].rotation += 0.001;
+		}
+	}
 };
 showTitleScreen();
\ No newline at end of file