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

/**** 
* Classes
****/ 
var Note = Container.expand(function (noteType, swipeDir, targetHitTimeFull, centerXVal) {
	var self = Container.call(this);
	self.noteType = noteType || 'tap';
	self.swipeDir = swipeDir || null;
	self.targetHitTime = targetHitTimeFull;
	self.visualSpawnTime = self.targetHitTime - noteTravelTime;
	self.hit = false;
	self.judged = false;
	self.scaleStart = 0.05;
	self.scaleEnd = 1.4;
	self.centerX = centerXVal;
	self.centerY = 1800;
	self.startY = 400;
	self.noteAsset = null;
	self.isWiderSwipePart = false; // Flag for wider swipe rendering if needed later
	// Store original columnIndex if available, for potential debugging or advanced logic
	if (this.mapData && this.mapData.originalColumnHint !== undefined) {
		self.originalColumnHint = this.mapData.originalColumnHint;
	}
	if (self.noteType === 'tap') {
		self.noteAsset = self.attachAsset('tapNote', {
			anchorX: 0.5,
			anchorY: 0.5
		});
	} else if (self.noteType === 'swipe') {
		self.noteAsset = self.attachAsset('swipeNote', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		if (self.swipeDir) {
			var arrow = new Text2('', {
				size: 80,
				fill: 0xFFFFFF
			});
			arrow.anchor.set(0.5, 0.5);
			if (self.swipeDir === 'left') {
				arrow.setText('←');
			} else if (self.swipeDir === 'right') {
				arrow.setText('→');
			} else if (self.swipeDir === 'up') {
				arrow.setText('↑');
			} else if (self.swipeDir === 'down') {
				arrow.setText('↓');
			}
			self.addChild(arrow);
			self.arrow = arrow;
		}
	} else if (self.noteType === 'trap') {
		self.noteAsset = self.attachAsset('trapNote', {
			anchorX: 0.5,
			anchorY: 0.5
		});
	}
	self.alpha = 0;
	self.showHitFeedback = function (result) {
		// Existing circular feedback
		var feedbackCircle = LK.getAsset('hitFeedback', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: 0,
			// Relative to the note's center
			y: 0,
			// Relative to the note's center
			scaleX: 0.7,
			scaleY: 0.7,
			alpha: 0.7
		});
		var feedbackTextContent = "";
		var feedbackTextColor = 0xFFFFFF; // Default white
		if (result === 'perfect') {
			feedbackCircle.tint = 0xffff00; // Yellow
			feedbackTextContent = "Perfect!"; // Or "+100"
			feedbackTextColor = 0xffff00;
		} else if (result === 'good') {
			feedbackCircle.tint = 0x00ff00; // Green
			feedbackTextContent = "Good!"; // Or "+50"
			feedbackTextColor = 0x00ff00;
		} else {
			// 'miss'
			feedbackCircle.tint = 0xff0000; // Red
			feedbackTextContent = "Miss";
			feedbackTextColor = 0xff0000;
		}
		self.addChild(feedbackCircle); // Add circle to the note container
		tween(feedbackCircle, {
			alpha: 0,
			scaleX: 1.5,
			scaleY: 1.5
		}, {
			duration: 350,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				if (feedbackCircle.parent) {
					feedbackCircle.destroy();
				}
			}
		});
		// New text feedback
		if (feedbackTextContent) {
			var scorePopup = new Text2(feedbackTextContent, {
				size: 60,
				// Możemy dostosować rozmiar
				fill: feedbackTextColor,
				stroke: 0x000000,
				// Czarny kontur dla lepszej czytelności
				strokeThickness: 3
			});
			scorePopup.anchor.set(0.5, 0.5);
			scorePopup.x = 0; // W centrum notatki (tam gdzie feedbackCircle)
			scorePopup.y = -SWIPE_NOTE_WIDTH / 2 - 30; // Trochę nad notatką (zakładając, że notatka ma środek w 0,0)
			// Możemy potrzebować dostosować Y, jeśli anchor notatki jest inny
			// Add to the main game layer (or LK.gui.top) so it's not affected by note's alpha/scale changes later
			// If added to self (note), it would disappear if note is quickly destroyed.
			// Let's add it to the note's parent (which should be 'game')
			if (self.parent) {
				// Ensure note has a parent
				// Position needs to be absolute if added to game layer
				scorePopup.x = self.x + 0; // (self.x (Note's absolute X) + relative X (0))
				scorePopup.y = self.y - SWIPE_NOTE_WIDTH * self.scale.y / 2 - 30; // (self.y (Note's absolute Y) + relative Y)
				self.parent.addChild(scorePopup); // Add to the same layer as the note
			}
			tween(scorePopup, {
				y: scorePopup.y - 80,
				// Animacja w górę
				alpha: 0
			}, {
				duration: 700,
				// Dłuższy czas trwania animacji
				easing: tween.easeOut,
				onFinish: function onFinish() {
					if (scorePopup.parent) {
						scorePopup.destroy();
					}
				}
			});
		}
	};
	self.update = function () {
		var now = Date.now();
		if (self.judged) {
			// If judged (hit or missed), it might still be moving for a bit
			if (now > self.targetHitTime + 500) {// Time after hit/miss to be fully removed by removeOldNotes
			}
			if (this.alpha > 0) {
				// Only update position if visible
				var elapsedTimeSinceSpawn = now - self.visualSpawnTime;
				var currentProgress = elapsedTimeSinceSpawn / noteTravelTime;
				// No clamping progress to 1 here, so it can go beyond
				self.x = self.centerX;
				self.y = self.startY + (self.centerY - self.startY) * currentProgress;
				// Keep scale at max after passing hit line
				var currentScale = currentProgress >= 1 ? self.scaleEnd : self.scaleStart + (self.scaleEnd - self.scaleStart) * currentProgress;
				self.scale.x = Math.max(0.01, currentScale);
				self.scale.y = Math.max(0.01, currentScale);
			}
			return;
		}
		if (now < self.visualSpawnTime) {
			self.alpha = 0;
			return;
		}
		if (self.alpha === 0 && !self.judged) {
			self.alpha = 1;
		}
		var elapsedTimeSinceSpawn = now - self.visualSpawnTime;
		var progress = elapsedTimeSinceSpawn / noteTravelTime;
		// Notatka leci dalej, więc progress może być > 1
		// Nie ograniczamy już progress do 1 tutaj dla pozycji i skali
		// Skala osiąga self.scaleEnd przy progress = 1 i tak pozostaje
		var scale;
		if (progress >= 1) {
			scale = self.scaleEnd;
		} else if (progress < 0) {
			// Powinno być obsłużone przez visualSpawnTime check, ale dla pewności
			scale = self.scaleStart;
			progress = 0; // Clamp progress for position if it was somehow negative
		} else {
			scale = self.scaleStart + (self.scaleEnd - self.scaleStart) * progress;
		}
		self.scale.x = Math.max(0.01, scale);
		self.scale.y = Math.max(0.01, scale);
		self.x = self.centerX;
		self.y = self.startY + (self.centerY - self.startY) * progress; // Pozwalamy Y iść dalej
		// Oznacz jako miss, jeśli nie została oceniona i minął czas + okno tolerancji
		if (!self.judged && now > self.targetHitTime + hitWindowGood) {
			self.judged = true; // Oznaczona jako oceniona (w tym przypadku jako miss)
			if (self.noteType !== 'trap') {
				game.onNoteMiss(self); // Wywołaj logikę miss
			}
			// Notatka będzie dalej widoczna i usuwana przez removeOldNotes
		}
	};
	self.isInHitWindow = function () {
		var now = Date.now();
		var dt = Math.abs(now - self.targetHitTime);
		return dt <= hitWindowGood;
	};
	self.getHitAccuracy = function () {
		var now = Date.now();
		var dt = Math.abs(now - self.targetHitTime);
		if (dt <= hitWindowPerfect) {
			return 'perfect';
		}
		if (dt <= hitWindowGood) {
			return 'good';
		}
		return 'miss';
	};
	return self;
});
var PowerUpItem = Container.expand(function (powerUpType, centerXVal) {
	var self = Container.call(this);
	self.itemType = powerUpType;
	self.centerX = centerXVal;
	self.startY = 600;
	self.centerY = 1800; // Linia uderzenia/zbierania
	self.visualAsset = null;
	self.collected = false;
	self.spawnTime = Date.now();
	self.isAtDestinationAndPotentiallyMissed = false; // Nowa flaga
	if (self.itemType === 'potion') {
		self.visualAsset = self.attachAsset('hpPotionAsset', {
			anchorX: 0.5,
			anchorY: 0.5
		});
	} else if (self.itemType === 'shield') {
		self.visualAsset = self.attachAsset('shieldAsset', {
			anchorX: 0.5,
			anchorY: 0.5
		});
	} else if (self.itemType === 'swipeToTap') {
		self.visualAsset = self.attachAsset('swipeToTapBuffAsset', {
			anchorX: 0.5,
			anchorY: 0.5
		});
	} else {
		console.log("Error: Nieznany typ PowerUpa przy tworzeniu assetu: " + self.itemType);
		self.visualAsset = self.attachAsset('hpPotionAsset', {
			anchorX: 0.5,
			anchorY: 0.5
		});
	}
	self.alpha = 1;
	self.scale.set(1);
	self.x = self.centerX; // Ustawienie początkowej pozycji X
	self.y = self.startY; // Ustawienie początkowej pozycji Y
	self.update = function () {
		if (self.collected) {
			// Jeśli zebrany, nic więcej nie rób (zostanie usunięty przez managePowerUpItems)
			return;
		}
		// Jeśli w poprzedniej klatce dotarł do celu i nie został zebrany, teraz go usuwamy
		if (self.isAtDestinationAndPotentiallyMissed) {
			if (!self.collected) {
				// Podwójne sprawdzenie, na wszelki wypadek
				console.log("PowerUp " + self.itemType + " ostatecznie minięty i niszczony");
				if (self.parent) {
					self.destroy();
				}
			}
			return; // Kończymy update dla tego obiektu
		}
		var now = Date.now();
		var progress = (now - self.spawnTime) / noteTravelTime;
		if (progress >= 1) {
			self.y = self.centerY; // Ustawiamy dokładnie na linii uderzenia
			// Dotarł do linii. Ustawiamy flagę, ale nie niszczymy od razu.
			// Zniszczenie (jeśli nie zebrany) nastąpi w następnej klatce update().
			// Daje to szansę na zarejestrowanie kliknięcia w tej klatce.
			self.isAtDestinationAndPotentiallyMissed = true;
			// Na tym etapie jeszcze nie logujemy "minięty", bo może zostać kliknięty w tej klatce.
		} else {
			// Nadal w ruchu
			self.y = self.startY + (self.centerY - self.startY) * progress;
		}
	};
	self.collect = function () {
		if (self.collected) {
			return;
		}
		self.collected = true;
		console.log("PowerUp " + self.itemType + " zebrany!");
		if (collectedPowerUps.hasOwnProperty(self.itemType)) {
			collectedPowerUps[self.itemType]++;
			console.log("Masz teraz " + collectedPowerUps[self.itemType] + " x " + self.itemType);
			updatePowerUpDisplayCounts(); // NOWE: Aktualizuj UI po zebraniu
		}
		if (self.parent) {
			self.destroy();
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Ustaw odpowiednie width i height, jeśli są inne niż domyślne wymiary ekranu
function _typeof2(o) {
	"@babel/helpers - typeof";
	return _typeof2 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
		return typeof o;
	} : function (o) {
		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
	}, _typeof2(o);
}
function _typeof(o) {
	"@babel/helpers - typeof";
	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
		return typeof o;
	} : function (o) {
		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
	}, _typeof(o);
}
function showStartScreen() {
	currentScreenState = 'start';
	if (gameUIContainer) {
		gameUIContainer.visible = false;
	}
	if (hitZoneLine) {
		hitZoneLine.visible = false;
	}
	// Usunięte linie ukrywające shieldTimerDisplayContainer i swipeToTapTimerDisplayContainer,
	// ponieważ teraz nie powinny być w ogóle tworzone w tym stanie.
	game.setBackgroundColor(0x000000);
	var startButton = new Text2("MAKE SOME NOISEE", {
		size: 150,
		fill: 0xFFFFFF
	});
	startButton.anchor.set(0.5, 0.5);
	startButton.x = gameScreenWidth / 2;
	startButton.y = gameScreenHeight / 2;
	startButton.interactive = true;
	startButton.cursor = "pointer";
	game.addChild(startButton);
	startButton.down = function () {
		if (startButton.parent) {
			startButton.destroy();
		}
		showIntro();
	};
}
function updateMainMenuHighlight(newIndex) {
	var defaultTint = 0xFFFFFF; // Biały tint (brak efektu, oryginalny kolor tekstu)
	var highlightTint = 0xFFD700; // Żółty tint dla podświetlenia
	var defaultScale = 1.0;
	var highlightScale = 1.15; // Skala dla podświetlonej opcji
	// Resetuj styl dla wszystkich opcji
	for (var i = 0; i < mainMenuItemTextObjects.length; i++) {
		if (mainMenuItemTextObjects[i] && mainMenuItemTextObjects[i].parent) {
			// Zakładamy, że bazowy .fill tekstu jest biały (ustawiony przy tworzeniu)
			mainMenuItemTextObjects[i].tint = defaultTint;
			mainMenuItemTextObjects[i].scale.set(defaultScale);
		}
	}
	// Ustaw styl dla nowo wybranej opcji
	if (newIndex >= 0 && newIndex < mainMenuItemTextObjects.length) {
		if (mainMenuItemTextObjects[newIndex] && mainMenuItemTextObjects[newIndex].parent) {
			var targetItem = mainMenuItemTextObjects[newIndex];
			targetItem.tint = highlightTint;
			targetItem.scale.set(highlightScale);
		}
	}
	selectedMainMenuItemIndex = newIndex; // Aktualizuj globalny indeks
}
function showMainMenu() {
	while (mainMenuScreenElements.length > 0) {
		var el = mainMenuScreenElements.pop();
		if (el && el.parent) {
			el.destroy();
		}
	}
	mainMenuItemTextObjects = [];
	currentScreenState = 'mainmenu_walkman';
	if (gameUIContainer) {
		gameUIContainer.visible = false;
	}
	if (hitZoneLine) {
		hitZoneLine.visible = false;
	}
	if (shieldTimerDisplayContainer) {
		shieldTimerDisplayContainer.visible = false;
	}
	if (swipeToTapTimerDisplayContainer) {
		swipeToTapTimerDisplayContainer.visible = false;
	}
	if (songSummaryContainer && songSummaryContainer.parent) {
		songSummaryContainer.destroy();
	}
	// Definicje dla szkiełka - takie same jak w boss menu
	var glassX = 384;
	var glassY = 1050;
	var glassWidth = 1000;
	var glassHeight = 720;
	var glassAlpha = 0.5;
	// Ustawienia dla czcionki i odstępów menu - możesz je nadal dostosowywać
	var menuItemFontSize = 120; // Twoja wartość
	var menuItemSpacing = 250; // Twoja wartość
	// Centrum obszaru "szkiełka" - tutaj będą centrowane opcje menu
	var TARGET_CENTER_X_FOR_MENU_ITEMS = gameScreenWidth / 2 - 80;
	var TARGET_CENTER_Y_FOR_SELECTED_ITEM = gameScreenHeight / 2 + 30;
	// 1. Kontener na teksty menu (rysowany najgłębiej)
	var menuTextContainer = new Container();
	game.addChild(menuTextContainer);
	mainMenuScreenElements.push(menuTextContainer);
	selectedMainMenuItemIndex = 0;
	for (var i = 0; i < mainMenuItems.length; i++) {
		var itemText = new Text2(mainMenuItems[i], {
			size: menuItemFontSize,
			fill: 0xFFFFFF,
			align: 'center'
		});
		itemText.anchor.set(0.5, 0.5);
		itemText.interactive = false;
		menuTextContainer.addChild(itemText);
		mainMenuItemTextObjects.push(itemText);
	}
	function layoutAndHighlightMainMenuItems() {
		var defaultTint = 0xFFFFFF;
		var highlightTint = 0xFFD700;
		var defaultScale = 1.0;
		var highlightScale = 1.15;
		for (var i = 0; i < mainMenuItemTextObjects.length; i++) {
			var item = mainMenuItemTextObjects[i];
			if (item && item.parent) {
				item.y = TARGET_CENTER_Y_FOR_SELECTED_ITEM + (i - selectedMainMenuItemIndex) * menuItemSpacing;
				item.x = TARGET_CENTER_X_FOR_MENU_ITEMS;
				if (i === selectedMainMenuItemIndex) {
					item.tint = highlightTint;
					item.scale.set(highlightScale);
				} else {
					item.tint = defaultTint;
					item.scale.set(defaultScale);
				}
			}
		}
	}
	// 2. Dodaj "szkiełko" (glassAsset) - RYSOWANE NAD TEKSTAMI
	var glass = LK.getAsset('glass', {
		x: glassX,
		y: glassY,
		width: glassWidth,
		height: glassHeight,
		alpha: glassAlpha,
		interactive: false
	});
	game.addChild(glass);
	mainMenuScreenElements.push(glass);
	// 3. Główna grafika Walkmana (asset 'mainmenu') - RYSOWANA NAD SZKIEŁKIEM I TEKSTAMI
	// Zakładamy, że jej przezroczysty ekran idealnie pasuje do wymiarów i pozycji 'glass'
	var walkmanFrame = LK.getAsset('mainmenu', {
		x: 0,
		y: 0,
		width: gameScreenWidth,
		height: gameScreenHeight
	});
	game.addChild(walkmanFrame);
	mainMenuScreenElements.push(walkmanFrame);
	// 4. Przyciski - RYSOWANE NAD GRAFIKĄ WALKMANA (ich pozycje pozostają takie same jak w boss menu)
	var upButton = LK.getAsset('upbutton', {});
	upButton.x = 210;
	upButton.y = gameScreenHeight / 2 - 180;
	upButton.anchor.set(0.5, 0.5);
	upButton.interactive = true;
	upButton.cursor = "pointer";
	upButton.down = function () {
		selectedMainMenuItemIndex = (selectedMainMenuItemIndex - 1 + mainMenuItems.length) % mainMenuItems.length;
		layoutAndHighlightMainMenuItems();
	};
	game.addChild(upButton);
	mainMenuScreenElements.push(upButton);
	var downButton = LK.getAsset('downbutton', {});
	downButton.x = 210;
	downButton.y = gameScreenHeight / 2 + 220;
	downButton.anchor.set(0.5, 0.5);
	downButton.interactive = true;
	downButton.cursor = "pointer";
	downButton.down = function () {
		selectedMainMenuItemIndex = (selectedMainMenuItemIndex + 1) % mainMenuItems.length;
		layoutAndHighlightMainMenuItems();
	};
	game.addChild(downButton);
	mainMenuScreenElements.push(downButton);
	var playButton = LK.getAsset('play', {});
	playButton.x = gameScreenWidth - 350;
	playButton.y = gameScreenHeight / 2 - 240;
	playButton.anchor.set(0.5, 0.5);
	playButton.interactive = true;
	playButton.cursor = "pointer";
	playButton.down = function () {
		console.log("Main Menu: Przycisk PLAY wciśnięty");
	};
	game.addChild(playButton);
	mainMenuScreenElements.push(playButton);
	var stopButton = LK.getAsset('stop', {});
	stopButton.x = gameScreenWidth - 350;
	stopButton.y = gameScreenHeight / 2;
	stopButton.anchor.set(0.5, 0.5);
	stopButton.interactive = true;
	stopButton.cursor = "pointer";
	stopButton.down = function () {
		console.log("Main Menu: Przycisk STOP wciśnięty");
	};
	game.addChild(stopButton);
	mainMenuScreenElements.push(stopButton);
	var fightButton = LK.getAsset('fight', {});
	fightButton.x = gameScreenWidth - 350;
	fightButton.y = gameScreenHeight / 2 + 240;
	fightButton.anchor.set(0.5, 0.5);
	fightButton.interactive = true;
	fightButton.cursor = "pointer";
	fightButton.down = function () {
		var selectedAction = mainMenuItems[selectedMainMenuItemIndex];
		while (mainMenuScreenElements.length > 0) {
			var elemToDestroy = mainMenuScreenElements.pop();
			if (elemToDestroy && elemToDestroy.parent) {
				elemToDestroy.destroy();
			}
		}
		mainMenuItemTextObjects = [];
		if (selectedAction === "Music Battle") {
			showBossSelectionScreen();
		} else if (selectedAction === "How To Play") {
			showTutorial();
		} else if (selectedAction === "Credits") {
			showCreditsScreen();
		} else if (selectedAction === "Stats") {
			console.log("Stats screen selected - (Not yet implemented)");
			var tempStatsPopup = new Text2("Stats Screen\n(Coming Soon!)", {
				size: 100,
				fill: 0xffffff,
				align: 'center'
			});
			tempStatsPopup.anchor.set(0.5, 0.5);
			tempStatsPopup.x = gameScreenWidth / 2;
			tempStatsPopup.y = gameScreenHeight / 2;
			game.addChild(tempStatsPopup);
			LK.setTimeout(function () {
				if (tempStatsPopup.parent) {
					tempStatsPopup.destroy();
				}
			}, 2000);
		}
	};
	game.addChild(fightButton);
	mainMenuScreenElements.push(fightButton);
	layoutAndHighlightMainMenuItems(); // Początkowe ułożenie i podświetlenie
}
var allBossData = [];
var currentBossViewStartIndex = 0;
var cardsContainer = null;
var visibleBossCards = [null, null, null, null];
var selectedCardSlotIndex = 0;
var currentlyPlayingMusic = null;
var peekingBossCards = [null, null];
var placeholderMusicKey = 'test1';
var placeholderSongMapKey = 'defaultTestTrack';
var visibleBossCards = [null, null];
function initializeBossData() {
	allBossData = [{
		id: 'boss1',
		displayName: 'Boss 1',
		cardAssetKey: 'boss1',
		musicAssetKey: 'Orctave',
		songMapKey: 'OrctaveBossTrack',
		defeatsRequired: 0
	}, {
		id: 'boss2',
		displayName: 'Boss 2',
		cardAssetKey: 'boss2',
		musicAssetKey: placeholderMusicKey,
		songMapKey: placeholderSongMapKey,
		defeatsRequired: 0
	}, {
		id: 'boss3',
		displayName: 'Boss 3',
		cardAssetKey: 'boss3',
		musicAssetKey: placeholderMusicKey,
		songMapKey: placeholderSongMapKey,
		defeatsRequired: 0
	}, {
		id: 'boss4',
		displayName: 'Boss 4',
		cardAssetKey: 'boss4',
		musicAssetKey: placeholderMusicKey,
		songMapKey: placeholderSongMapKey,
		defeatsRequired: 1
	}, {
		id: 'boss5',
		displayName: 'Boss 5',
		cardAssetKey: 'boss5',
		musicAssetKey: placeholderMusicKey,
		songMapKey: placeholderSongMapKey,
		defeatsRequired: 2
	}, {
		id: 'boss6',
		displayName: 'Boss 6',
		cardAssetKey: 'boss6',
		musicAssetKey: placeholderMusicKey,
		songMapKey: placeholderSongMapKey,
		defeatsRequired: 3
	}, {
		id: 'boss7',
		displayName: 'Boss 7',
		cardAssetKey: 'boss7',
		musicAssetKey: placeholderMusicKey,
		songMapKey: placeholderSongMapKey,
		defeatsRequired: 4
	}, {
		id: 'boss8',
		displayName: 'Boss 8',
		cardAssetKey: 'boss8',
		musicAssetKey: placeholderMusicKey,
		songMapKey: placeholderSongMapKey,
		defeatsRequired: 5
	}];
	var loadedUnlockProgress = storage[BOSS_UNLOCK_KEY];
	if (loadedUnlockProgress) {
		bossUnlockProgress = loadedUnlockProgress;
		// Upewnij się, że wszyscy zdefiniowani bossowie mają wpis w postępie
		// (na wypadek dodania nowych bossów w przyszłości i starym zapisie w storage)
		for (var i = 0; i < allBossData.length; i++) {
			var bossId = allBossData[i].id;
			if (!bossUnlockProgress.hasOwnProperty(bossId)) {
				bossUnlockProgress[bossId] = false;
			}
		}
	} else {
		// Inicjalizuj, jeśli nie znaleziono w storage
		bossUnlockProgress = {};
		for (var j = 0; j < allBossData.length; j++) {
			bossUnlockProgress[allBossData[j].id] = false;
		}
	}
}
function updateSelectedCardVisual() {
	for (var i = 0; i < visibleBossCards.length; i++) {
		var cardContainer = visibleBossCards[i];
		if (cardContainer && cardContainer.visualAsset) {
			if (i === selectedCardSlotIndex) {
				cardContainer.visualAsset.tint = 0xFFFF00;
				cardContainer.scale.set(1.05);
			} else {
				cardContainer.visualAsset.tint = 0xFFFFFF;
				cardContainer.scale.set(1.0);
			}
		}
	}
}
function displayBossCards(newStartIndex, isInitialDisplay, numberOfDefeated) {
	currentBossViewStartIndex = newStartIndex;
	var singleCardDisplayWidth = 400;
	var singleCardDisplayHeight = 380;
	var spacingBetweenCardsX = 80;
	var cardSlotX_0 = singleCardDisplayWidth / 2;
	var cardSlotX_1 = singleCardDisplayWidth * 1.5 + spacingBetweenCardsX;
	var mainCardsCenterY_relative = singleCardDisplayHeight / 2;
	var peekingCardVisibleSliceHeight = 80;
	var verticalOffsetMainToPeeking = 140;
	var mainCardSlotsPositions = [{
		x: cardSlotX_0,
		y: mainCardsCenterY_relative
	}, {
		x: cardSlotX_1,
		y: mainCardsCenterY_relative
	}];
	var peekingCardsTopY_relative = mainCardsCenterY_relative + singleCardDisplayHeight / 2 + verticalOffsetMainToPeeking;
	var peekingCardSlotsPositions = [{
		x: cardSlotX_0,
		y: peekingCardsTopY_relative
	}, {
		x: cardSlotX_1,
		y: peekingCardsTopY_relative
	}];
	if (!cardsContainer) {
		return;
	}
	while (cardsContainer.children[0]) {
		cardsContainer.removeChild(cardsContainer.children[0]).destroy();
	}
	visibleBossCards = [null, null];
	peekingBossCards = [null, null];
	for (var i = 0; i < 2; i++) {
		var dataIndex = currentBossViewStartIndex + i;
		if (dataIndex < allBossData.length) {
			var bossData = allBossData[dataIndex];
			var cardContainer = new Container();
			cardContainer.x = mainCardSlotsPositions[i].x;
			cardContainer.y = mainCardSlotsPositions[i].y;
			cardContainer.bossData = bossData;
			cardContainer.slotIndex = i;
			var cardAsset = LK.getAsset(bossData.cardAssetKey, {});
			cardAsset.anchor.set(0.5, 0.5);
			cardAsset.width = singleCardDisplayWidth;
			cardAsset.height = singleCardDisplayHeight;
			cardContainer.visualAsset = cardAsset;
			cardContainer.addChild(cardAsset);
			var nameText = new Text2(bossData.displayName, {
				size: 30,
				fill: 0xFFFFFF,
				stroke: 0x000000,
				strokeThickness: 2
			});
			nameText.anchor.set(0.5, 0);
			nameText.x = 0;
			nameText.y = singleCardDisplayHeight / 2 + 5;
			cardContainer.addChild(nameText);
			var isUnlocked = bossData.defeatsRequired === 0 || numberOfDefeated >= bossData.defeatsRequired;
			bossData.isUnlocked = isUnlocked; // Zapiszmy status odblokowania
			// Wszystkie karty są interaktywne
			cardContainer.interactive = true;
			cardContainer.cursor = "pointer";
			cardContainer.down = function () {
				selectedCardSlotIndex = this.slotIndex;
				updateSelectedCardVisual();
			};
			// Usunięto wizualne zmiany dla zablokowanych kart (alpha, tekst "LOCKED")
			cardsContainer.addChild(cardContainer);
			visibleBossCards[i] = cardContainer;
		}
	}
	for (var j = 0; j < 2; j++) {
		var peekingDataIndex = currentBossViewStartIndex + 2 + j;
		if (peekingDataIndex < allBossData.length) {
			var peekingBossData = allBossData[peekingDataIndex];
			var peekingCardContainer = new Container();
			peekingCardContainer.x = peekingCardSlotsPositions[j].x;
			peekingCardContainer.y = peekingCardSlotsPositions[j].y;
			var peekingCardAsset = LK.getAsset(peekingBossData.cardAssetKey, {});
			peekingCardAsset.anchor.set(0.5, 0); // Anchor u góry na środku dla "zajawki"
			peekingCardAsset.width = singleCardDisplayWidth;
			peekingCardAsset.height = singleCardDisplayHeight;
			peekingCardContainer.addChild(peekingCardAsset);
			// Usunięto wizualne zmiany dla zablokowanych kart "zajawek" (alpha, tekst "LOCKED")
			peekingCardContainer.interactive = false; // Zajawki pozostają nieinteraktywne
			cardsContainer.addChild(peekingCardContainer);
			peekingBossCards[j] = peekingCardContainer;
		}
	}
	if (isInitialDisplay) {
		selectedCardSlotIndex = 0;
	} else {
		var maxSlotOnNewPage = Math.min(1, allBossData.length - 1 - currentBossViewStartIndex);
		if (selectedCardSlotIndex > maxSlotOnNewPage) {
			selectedCardSlotIndex = maxSlotOnNewPage;
		}
	}
	updateSelectedCardVisual();
}
function getNumberOfDefeatedBosses() {
	var count = 0;
	for (var i = 0; i < allBossData.length; i++) {
		// Zakładamy, że allBossData zawiera tylko standardowych bossów (1-8)
		var bossId = allBossData[i].id;
		if (bossUnlockProgress.hasOwnProperty(bossId) && bossUnlockProgress[bossId] === true) {
			count++;
		}
	}
	return count;
}
function showBossSelectionScreen() {
	if (songSummaryContainer && songSummaryContainer.parent) {
		songSummaryContainer.destroy();
		songSummaryContainer = null;
	}
	currentScreenState = 'bossGallery_paged';
	if (gameUIContainer) {
		gameUIContainer.visible = false;
	}
	if (hitZoneLine) {
		hitZoneLine.visible = false;
	}
	if (shieldTimerDisplayContainer) {
		shieldTimerDisplayContainer.visible = false;
	}
	if (swipeToTapTimerDisplayContainer) {
		swipeToTapTimerDisplayContainer.visible = false;
	}
	initializeBossData(); // To także inicjalizuje/resetuje bossUnlockProgress dla testów
	var numberOfDefeated = getNumberOfDefeatedBosses();
	// console.log("Number of defeated bosses: " + numberOfDefeated); // Dla debugowania
	var screenElements = [];
	var tempSingleCardDisplayWidth = 400;
	var tempSingleCardDisplayHeight = 380;
	var tempSpacingBetweenCardsX = 80;
	var tempGroupHorizontalOffset = -60;
	var tempGroupVerticalOffset = -90;
	var tempPeekingCardVisibleSliceHeight = 80;
	var tempVerticalOffsetMainToPeeking = 140;
	var screenAreaContentWidth = tempSingleCardDisplayWidth * 2 + tempSpacingBetweenCardsX;
	var screenAreaContentHeight = tempSingleCardDisplayHeight + tempVerticalOffsetMainToPeeking + tempPeekingCardVisibleSliceHeight;
	var screenAreaX = (gameScreenWidth - screenAreaContentWidth) / 2 + tempGroupHorizontalOffset;
	var screenAreaY = gameScreenHeight / 2 + tempGroupVerticalOffset - tempSingleCardDisplayHeight / 2;
	if (cardsContainer && cardsContainer.parent) {
		cardsContainer.destroy();
	}
	cardsContainer = new Container();
	cardsContainer.x = screenAreaX;
	cardsContainer.y = screenAreaY;
	game.addChild(cardsContainer);
	screenElements.push(cardsContainer);
	displayBossCards(0, true, numberOfDefeated); // Przekazujemy numberOfDefeated
	var glassAsset = LK.getAsset('glass', {});
	glassAsset.x = 424;
	glassAsset.y = 886;
	glassAsset.width = 1180;
	glassAsset.height = 1200;
	glassAsset.alpha = 0.3;
	glassAsset.interactive = false;
	game.addChild(glassAsset);
	screenElements.push(glassAsset);
	var galleryBg = LK.getAsset('galleryBackground', {});
	galleryBg.width = gameScreenWidth;
	galleryBg.height = gameScreenHeight;
	galleryBg.x = 0;
	galleryBg.y = 0;
	game.addChild(galleryBg);
	screenElements.push(galleryBg);
	var upButton = LK.getAsset('upbutton', {});
	upButton.x = 210;
	upButton.y = gameScreenHeight / 2 - 180;
	upButton.anchor.set(0.5, 0.5);
	upButton.interactive = true;
	upButton.cursor = "pointer";
	upButton.down = function () {
		var newIndex = Math.max(0, currentBossViewStartIndex - 2);
		if (newIndex !== currentBossViewStartIndex) {
			displayBossCards(newIndex, false, getNumberOfDefeatedBosses()); // Ponownie pobieramy aktualną liczbę
		}
	};
	game.addChild(upButton);
	screenElements.push(upButton);
	var downButton = LK.getAsset('downbutton', {});
	downButton.x = 210;
	downButton.y = gameScreenHeight / 2 + 220;
	downButton.anchor.set(0.5, 0.5);
	downButton.interactive = true;
	downButton.cursor = "pointer";
	downButton.down = function () {
		var newIndex = currentBossViewStartIndex + 2;
		if (newIndex < allBossData.length) {
			// Upewnij się, że nie wyjdziemy poza zakres dla głównych kart
			var potentialMaxViewable = allBossData.length - 2; // Ostatni możliwy startowy index dla 2 kart
			if (currentBossViewStartIndex < potentialMaxViewable || allBossData.length % 2 !== 0 && newIndex < allBossData.length) {
				displayBossCards(newIndex, false, getNumberOfDefeatedBosses());
			} else if (newIndex >= allBossData.length - 1 && allBossData.length % 2 !== 0) {
				// Sytuacja gdy jest nieparzysta liczba bossów i chcemy wyświetlić ostatniego
				displayBossCards(allBossData.length - 1, false, getNumberOfDefeatedBosses());
			}
		}
	};
	game.addChild(downButton);
	screenElements.push(downButton);
	var playButton = LK.getAsset('play', {});
	playButton.x = gameScreenWidth - 350;
	playButton.y = gameScreenHeight / 2 - 240;
	playButton.anchor.set(0.5, 0.5);
	playButton.interactive = true;
	playButton.cursor = "pointer";
	playButton.down = function () {
		var selectedBossIndexGlobal = currentBossViewStartIndex + selectedCardSlotIndex;
		if (selectedBossIndexGlobal < 0 || selectedBossIndexGlobal >= allBossData.length) {
			console.log("Invalid selected boss index for play button.");
			return;
		}
		var selectedBossData = allBossData[selectedBossIndexGlobal];
		if (selectedBossData) {
			// Muzyka odtwarza się niezależnie od statusu odblokowania bossa
			if (currentlyPlayingMusic && typeof currentlyPlayingMusic.stop === 'function') {
				currentlyPlayingMusic.stop();
			}
			currentlyPlayingMusic = LK.getSound(selectedBossData.musicAssetKey);
			if (currentlyPlayingMusic && typeof currentlyPlayingMusic.play === 'function') {
				currentlyPlayingMusic.play();
			}
		}
	};
	game.addChild(playButton);
	screenElements.push(playButton);
	var stopButton = LK.getAsset('stop', {});
	stopButton.x = gameScreenWidth - 350;
	stopButton.y = gameScreenHeight / 2;
	stopButton.anchor.set(0.5, 0.5);
	stopButton.interactive = true;
	stopButton.cursor = "pointer";
	stopButton.down = function () {
		if (currentlyPlayingMusic && typeof currentlyPlayingMusic.stop === 'function') {
			currentlyPlayingMusic.stop();
			currentlyPlayingMusic = null;
		}
	};
	game.addChild(stopButton);
	screenElements.push(stopButton);
	var fightButton = LK.getAsset('fight', {});
	fightButton.x = gameScreenWidth - 350;
	fightButton.y = gameScreenHeight / 2 + 240;
	fightButton.anchor.set(0.5, 0.5);
	fightButton.interactive = true;
	fightButton.cursor = "pointer";
	fightButton.down = function () {
		var selectedBossIndexGlobal = currentBossViewStartIndex + selectedCardSlotIndex;
		if (selectedBossIndexGlobal < 0 || selectedBossIndexGlobal >= allBossData.length) {
			console.log("Invalid selected boss index for fight button.");
			return;
		}
		var selectedBossData = allBossData[selectedBossIndexGlobal];
		if (selectedBossData) {
			// Używamy statusu isUnlocked zapisanego w bossData przez displayBossCards
			if (selectedBossData.isUnlocked) {
				if (currentlyPlayingMusic && typeof currentlyPlayingMusic.stop === 'function') {
					currentlyPlayingMusic.stop();
					currentlyPlayingMusic = null;
				}
				screenElements.forEach(function (el) {
					if (el && el.parent) {
						el.destroy();
					}
				});
				screenElements = [];
				if (cardsContainer && cardsContainer.parent) {
					cardsContainer.destroy();
				}
				cardsContainer = null;
				loadSong(selectedBossData.songMapKey);
				currentScreenState = 'gameplay';
			} else {
				var requirementTextContent = "This boss is locked.";
				if (selectedBossData.defeatsRequired > 0) {
					var remainingDefeats = selectedBossData.defeatsRequired - getNumberOfDefeatedBosses();
					if (remainingDefeats > 0) {
						requirementTextContent = "Defeat " + remainingDefeats + (remainingDefeats === 1 ? " more boss" : " more bosses") + " to unlock!";
					} else {
						// Powinno być już odblokowane, ale na wszelki wypadek
						requirementTextContent = "This boss should be unlocked. Error?";
					}
				}
				var infoPopup = new Text2(requirementTextContent, {
					size: 80,
					fill: 0xe24203,
					stroke: 0x000000,
					strokeThickness: 2,
					align: 'center',
					wordWrap: true,
					wordWrapWidth: gameScreenWidth * 0.5,
					fontWeight: 'bold'
				});
				infoPopup.anchor.set(0.5, 0.5);
				infoPopup.x = gameScreenWidth / 2 - 90;
				infoPopup.y = gameScreenHeight / 2 - 900;
				game.addChild(infoPopup);
				LK.setTimeout(function () {
					if (infoPopup.parent) {
						infoPopup.destroy();
					}
				}, 3500);
			}
		}
	};
	game.addChild(fightButton);
	screenElements.push(fightButton);
	// Logika dla specjalnego bossa
	var actualDefeatedCount = getNumberOfDefeatedBosses(); // Użyj rzeczywistej liczby pokonanych
	var allStandardBossesDefeated = actualDefeatedCount === allBossData.length; // Zakładając, że allBossData zawiera tylko 8 standardowych bossów
	var specialBossButtonAssetKey = allStandardBossesDefeated ? 'specialboss_unlocked' : 'specialboss_locked';
	var specialBossButton = LK.getAsset(specialBossButtonAssetKey, {});
	specialBossButton.width = 400;
	specialBossButton.height = 370;
	specialBossButton.x = 950;
	specialBossButton.y = 1950;
	specialBossButton.anchor.set(0.5, 0.5);
	specialBossButton.interactive = true;
	if (allStandardBossesDefeated) {
		specialBossButton.cursor = "pointer";
		specialBossButton.down = function () {
			// Logika dla walki ze specjalnym bossem - DO UZUPEŁNIENIA
			console.log("Special Boss Fight Initiated!");
			var infoPopup = new Text2("Special Boss - Not Yet Implemented!", {
				size: 70,
				fill: 0x00FF00,
				stroke: 0x000000,
				strokeThickness: 2,
				align: 'center',
				wordWrap: true,
				wordWrapWidth: gameScreenWidth * 0.5
			});
			infoPopup.anchor.set(0.5, 0.5);
			infoPopup.x = gameScreenWidth / 2;
			infoPopup.y = gameScreenHeight / 2;
			game.addChild(infoPopup);
			LK.setTimeout(function () {
				if (infoPopup.parent) {
					infoPopup.destroy();
				}
			}, 3000);
			// if (currentlyPlayingMusic && typeof currentlyPlayingMusic.stop === 'function') {
			//     currentlyPlayingMusic.stop();
			//     currentlyPlayingMusic = null;
			// }
			// screenElements.forEach(function (el) { if (el && el.parent) { el.destroy(); } });
			// screenElements = [];
			// if (cardsContainer && cardsContainer.parent) { cardsContainer.destroy(); }
			// cardsContainer = null;
			// loadSong('specialBossSongMapKey'); // Potrzebujesz mapy dla specjalnego bossa
			// currentScreenState = 'gameplay';
		};
	} else {
		specialBossButton.cursor = "default";
		specialBossButton.down = function () {
			var infoPopup = new Text2("Defeat all other bosses (" + actualDefeatedCount + "/" + allBossData.length + ")\nto unlock!", {
				size: 70,
				fill: 0xe24203,
				stroke: 0x000000,
				strokeThickness: 2,
				align: 'center',
				wordWrap: true,
				wordWrapWidth: gameScreenWidth * 0.5
			});
			infoPopup.anchor.set(0.5, 0.5);
			infoPopup.x = gameScreenWidth / 2 - 90;
			infoPopup.y = gameScreenHeight / 2;
			game.addChild(infoPopup);
			LK.setTimeout(function () {
				if (infoPopup.parent) {
					infoPopup.destroy();
				}
			}, 3500);
		};
	}
	game.addChild(specialBossButton);
	screenElements.push(specialBossButton);
	var backToMainButton = new Text2("Back to Main Menu", {
		size: 50,
		fill: 0xDDDDDD
	});
	backToMainButton.anchor.set(0.5, 1);
	backToMainButton.x = gameScreenWidth / 2;
	backToMainButton.y = gameScreenHeight - 20;
	backToMainButton.interactive = true;
	backToMainButton.cursor = "pointer";
	backToMainButton.down = function () {
		if (currentlyPlayingMusic && typeof currentlyPlayingMusic.stop === 'function') {
			currentlyPlayingMusic.stop();
			currentlyPlayingMusic = null;
		}
		screenElements.forEach(function (el) {
			if (el && el.parent) {
				el.destroy();
			}
		});
		screenElements = [];
		if (cardsContainer && cardsContainer.parent) {
			cardsContainer.destroy();
		}
		cardsContainer = null;
		currentBossViewStartIndex = 0;
		selectedCardSlotIndex = 0;
		showMainMenu();
	};
	game.addChild(backToMainButton);
	screenElements.push(backToMainButton);
}
// Pamiętaj, aby wywołaċ initializeBossData(); gdzieś na początku, np. po deklaracjach zmiennych globalnych.
// Aby uruchomiċ ten ekran, wywołaj showBossSelectionScreen();
function showCreditsScreen() {
	currentScreenState = 'credits';
	if (gameUIContainer) {
		gameUIContainer.visible = false;
	}
	if (hitZoneLine) {
		hitZoneLine.visible = false;
	}
	game.setBackgroundColor(0x1a1a1a); // Ciemnoszary dla creditsów
	var elements = [];
	var creditsText = new Text2("Gra stworzona przez:\nNasz Wspaniały Duet!", {
		size: 90,
		fill: 0xFFFFFF,
		align: 'center' // Wyśrodkowanie tekstu wieloliniowego
	});
	creditsText.anchor.set(0.5, 0.5);
	creditsText.x = gameScreenWidth / 2;
	creditsText.y = gameScreenHeight / 2 - 100;
	game.addChild(creditsText);
	elements.push(creditsText);
	var backButton = new Text2("Back to Menu", {
		size: 80,
		fill: 0xCCCCCC
	});
	backButton.anchor.set(0.5, 0.5);
	backButton.x = gameScreenWidth / 2;
	backButton.y = gameScreenHeight - 200;
	backButton.interactive = true;
	backButton.cursor = "pointer";
	game.addChild(backButton);
	elements.push(backButton);
	backButton.down = function () {
		elements.forEach(function (item) {
			if (item.parent) {
				item.destroy();
			}
		});
		showMainMenu();
	};
}
function showIntro() {
	currentScreenState = 'intro';
	if (gameUIContainer) {
		gameUIContainer.visible = false;
	}
	if (hitZoneLine) {
		hitZoneLine.visible = false;
	}
	if (shieldTimerDisplayContainer) {
		shieldTimerDisplayContainer.visible = false;
	}
	if (swipeToTapTimerDisplayContainer) {
		swipeToTapTimerDisplayContainer.visible = false;
	}
	game.setBackgroundColor(0x111111);
	var introPlaceholderText = new Text2("Intro Sequence Placeholder", {
		size: 100,
		fill: 0xFFFFFF
	});
	introPlaceholderText.anchor.set(0.5, 0.5);
	introPlaceholderText.x = gameScreenWidth / 2;
	introPlaceholderText.y = gameScreenHeight / 2;
	game.addChild(introPlaceholderText);
	LK.setTimeout(function () {
		if (introPlaceholderText.parent) {
			introPlaceholderText.destroy();
		}
		showMainMenu(); // <<<< ZMIANA TUTAJ
	}, 1000);
}
function showTutorial() {
	currentScreenState = 'tutorial';
	if (gameUIContainer) {
		gameUIContainer.visible = false;
	}
	if (hitZoneLine) {
		hitZoneLine.visible = false;
	}
	if (shieldTimerDisplayContainer) {
		shieldTimerDisplayContainer.visible = false;
	} // Pozostawiam na wszelki wypadek
	if (swipeToTapTimerDisplayContainer) {
		swipeToTapTimerDisplayContainer.visible = false;
	} // Pozostawiam na wszelki wypadek
	game.setBackgroundColor(0x222222);
	var elements = [];
	var tutorialPlaceholderText = new Text2("Tutorial Placeholder\n(Tu będzie super tutorial!)", {
		size: 100,
		fill: 0xFFFFFF,
		align: 'center'
	});
	tutorialPlaceholderText.anchor.set(0.5, 0.5);
	tutorialPlaceholderText.x = gameScreenWidth / 2;
	tutorialPlaceholderText.y = gameScreenHeight / 2 - 100;
	game.addChild(tutorialPlaceholderText);
	elements.push(tutorialPlaceholderText);
	var backButton = new Text2("Back to Menu", {
		size: 80,
		fill: 0xCCCCCC
	});
	backButton.anchor.set(0.5, 0.5);
	backButton.x = gameScreenWidth / 2;
	backButton.y = gameScreenHeight - 200;
	backButton.interactive = true;
	backButton.cursor = "pointer";
	game.addChild(backButton);
	elements.push(backButton);
	backButton.down = function () {
		elements.forEach(function (item) {
			if (item.parent) {
				item.destroy();
			}
		});
		showMainMenu();
	};
}
var currentScreenState = '';
var mainMenuScreenElements = [];
var mainMenuItemTextObjects = [];
var mainMenuItems = ["Music Battle", "How To Play", "Credits", "Stats"]; // "Stats" dodane jako nowa opcja
var selectedMainMenuItemIndex = 0;
var gameScreenWidth = 2048;
var gameScreenHeight = Math.round(gameScreenWidth * (2732 / 2048)); // iPad-like proportions
var playfieldWidth = 1408;
var playfieldStartX = (gameScreenWidth - playfieldWidth) / 2;
var NUM_COLUMNS = 3;
var columnWidth = playfieldWidth / NUM_COLUMNS;
var columnCenterXs = [];
for (var i = 0; i < NUM_COLUMNS; i++) {
	columnCenterXs.push(playfieldStartX + i * columnWidth + columnWidth / 2);
}
var SWIPE_NOTE_WIDTH = 180;
// HP System Variables
var playerMaxHP = 10;
var playerCurrentHP = 10;
var bossMaxHP = 30;
var bossCurrentHP = 30;
var gameOverFlag = false;
// HP Bar UI Elements Configuration (actual elements created in setupHpBars)
var hpBarWidth = 400;
var hpBarHeight = 30;
// UI Container
var gameUIContainer; // Declare gameUIContainer
// HP Bar Containers (will be initialized in setupHpBars)
var playerHpBarContainer;
var playerHpBarFill;
var bossHpBarContainer;
var bossHpBarFill;
var POWERUP_SPAWN_INTERVAL = 2000; // Co 6 sekund
var lastPowerUpSpawnAttemptTime = 0;
var POWERUP_SPAWN_CHANCE = 0.15; // 15% szansy
var POTION_HEAL_AMOUNT = 2;
var activePowerUpItems = [];
var SHIELD_DURATION = 6000;
var isShieldActive = false;
var shieldEndTime = 0;
var SWIPE_TO_TAP_BUFF_DURATION = 5000; // Czas trwania buffa w ms (5 sekund)
var isSwipeToTapBuffActive = false;
var swipeToTapBuffEndTime = 0;
var shieldTimerDisplayContainer;
var smallShieldIconDisplay;
var shieldTimerTextDisplay;
var shieldTimerDisplayContainer;
var smallShieldIconDisplay;
var shieldTimerTextDisplay;
var swipeToTapTimerDisplayContainer; // Kontener na ikonkę timera i tekst dla buffa
var smallSwipeToTapIconDisplay; // Mniejsza ikonka buffa dla timera
var swipeToTapTimerTextDisplay;
var currentBossSprite;
var powerUpDisplayContainer; // Główny kontener na UI power-upów
var hpPotionIcon, shieldIcon, swipeToTapIcon; // Referencje do ikon
var hpPotionCountText, shieldCountText, swipeToTapCountText; // Referencje do tekstów z ilością
var collectedPowerUps = {
	potion: 0,
	shield: 0,
	swipeToTap: 0 // Klucz 'swipeToTap' dla spójności
};
// Game State & Rhythm Logic Variables
var allSongData = {
	"OrctaveBossTrack": {
		musicAsset: "Orctave",
		// Upewnij się, że masz asset muzyczny o tym kluczu
		bossAssetKey: 'Boss1_Asset',
		// Asset dla pierwszego bossa
		config: {
			playerMaxHP: 100,
			bossMaxHP: 200
		},
		rawRhythmMap: [{
			time: 8000,
			type: 'tap',
			columnIndex: 0
		}, {
			time: 8210,
			type: 'tap',
			columnIndex: 1
		}, {
			time: 8401,
			type: 'tap',
			columnIndex: 2
		}, {
			time: 8596,
			type: 'tap',
			columnIndex: 0
		}, {
			time: 8795,
			type: 'tap',
			columnIndex: 1
		}, {
			time: 9117,
			type: 'tap',
			columnIndex: 2
		}, {
			time: 9832,
			type: 'swipe',
			columnIndex: 0,
			swipeDir: 'right'
		}, {
			time: 10536,
			type: 'swipe',
			columnIndex: 0,
			swipeDir: 'right'
		}, {
			time: 11245,
			type: 'swipe',
			columnIndex: 0,
			swipeDir: 'right'
		}, {
			time: 11888,
			type: 'swipe',
			columnIndex: 2,
			swipeDir: 'left'
		}, {
			time: 12628,
			type: 'swipe',
			columnIndex: 2,
			swipeDir: 'left'
		}, {
			time: 13308,
			type: 'swipe',
			columnIndex: 2,
			swipeDir: 'left'
		}, {
			time: 13986,
			type: 'swipe',
			columnIndex: 2,
			swipeDir: 'left'
		}, {
			time: 14696,
			type: 'tap',
			columnIndex: 2
		}, {
			time: 15456,
			type: 'tap',
			columnIndex: 2
		}, {
			time: 16140,
			type: 'tap',
			columnIndex: 1
		}, {
			time: 16863,
			type: 'tap',
			columnIndex: 1
		}, {
			time: 17547,
			type: 'tap',
			columnIndex: 0
		}, {
			time: 18275,
			type: 'tap',
			columnIndex: 0
		}, {
			time: 18955,
			type: 'tap',
			columnIndex: 0
		}, {
			time: 19670,
			type: 'tap',
			columnIndex: 0
		}, {
			time: 20333,
			type: 'tap',
			columnIndex: 1
		}, {
			time: 20740,
			type: 'tap',
			columnIndex: 2
		}, {
			time: 21063,
			type: 'tap',
			columnIndex: 1
		}, {
			time: 21411,
			type: 'tap',
			columnIndex: 0
		}, {
			time: 21742,
			type: 'tap',
			columnIndex: 1
		}, {
			time: 22110,
			type: 'tap',
			columnIndex: 2
		}, {
			time: 22463,
			type: 'tap',
			columnIndex: 1
		}, {
			time: 22797,
			type: 'tap',
			columnIndex: 0
		}, {
			time: 23336,
			type: 'tap',
			columnIndex: 2
		}, {
			time: 26163,
			type: 'swipe',
			columnIndex: 0,
			swipeDir: 'right'
		}, {
			time: 26737,
			type: 'swipe',
			columnIndex: 2,
			swipeDir: 'left'
		}, {
			time: 27351,
			type: 'swipe',
			columnIndex: 0,
			swipeDir: 'right'
		}, {
			time: 27764,
			type: 'swipe',
			columnIndex: 0,
			swipeDir: 'right'
		}, {
			time: 28116,
			type: 'swipe',
			columnIndex: 2,
			swipeDir: 'left'
		}, {
			time: 28827,
			type: 'swipe',
			columnIndex: 1,
			swipeDir: 'right'
		}, {
			time: 29546,
			type: 'swipe',
			columnIndex: 0,
			swipeDir: 'left'
		}, {
			time: 30102,
			type: 'swipe',
			columnIndex: 1,
			swipeDir: 'right'
		}, {
			time: 30534,
			type: 'swipe',
			columnIndex: 1,
			swipeDir: 'right'
		}, {
			time: 30931,
			type: 'swipe',
			columnIndex: 0,
			swipeDir: 'left'
		}, {
			time: 31677,
			type: 'tap',
			columnIndex: 2
		}, {
			time: 32392,
			type: 'tap',
			columnIndex: 1
		}, {
			time: 32989,
			type: 'tap',
			columnIndex: 2
		}, {
			time: 33386,
			type: 'tap',
			columnIndex: 2
		}, {
			time: 33781,
			type: 'tap',
			columnIndex: 1
		}, {
			time: 34568,
			type: 'tap',
			columnIndex: 2
		}, {
			time: 35234,
			type: 'tap',
			columnIndex: 1
		}, {
			time: 35749,
			type: 'tap',
			columnIndex: 2
		}, {
			time: 36182,
			type: 'tap',
			columnIndex: 2
		}, {
			time: 36583,
			type: 'tap',
			columnIndex: 0
		}, {
			time: 37302,
			type: 'tap',
			columnIndex: 0
		}, {
			time: 37681,
			type: 'tap',
			columnIndex: 1
		}, {
			time: 38033,
			type: 'tap',
			columnIndex: 2
		}, {
			time: 38354,
			type: 'tap',
			columnIndex: 2
		}, {
			time: 38721,
			type: 'tap',
			columnIndex: 1
		}, {
			time: 39067,
			type: 'tap',
			columnIndex: 0
		}, {
			time: 39471,
			type: 'tap',
			columnIndex: 1
		}, {
			time: 39821,
			type: 'tap',
			columnIndex: 2
		}, {
			time: 40164,
			type: 'tap',
			columnIndex: 1
		}, {
			time: 40488,
			type: 'tap',
			columnIndex: 0
		}, {
			time: 40861,
			type: 'tap',
			columnIndex: 0
		}, {
			time: 41250,
			type: 'tap',
			columnIndex: 1
		}, {
			time: 41609,
			type: 'tap',
			columnIndex: 2
		}, {
			time: 41946,
			type: 'tap',
			columnIndex: 1
		}, {
			time: 42290,
			type: 'tap',
			columnIndex: 0
		}, {
			time: 42643,
			type: 'tap',
			columnIndex: 2
		}, {
			time: 43068,
			type: 'tap',
			columnIndex: 1
		}, {
			time: 43379,
			type: 'tap',
			columnIndex: 2
		}, {
			time: 43726,
			type: 'tap',
			columnIndex: 1
		}, {
			time: 44078,
			type: 'tap',
			columnIndex: 2
		}, {
			time: 44414,
			type: 'tap',
			columnIndex: 1
		}, {
			time: 44728,
			type: 'tap',
			columnIndex: 2
		}, {
			time: 45115,
			type: 'tap',
			columnIndex: 1
		}, {
			time: 45475,
			type: 'tap',
			columnIndex: 2
		}, {
			time: 45809,
			type: 'tap',
			columnIndex: 0
		}, {
			time: 46199,
			type: 'tap',
			columnIndex: 1
		}, {
			time: 46521,
			type: 'tap',
			columnIndex: 2
		}, {
			time: 46855,
			type: 'tap',
			columnIndex: 1
		}, {
			time: 47190,
			type: 'tap',
			columnIndex: 0
		}, {
			time: 47535,
			type: 'tap',
			columnIndex: 2
		}, {
			time: 47874,
			type: 'tap',
			columnIndex: 1
		}, {
			time: 48252,
			type: 'tap',
			columnIndex: 2
		}, {
			time: 51448,
			type: 'swipe',
			columnIndex: 2,
			swipeDir: 'left'
		}, {
			time: 52112,
			type: 'swipe',
			columnIndex: 2,
			swipeDir: 'left'
		}, {
			time: 52853,
			type: 'swipe',
			columnIndex: 2,
			swipeDir: 'left'
		}, {
			time: 53536,
			type: 'swipe',
			columnIndex: 2,
			swipeDir: 'left'
		}, {
			time: 54251,
			type: 'swipe',
			columnIndex: 0,
			swipeDir: 'right'
		}, {
			time: 54964,
			type: 'swipe',
			columnIndex: 0,
			swipeDir: 'right'
		}, {
			time: 55618,
			type: 'swipe',
			columnIndex: 0,
			swipeDir: 'right'
		}, {
			time: 56339,
			type: 'swipe',
			columnIndex: 0,
			swipeDir: 'right'
		}, {
			time: 57058,
			type: 'swipe',
			columnIndex: 1,
			swipeDir: 'left'
		}, {
			time: 57799,
			type: 'swipe',
			columnIndex: 1,
			swipeDir: 'left'
		}, {
			time: 58512,
			type: 'swipe',
			columnIndex: 1,
			swipeDir: 'left'
		}, {
			time: 59170,
			type: 'swipe',
			columnIndex: 1,
			swipeDir: 'left'
		}, {
			time: 59911,
			type: 'swipe',
			columnIndex: 2,
			swipeDir: 'right'
		}, {
			time: 60668,
			type: 'tap',
			columnIndex: 2
		}, {
			time: 61334,
			type: 'swipe',
			columnIndex: 2,
			swipeDir: 'right'
		}, {
			time: 62084,
			type: 'tap',
			columnIndex: 2
		}, {
			time: 62744,
			type: 'swipe',
			columnIndex: 2,
			swipeDir: 'right'
		}, {
			time: 63445,
			type: 'tap',
			columnIndex: 2
		}, {
			time: 64134,
			type: 'swipe',
			columnIndex: 1,
			swipeDir: 'left'
		}, {
			time: 64827,
			type: 'tap',
			columnIndex: 1
		}, {
			time: 65532,
			type: 'swipe',
			columnIndex: 1,
			swipeDir: 'left'
		}, {
			time: 66199,
			type: 'tap',
			columnIndex: 1
		}, {
			time: 66921,
			type: 'swipe',
			columnIndex: 1,
			swipeDir: 'left'
		}, {
			time: 67679,
			type: 'tap',
			columnIndex: 1
		}, {
			time: 68353,
			type: 'swipe',
			columnIndex: 0,
			swipeDir: 'right'
		}, {
			time: 69005,
			type: 'tap',
			columnIndex: 0
		}, {
			time: 69772,
			type: 'swipe',
			columnIndex: 0,
			swipeDir: 'right'
		}, {
			time: 70457,
			type: 'tap',
			columnIndex: 0
		}, {
			time: 71178,
			type: 'swipe',
			columnIndex: 1,
			swipeDir: 'left'
		}, {
			time: 71892,
			type: 'swipe',
			columnIndex: 2,
			swipeDir: 'right'
		}, {
			time: 72585,
			type: 'swipe',
			columnIndex: 1,
			swipeDir: 'left'
		}, {
			time: 73287,
			type: 'swipe',
			columnIndex: 0,
			swipeDir: 'right'
		}, {
			time: 74094,
			type: 'tap',
			columnIndex: 2
		}, {
			time: 75031,
			type: 'tap',
			columnIndex: 1
		}, {
			time: 75469,
			type: 'tap',
			columnIndex: 2
		}, {
			time: 75831,
			type: 'tap',
			columnIndex: 2
		}, {
			time: 76181,
			type: 'tap',
			columnIndex: 1
		}, {
			time: 76909,
			type: 'tap',
			columnIndex: 0
		}, {
			time: 77641,
			type: 'tap',
			columnIndex: 1
		}, {
			time: 78208,
			type: 'tap',
			columnIndex: 2
		}, {
			time: 78675,
			type: 'tap',
			columnIndex: 2
		}, {
			time: 79001,
			type: 'tap',
			columnIndex: 1
		}, {
			time: 79743,
			type: 'tap',
			columnIndex: 0
		}, {
			time: 80401,
			type: 'tap',
			columnIndex: 1
		}, {
			time: 80982,
			type: 'tap',
			columnIndex: 0
		}, {
			time: 81387,
			type: 'tap',
			columnIndex: 0
		}, {
			time: 81769,
			type: 'tap',
			columnIndex: 1
		}, {
			time: 82537,
			type: 'tap',
			columnIndex: 2
		}, {
			time: 83216,
			type: 'tap',
			columnIndex: 1
		}, {
			time: 83789,
			type: 'tap',
			columnIndex: 0
		}, {
			time: 84229,
			type: 'tap',
			columnIndex: 0
		}, {
			time: 84566,
			type: 'tap',
			columnIndex: 0
		}, {
			time: 84923,
			type: 'tap',
			columnIndex: 0
		}, {
			time: 85105,
			type: 'tap',
			columnIndex: 0
		}, {
			time: 85305,
			type: 'tap',
			columnIndex: 1
		}]
	}
};
var currentActiveRhythmMap = null;
var currentMusic = null;
var noteTravelTime = 3200;
var hitWindowPerfect = 220;
var hitWindowGood = 270;
var MIN_SWIPE_DISTANCE = 60;
var notes = [];
var nextNoteIdx = 0;
var gameStartTime = 0;
var score = 0;
var bossWasDefeatedThisSong = false;
var songSummaryContainer = null;
var bossUnlockProgress = {};
var GAME_SCORES_KEY = 'walkmanFighters_scores';
var BOSS_UNLOCK_KEY = 'walkmanFighters_bossUnlock';
var currentFightingBossId = null;
var lastPlayedSongKeyForRestart = null;
var combo = 0;
var maxCombo = 0;
var swipeStart = null;
var inputLocked = false;
var hpBarsInitialized = false;
// Initialize and add gameUIContainer to the game scene
gameUIContainer = new Container();
game.addChild(gameUIContainer);
// Function to process raw rhythm map data (remains unchanged, ensure it's here)
function processRawRhythmMap(rawMapData, songKeyForLogging) {
	console.log("Processing raw map for: " + songKeyForLogging + " with " + rawMapData.length + " initial notes.");
	var processedMap = [];
	var tempMap = [];
	for (var k = 0; k < rawMapData.length; k++) {
		var originalNote = rawMapData[k];
		var copiedNote = {};
		for (var key in originalNote) {
			if (originalNote.hasOwnProperty(key)) {
				copiedNote[key] = originalNote[key];
			}
		}
		tempMap.push(copiedNote);
	}
	for (var i = 0; i < tempMap.length; i++) {
		var note = tempMap[i];
		if (note.type === 'swipe' && note.swipeDir) {
			var dir = note.swipeDir.toLowerCase();
			if (dir.includes('right')) {
				note.swipeDir = 'right';
			} else if (dir.includes('left')) {
				note.swipeDir = 'left';
			} else if (dir.includes('up')) {
				note.swipeDir = 'up';
			} else if (dir.includes('down')) {
				note.swipeDir = 'down';
			}
		}
	}
	var timeGroupedNotes = {};
	tempMap.forEach(function (note) {
		if (!timeGroupedNotes[note.time]) {
			timeGroupedNotes[note.time] = [];
		}
		timeGroupedNotes[note.time].push(note);
	});
	var finalMapNotes = [];
	var sortedTimes = Object.keys(timeGroupedNotes).map(Number).sort(function (a, b) {
		return a - b;
	});
	for (var tIdx = 0; tIdx < sortedTimes.length; tIdx++) {
		var time = sortedTimes[tIdx];
		var notesAtThisTime = timeGroupedNotes[time];
		var notesToKeepAtThisTime = [];
		var processedForWiderSwipeConversion = [];
		var colsWithVerticalSwipes = [null, null, null, null];
		notesAtThisTime.forEach(function (note) {
			if (note.type === 'swipe' && (note.swipeDir === 'up' || note.swipeDir === 'down')) {
				if (note.columnIndex >= 0 && note.columnIndex < NUM_COLUMNS) {
					var alreadyConverted = false;
					for (var convIdx = 0; convIdx < processedForWiderSwipeConversion.length; convIdx++) {
						if (processedForWiderSwipeConversion[convIdx].originalTime === note.time && processedForWiderSwipeConversion[convIdx].originalColumn === note.columnIndex) {
							alreadyConverted = true;
							break;
						}
					}
					if (!alreadyConverted) {
						colsWithVerticalSwipes[note.columnIndex] = note.swipeDir;
					}
				}
			}
		});
		for (var c = 0; c < NUM_COLUMNS - 1; c++) {
			if (colsWithVerticalSwipes[c] && colsWithVerticalSwipes[c + 1] && colsWithVerticalSwipes[c] === colsWithVerticalSwipes[c + 1]) {
				var randomHorizontalDir = Math.random() < 0.5 ? 'left' : 'right';
				var pairCenterX = (columnCenterXs[c] + columnCenterXs[c + 1]) / 2;
				notesToKeepAtThisTime.push({
					time: time,
					type: 'swipe',
					swipeDir: randomHorizontalDir,
					partOfWiderSwipe: 'leftHalf',
					widerSwipePairCenterX: pairCenterX,
					originalColumnHint: c
				});
				notesToKeepAtThisTime.push({
					time: time,
					type: 'swipe',
					swipeDir: randomHorizontalDir,
					partOfWiderSwipe: 'rightHalf',
					widerSwipePairCenterX: pairCenterX,
					originalColumnHint: c + 1
				});
				processedForWiderSwipeConversion.push({
					originalTime: time,
					originalColumn: c
				});
				processedForWiderSwipeConversion.push({
					originalTime: time,
					originalColumn: c + 1
				});
				colsWithVerticalSwipes[c] = null;
				colsWithVerticalSwipes[c + 1] = null;
				c++;
			}
		}
		notesAtThisTime.forEach(function (note) {
			var wasConverted = false;
			for (var convIdx = 0; convIdx < processedForWiderSwipeConversion.length; convIdx++) {
				if (processedForWiderSwipeConversion[convIdx].originalTime === note.time && processedForWiderSwipeConversion[convIdx].originalColumn === note.columnIndex && (note.swipeDir === 'up' || note.swipeDir === 'down')) {
					wasConverted = true;
					break;
				}
			}
			if (!wasConverted) {
				notesToKeepAtThisTime.push(note);
			}
		});
		var horizontalWiderSwipePairs = {};
		var notesForFinalProcessing = [];
		var uniqueNotesAtThisTime = [];
		var seenNotesKeysAtThisTime = {};
		notesToKeepAtThisTime.forEach(function (note) {
			var key = "" + note.type + "_" + (note.columnIndex !== undefined ? note.columnIndex : note.partOfWiderSwipe ? note.widerSwipePairCenterX + note.partOfWiderSwipe : '') + "_" + (note.swipeDir || '');
			if (!seenNotesKeysAtThisTime[key]) {
				uniqueNotesAtThisTime.push(note);
				seenNotesKeysAtThisTime[key] = true;
			}
		});
		uniqueNotesAtThisTime.sort(function (a, b) {
			var valA = a.originalColumnHint !== undefined ? a.originalColumnHint : a.columnIndex !== undefined ? a.columnIndex : a.widerSwipePairCenterX || 0;
			var valB = b.originalColumnHint !== undefined ? b.originalColumnHint : b.columnIndex !== undefined ? b.columnIndex : b.widerSwipePairCenterX || 0;
			return valA - valB;
		});
		for (var nIdx = 0; nIdx < uniqueNotesAtThisTime.length; nIdx++) {
			var note = uniqueNotesAtThisTime[nIdx];
			if (note.partOfWiderSwipe) {
				notesForFinalProcessing.push(note);
				continue;
			}
			var potentialPartner = null;
			if (nIdx + 1 < uniqueNotesAtThisTime.length) {
				potentialPartner = uniqueNotesAtThisTime[nIdx + 1];
			}
			if (note.type === 'swipe' && (note.swipeDir === 'left' || note.swipeDir === 'right') && potentialPartner && potentialPartner.type === 'swipe' && potentialPartner.time === note.time && potentialPartner.swipeDir === note.swipeDir && potentialPartner.columnIndex === note.columnIndex + 1) {
				var pairCenterX = (columnCenterXs[note.columnIndex] + columnCenterXs[potentialPartner.columnIndex]) / 2;
				notesForFinalProcessing.push({
					time: note.time,
					type: 'swipe',
					swipeDir: note.swipeDir,
					partOfWiderSwipe: 'leftHalf',
					widerSwipePairCenterX: pairCenterX,
					originalColumnHint: note.columnIndex
				});
				notesForFinalProcessing.push({
					time: potentialPartner.time,
					type: 'swipe',
					swipeDir: potentialPartner.swipeDir,
					partOfWiderSwipe: 'rightHalf',
					widerSwipePairCenterX: pairCenterX,
					originalColumnHint: potentialPartner.columnIndex
				});
				nIdx++;
			} else {
				notesForFinalProcessing.push(note);
			}
		}
		finalMapNotes.push.apply(finalMapNotes, notesForFinalProcessing);
	}
	var uniqueNotesOverall = [];
	var seenNotesOverall = {};
	finalMapNotes.sort(function (a, b) {
		return a.time - b.time;
	});
	finalMapNotes.forEach(function (note) {
		var cX;
		var keyPartForColumn;
		if (note.partOfWiderSwipe) {
			cX = note.widerSwipePairCenterX + (note.partOfWiderSwipe === 'leftHalf' ? -(SWIPE_NOTE_WIDTH / 2) : SWIPE_NOTE_WIDTH / 2);
			keyPartForColumn = "pC" + note.widerSwipePairCenterX + "h" + (note.partOfWiderSwipe === 'leftHalf' ? 'L' : 'R');
		} else if (note.columnIndex !== undefined) {
			cX = columnCenterXs[note.columnIndex];
			keyPartForColumn = "c" + note.columnIndex;
		} else {
			cX = gameScreenWidth / 2;
			keyPartForColumn = "cX" + cX;
		}
		var key = "" + note.time + "_" + note.type + "_" + keyPartForColumn + "_" + (note.swipeDir || '');
		if (!seenNotesOverall[key]) {
			uniqueNotesOverall.push(note);
			seenNotesOverall[key] = true;
		} else {
			// console.log("Filtered final duplicate note: " + key);
		}
	});
	console.log("Processed map for: " + songKeyForLogging + " FINALLY contains " + uniqueNotesOverall.length + " notes.");
	return uniqueNotesOverall;
}
var hpBarsInitialized = false;
var scoreTxt = new Text2('Score: 0', {
	size: 100,
	fill: 0xFFFFFF,
	alpha: 1
});
scoreTxt.anchor.set(1, 0); // Anchor center-top
scoreTxt.x = gameScreenWidth / 1;
scoreTxt.y = 20; // Position from the top of its container (gameUIContainer)
gameUIContainer.addChild(scoreTxt);
console.log("Restored scoreTxt: X=" + scoreTxt.x + " Y=" + scoreTxt.y + " Visible:" + scoreTxt.visible + " Parent: gameUIContainer");
var comboTxt = new Text2('Combo: 0', {
	size: 50,
	// Możesz dostosować rozmiar tekstu combo
	fill: 0xFFFF00,
	// Żółty kolor
	alpha: 0.5
});
comboTxt.anchor.set(0, 0.5);
comboTxt.x = 100;
comboTxt.y = 1000;
comboTxt.rotation = -0.26;
gameUIContainer.addChild(comboTxt);
console.log("ComboTxt positioned: X=" + comboTxt.x + " Y=" + comboTxt.y + " Visible:" + comboTxt.visible + " Parent: gameUIContainer");
var hitZoneY = 1800;
var hitZoneVisualWidth = playfieldWidth;
var hitZoneLine = LK.getAsset('lineAsset', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: gameScreenWidth / 2,
	y: hitZoneY,
	width: hitZoneVisualWidth,
	height: 4,
	alpha: 0.6
});
game.addChild(hitZoneLine);
function rectsIntersect(r1, r2) {
	return !(r2.x > r1.x + r1.width || r2.x + r2.width < r1.x || r2.y > r1.y + r1.height || r2.y + r2.height < r1.y);
}
function resetGameState() {
	notes.forEach(function (n) {
		if (n && n.parent) {
			n.destroy();
		}
	});
	notes = [];
	nextNoteIdx = 0;
	score = 0;
	combo = 0;
	maxCombo = 0;
	swipeStart = null;
	inputLocked = false;
	scoreTxt.setText('Score: 0');
	comboTxt.setText('Combo: 0');
	gameOverFlag = false;
	playerCurrentHP = playerMaxHP;
	bossCurrentHP = bossMaxHP;
	collectedPowerUps.potion = 0;
	collectedPowerUps.shield = 0;
	collectedPowerUps.swipeToTap = 0;
	hpBarsInitialized = false;
	if (hpBarsInitialized) {
		updatePowerUpDisplayCounts();
	}
	if (isShieldActive) {
		isShieldActive = false;
		if (shieldIcon) {
			shieldIcon.alpha = 1.0;
		}
	}
	if (shieldTimerDisplayContainer) {
		shieldTimerDisplayContainer.visible = false;
	}
	if (isSwipeToTapBuffActive) {
		isSwipeToTapBuffActive = false;
		if (swipeToTapIcon) {
			swipeToTapIcon.alpha = 1.0;
		}
	}
	// NOWE: Ukryj timer buffa Swipe-to-Tap przy resecie
	if (swipeToTapTimerDisplayContainer) {
		swipeToTapTimerDisplayContainer.visible = false;
	}
	// Koniec NOWE
	if (playerHpBarFill && bossHpBarFill) {
		updatePlayerHpDisplay();
		updateBossHpDisplay();
	}
}
function loadSong(songKey) {
	if (songSummaryContainer && songSummaryContainer.parent) {
		songSummaryContainer.destroy();
		songSummaryContainer = null;
	}
	if (gameUIContainer) {
		gameUIContainer.visible = true;
	}
	if (hitZoneLine) {
		hitZoneLine.visible = true;
	}
	lastPlayedSongKeyForRestart = songKey;
	bossWasDefeatedThisSong = false;
	var songData = allSongData[songKey];
	if (!songData) {
		console.log("Error: Song data not found for key: " + songKey);
		if (allSongData["defaultTestTrack"]) {
			songData = allSongData["defaultTestTrack"];
			console.log("Fallback to defaultTestTrack");
		} else {
			currentActiveRhythmMap = [];
			console.log("No fallback song data found.");
			return;
		}
	}
	// <<<< POCZĄTEK DODANEGO FRAGMENTU >>>>
	currentFightingBossId = null;
	for (var i = 0; i < allBossData.length; i++) {
		if (allBossData[i].songMapKey === songKey) {
			currentFightingBossId = allBossData[i].id;
			break;
		}
	}
	// console.log("Current fighting boss ID for song " + songKey + ": " + currentFightingBossId);
	// <<<< KONIEC DODANEGO FRAGMENTU >>>>
	if (songData.config) {
		playerMaxHP = songData.config.playerMaxHP || 10;
		bossMaxHP = songData.config.bossMaxHP || 50;
	} else {
		playerMaxHP = 10;
		bossMaxHP = 50;
	}
	if (currentMusic && typeof currentMusic.stop === 'function') {
		currentMusic.stop();
	}
	currentMusic = null;
	resetGameState();
	if (gameUIContainer) {
		gameUIContainer.visible = true;
	}
	hpBarsInitialized = false;
	nextNoteIdx = 0;
	if (currentBossSprite && currentBossSprite.parent) {
		currentBossSprite.destroy();
		currentBossSprite = null;
	}
	if (songData.bossAssetKey) {
		currentBossSprite = LK.getAsset(songData.bossAssetKey, {
			anchorX: 0.5,
			anchorY: 0.5
		});
		currentBossSprite.x = gameScreenWidth / 2;
		currentBossSprite.y = 350;
		currentBossSprite.alpha = 0.8;
		game.addChildAt(currentBossSprite, 0);
		console.log("Boss sprite '" + songData.bossAssetKey + "' loaded and added to scene.");
	} else {
		console.log("No bossAssetKey defined for song: " + songKey);
	}
	if (songData.rawRhythmMap) {
		currentActiveRhythmMap = processRawRhythmMap(songData.rawRhythmMap, songKey);
	} else {
		currentActiveRhythmMap = [];
		console.log("Warning: No rawRhythmMap for song: " + songKey + ". Game will have no notes.");
	}
	gameStartTime = Date.now();
	if (songData.musicAsset) {
		currentMusic = LK.getSound(songData.musicAsset);
		if (currentMusic && typeof currentMusic.play === 'function') {
			currentMusic.play();
			console.log("Music asset for " + songKey + " PLAYING. gameStartTime: " + gameStartTime);
		} else {
			console.log("Warning: Music asset '" + songData.musicAsset + "' not found or not playable.");
		}
	} else {
		console.log("No musicAsset defined for " + songKey + ". Map will run on system time only.");
	}
	console.log("Loaded and processed song: " + songKey + " PlayerHP: " + playerMaxHP + " BossHP: " + bossMaxHP);
	currentScreenState = 'gameplay';
}
function setupHpBars() {
	if (bossHpBarContainer) {
		bossHpBarContainer.destroy();
	}
	bossHpBarContainer = new Container();
	bossHpBarContainer.x = gameScreenWidth / 2;
	bossHpBarContainer.y = 100; // Adjusted Y slightly lower than scoreTxt for clarity
	gameUIContainer.addChild(bossHpBarContainer); // Add to gameUIContainer
	var bossBg = LK.getAsset('hpBarBackground', {
		width: hpBarWidth,
		height: hpBarHeight,
		anchorX: 0.5,
		anchorY: 0.5
	});
	bossHpBarContainer.addChild(bossBg);
	bossHpBarFill = LK.getAsset('bossHpFill', {
		width: hpBarWidth,
		height: hpBarHeight,
		anchorX: 0,
		anchorY: 0.5,
		x: -hpBarWidth / 2
	});
	bossHpBarContainer.addChild(bossHpBarFill);
	if (playerHpBarContainer) {
		playerHpBarContainer.destroy();
	}
	playerHpBarContainer = new Container();
	playerHpBarContainer.x = gameScreenWidth / 2;
	playerHpBarContainer.y = gameScreenHeight - 80;
	gameUIContainer.addChild(playerHpBarContainer); // Add to gameUIContainer
	var playerBg = LK.getAsset('hpBarBackground', {
		width: hpBarWidth,
		height: hpBarHeight,
		anchorX: 0.5,
		anchorY: 0.5
	});
	playerHpBarContainer.addChild(playerBg);
	playerHpBarFill = LK.getAsset('playerHpFill', {
		width: hpBarWidth,
		height: hpBarHeight,
		anchorX: 0,
		anchorY: 0.5,
		x: -hpBarWidth / 2
	});
	playerHpBarContainer.addChild(playerHpBarFill);
	updateBossHpDisplay();
	updatePlayerHpDisplay();
	console.log("HP Bars setup and added to gameUIContainer. PlayerHP Y: " + playerHpBarContainer.y + " BossHP Y: " + bossHpBarContainer.y);
}
function setupPowerUpDisplay() {
	powerUpDisplayContainer = new Container();
	powerUpDisplayContainer.x = gameScreenWidth / 2;
	powerUpDisplayContainer.y = 2450; // Twoja ustawiona wartość
	gameUIContainer.addChild(powerUpDisplayContainer);
	var iconSize = 150; // Twoja ustawiona wartość
	var iconSpacing = 450; // Twoja ustawiona wartość
	var textOffsetY = iconSize / 2 + 15;
	// 1. Mikstura HP (bez zmian)
	hpPotionIcon = LK.getAsset('hpPotionAsset', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: iconSize,
		height: iconSize * 1.2
	});
	hpPotionIcon.x = -iconSpacing;
	powerUpDisplayContainer.addChild(hpPotionIcon);
	hpPotionCountText = new Text2("x0", {
		size: 40,
		fill: 0xFFFFFF,
		anchorX: 0.5,
		anchorY: 0
	});
	hpPotionCountText.x = hpPotionIcon.x;
	hpPotionCountText.y = textOffsetY;
	powerUpDisplayContainer.addChild(hpPotionCountText);
	hpPotionIcon.interactive = true;
	hpPotionIcon.down = function () {
		if (collectedPowerUps.potion > 0 && !gameOverFlag) {
			collectedPowerUps.potion--;
			updatePowerUpDisplayCounts();
			playerCurrentHP += POTION_HEAL_AMOUNT;
			if (playerCurrentHP > playerMaxHP) {
				playerCurrentHP = playerMaxHP;
			}
			updatePlayerHpDisplay();
			console.log("Użyto Mikstury HP! Aktualne HP gracza: " + playerCurrentHP);
		} else if (collectedPowerUps.potion <= 0 && !gameOverFlag) {
			console.log("Brak mikstur HP do użycia.");
		}
	};
	// 2. Tarcza (bez zmian)
	shieldIcon = LK.getAsset('shieldAsset', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: iconSize,
		height: iconSize
	});
	shieldIcon.x = 0;
	powerUpDisplayContainer.addChild(shieldIcon);
	shieldCountText = new Text2("x0", {
		size: 40,
		fill: 0xFFFFFF,
		anchorX: 0.5,
		anchorY: 0
	});
	shieldCountText.x = shieldIcon.x;
	shieldCountText.y = textOffsetY;
	powerUpDisplayContainer.addChild(shieldCountText);
	shieldIcon.interactive = true;
	shieldIcon.down = function () {
		if (collectedPowerUps.shield > 0 && !isShieldActive && !gameOverFlag) {
			collectedPowerUps.shield--;
			updatePowerUpDisplayCounts();
			isShieldActive = true;
			shieldEndTime = Date.now() + SHIELD_DURATION;
			shieldIcon.alpha = 0.5;
			console.log("Tarcza AKTYWOWANA na " + SHIELD_DURATION / 1000 + " sekund!");
			if (shieldTimerDisplayContainer) {
				shieldTimerDisplayContainer.visible = true;
				var remainingSeconds = SHIELD_DURATION / 1000;
				shieldTimerTextDisplay.setText(remainingSeconds.toFixed(1) + "s");
			}
		} else if (isShieldActive && !gameOverFlag) {
			console.log("Tarcza jest już aktywna.");
		} else if (collectedPowerUps.shield <= 0 && !gameOverFlag) {
			console.log("Brak Tarcz do użycia.");
		}
	};
	// 3. Buff Swipe-to-Tap
	swipeToTapIcon = LK.getAsset('swipeToTapBuffAsset', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: iconSize * 1.1,
		height: iconSize * 1.1
	});
	swipeToTapIcon.x = iconSpacing;
	powerUpDisplayContainer.addChild(swipeToTapIcon);
	swipeToTapCountText = new Text2("x0", {
		size: 40,
		fill: 0xFFFFFF,
		anchorX: 0.5,
		anchorY: 0
	});
	swipeToTapCountText.x = swipeToTapIcon.x;
	swipeToTapCountText.y = textOffsetY;
	powerUpDisplayContainer.addChild(swipeToTapCountText);
	swipeToTapIcon.interactive = true;
	swipeToTapIcon.down = function () {
		console.log("--- SwipeToTap Icon (pełna logika) KLIKNIĘTA! ---");
		console.log("Stan przed aktywacją: collected=" + collectedPowerUps.swipeToTap + ", isActive=" + isSwipeToTapBuffActive + ", gameOver=" + gameOverFlag);
		if (collectedPowerUps.swipeToTap > 0 && !isSwipeToTapBuffActive && !gameOverFlag) {
			collectedPowerUps.swipeToTap--;
			updatePowerUpDisplayCounts();
			isSwipeToTapBuffActive = true;
			swipeToTapBuffEndTime = Date.now() + SWIPE_TO_TAP_BUFF_DURATION;
			swipeToTapIcon.alpha = 0.5;
			console.log("Buff Swipe-to-Tap AKTYWOWANY na " + SWIPE_TO_TAP_BUFF_DURATION / 1000 + " sekund!");
			// NOWE: Pokaż timer buffa Swipe-to-Tap
			if (swipeToTapTimerDisplayContainer) {
				swipeToTapTimerDisplayContainer.visible = true;
				var remainingSecondsBuff = SWIPE_TO_TAP_BUFF_DURATION / 1000;
				swipeToTapTimerTextDisplay.setText(remainingSecondsBuff.toFixed(1) + "s");
			}
		} else {
			console.log("Buff Swipe-to-Tap NIE został aktywowany. Analiza warunków:");
			if (!(collectedPowerUps.swipeToTap > 0)) {
				console.log("  - Powód: Brak zebranych buffów (ilość: " + collectedPowerUps.swipeToTap + ")");
			}
			if (isSwipeToTapBuffActive) {
				console.log("  - Powód: Buff Swipe-to-Tap jest już aktywny.");
			}
			if (gameOverFlag) {
				console.log("  - Powód: Gra jest zakończona (gameOverFlag = " + gameOverFlag + ")");
			}
		}
	};
	// UI dla timera tarczy (bez zmian)
	shieldTimerDisplayContainer = new Container();
	shieldTimerDisplayContainer.x = gameScreenWidth - 120;
	shieldTimerDisplayContainer.y = 150;
	gameUIContainer.addChild(shieldTimerDisplayContainer);
	var smallIconSize = 60; // Wspólny rozmiar dla małych ikon w timerach
	smallShieldIconDisplay = LK.getAsset('shieldAsset', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: smallIconSize,
		height: smallIconSize
	});
	shieldTimerDisplayContainer.addChild(smallShieldIconDisplay);
	shieldTimerTextDisplay = new Text2("", {
		size: 35,
		fill: 0xFFFFFF,
		anchorX: 0.5,
		anchorY: 0
	});
	shieldTimerTextDisplay.y = smallIconSize / 2 + 5;
	shieldTimerDisplayContainer.addChild(shieldTimerTextDisplay);
	shieldTimerDisplayContainer.visible = false;
	// NOWE: Tworzenie UI dla timera buffa Swipe-to-Tap (początkowo niewidoczne)
	swipeToTapTimerDisplayContainer = new Container();
	swipeToTapTimerDisplayContainer.x = gameScreenWidth - 120; // Ta sama pozycja X co timer tarczy
	// Pozycja Y poniżej timera tarczy (wysokość timera tarczy to ok. smallIconSize + wysokość tekstu + odstęp)
	// Zakładając, że shieldTimerDisplayContainer ma ok. 100-110px wysokości:
	swipeToTapTimerDisplayContainer.y = shieldTimerDisplayContainer.y + smallIconSize + 40 + 10; // np. 150 + 60 + 40 + 10 = 260
	gameUIContainer.addChild(swipeToTapTimerDisplayContainer);
	smallSwipeToTapIconDisplay = LK.getAsset('swipeToTapBuffAsset', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: smallIconSize * 1.1,
		// Zachowujemy proporcje jak dla dużej ikony
		height: smallIconSize * 1.1
	});
	swipeToTapTimerDisplayContainer.addChild(smallSwipeToTapIconDisplay);
	swipeToTapTimerTextDisplay = new Text2("", {
		// Początkowo pusty tekst
		size: 35,
		fill: 0xFFFFFF,
		anchorX: 0.5,
		anchorY: 0
	});
	swipeToTapTimerTextDisplay.y = smallIconSize * 1.1 / 2 + 5; // Umiejscowienie pod małą ikonką buffa
	swipeToTapTimerDisplayContainer.addChild(swipeToTapTimerTextDisplay);
	swipeToTapTimerDisplayContainer.visible = false; // Początkowo niewidoczny
	console.log("PowerUp Display UI created. All PowerUp Icons are interactive. Shield & SwipeToTap Timer UI created.");
}
function updatePowerUpDisplayCounts() {
	if (hpPotionCountText) {
		// Sprawdzamy, czy UI zostało już zainicjalizowane
		hpPotionCountText.setText("x" + collectedPowerUps.potion);
		shieldCountText.setText("x" + collectedPowerUps.shield);
		swipeToTapCountText.setText("x" + collectedPowerUps.swipeToTap);
	}
}
function updatePlayerHpDisplay() {
	if (playerHpBarFill) {
		var healthPercent = playerCurrentHP / playerMaxHP;
		playerHpBarFill.width = hpBarWidth * Math.max(0, healthPercent);
	}
}
function updateBossHpDisplay() {
	if (bossHpBarFill) {
		var healthPercent = bossCurrentHP / bossMaxHP;
		bossHpBarFill.width = hpBarWidth * Math.max(0, healthPercent);
	}
}
function spawnNotes() {
	if (!currentActiveRhythmMap || currentActiveRhythmMap.length === 0) {
		// console.log("spawnNotes called, but currentActiveRhythmMap is empty or null."); // Możesz odkomentować w razie potrzeby
		return;
	}
	// ZMODYFIKOWANY LOG:
	console.log("spawnNotes called. nextNoteIdx: " + nextNoteIdx + ", Map length: " + currentActiveRhythmMap.length + ", gameStartTime: " + gameStartTime);
	var now = Date.now();
	if (!currentActiveRhythmMap) {
		// Ten warunek jest już wyżej, ale dla pewności
		return;
	}
	while (nextNoteIdx < currentActiveRhythmMap.length) {
		var noteData = currentActiveRhythmMap[nextNoteIdx];
		var noteTargetHitTime = gameStartTime + noteData.time;
		// DODAJ TEN SZCZEGÓŁOWY BLOK LOGÓW:
		console.log("spawnNotes - Checking note Idx: " + nextNoteIdx + ", Note Time: " + noteData.time + ", TargetHitTime: " + noteTargetHitTime + ", VisualSpawnTimeCalc: " + (noteTargetHitTime - noteTravelTime) +
		// To jest moment, kiedy nuta powinna zacząć być widoczna
		", CurrentTime (now): " + now + ", noteTravelTime: " + noteTravelTime);
		if (noteTargetHitTime - noteTravelTime <= now) {
			console.log("spawnNotes - SPAWNING NOTE Idx: " + nextNoteIdx, noteData); // Log potwierdzający próbę spawnu
			var targetCenterX;
			if (noteData.partOfWiderSwipe && noteData.widerSwipePairCenterX !== undefined) {
				if (noteData.partOfWiderSwipe === 'leftHalf') {
					targetCenterX = noteData.widerSwipePairCenterX - SWIPE_NOTE_WIDTH / 2;
				} else if (noteData.partOfWiderSwipe === 'rightHalf') {
					targetCenterX = noteData.widerSwipePairCenterX + SWIPE_NOTE_WIDTH / 2;
				} else {
					targetCenterX = columnCenterXs[noteData.originalColumnHint !== undefined ? noteData.originalColumnHint : Math.floor(NUM_COLUMNS / 2)];
				}
			} else if (noteData.columnIndex !== undefined && noteData.columnIndex >= 0 && noteData.columnIndex < NUM_COLUMNS) {
				targetCenterX = columnCenterXs[noteData.columnIndex];
			} else {
				targetCenterX = playfieldStartX + playfieldWidth / 2;
				console.warn("spawnNotes - Note spawned without proper columnIndex or widerSwipe info:", noteData);
			}
			var finalNoteType = noteData.type;
			var finalSwipeDir = noteData.swipeDir;
			if (isSwipeToTapBuffActive && noteData.type === 'swipe') {
				finalNoteType = 'tap';
				finalSwipeDir = null;
			}
			var n = new Note(finalNoteType, finalSwipeDir, noteTargetHitTime, targetCenterX);
			n.mapData = noteData;
			if (noteData.partOfWiderSwipe) {
				n.isWiderSwipePart = true;
			}
			// n.alpha = 0; // Ustawiane w konstruktorze Note
			notes.push(n);
			game.addChild(n);
			console.log("spawnNotes - Note added to 'notes' array and to stage. Note instance:", n, "Parent of note:", n.parent ? "Exists" : "DOES NOT EXIST/NULL"); // Sprawdź rodzica
			nextNoteIdx++;
		} else {
			// console.log("spawnNotes - Note not ready to spawn yet, Idx: " + nextNoteIdx); // Możesz odkomentować w razie potrzeby
			break;
		}
	}
}
function removeOldNotes() {
	var now = Date.now();
	for (var i = notes.length - 1; i >= 0; i--) {
		var n = notes[i];
		var timeToRemoveAfterJudged = 700; // ms po targetHitTime dla ocenionych notatek
		var timeToRemoveIfNotJudged = noteTravelTime / 2 + hitWindowGood + 500; // Dłuższy czas, jeśli nieoceniona, liczony od targetHitTime
		if (n.judged && now > n.targetHitTime + timeToRemoveAfterJudged) {
			if (n.parent) {
				n.destroy();
			}
			notes.splice(i, 1);
		} else if (!n.judged && now > n.targetHitTime + timeToRemoveIfNotJudged) {
			if (n.noteType !== 'trap') {}
			if (n.parent) {
				n.destroy();
			}
			notes.splice(i, 1);
		}
	}
}
function findNoteAt(x, y, typeToFind) {
	var now = Date.now();
	var bestNote = null;
	var smallestTimeDiff = hitWindowGood + 1;
	for (var i = 0; i < notes.length; i++) {
		var n = notes[i];
		if (n.judged || n.noteType !== typeToFind) {
			continue;
		}
		var timeDiff = Math.abs(now - n.targetHitTime);
		if (timeDiff > hitWindowGood) {
			continue;
		}
		var currentNoteAsset = n.noteAsset;
		if (!currentNoteAsset) {
			continue;
		}
		var currentNoteWidth = currentNoteAsset.width * n.scale.x;
		var currentNoteHeight = currentNoteAsset.height * n.scale.y;
		if (n.noteType === 'swipe') {
			currentNoteWidth = SWIPE_NOTE_WIDTH * n.scale.x;
			currentNoteHeight = SWIPE_NOTE_WIDTH * n.scale.y;
		}
		var dx = x - n.x;
		var dy = y - n.y;
		if (Math.abs(dx) <= currentNoteWidth / 2 && Math.abs(dy) <= currentNoteHeight / 2) {
			if (timeDiff < smallestTimeDiff) {
				bestNote = n;
				smallestTimeDiff = timeDiff;
			}
		}
	}
	return bestNote;
}
function addScore(result) {
	if (result === 'perfect') {
		score += 100;
	} else if (result === 'good') {
		score += 50;
	}
	scoreTxt.setText('Score: ' + score);
}
function addCombo() {
	combo += 1;
	if (combo > maxCombo) {
		maxCombo = combo;
	}
	comboTxt.setText('Combo: ' + combo);
	// Animacja dla comboTxt
	if (combo > 1) {
		// Mała animacja tylko jeśli combo jest większe niż 1
		var originalScale = comboTxt.scale.x; // Zakładamy, że skala X i Y jest taka sama
		tween(comboTxt.scale, {
			x: originalScale * 1.3,
			y: originalScale * 1.3
		}, {
			duration: 100,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				tween(comboTxt.scale, {
					x: originalScale,
					y: originalScale
				}, {
					duration: 100,
					easing: tween.easeIn
				});
			}
		});
	}
}
function resetCombo() {
	combo = 0;
	comboTxt.setText('Combo: 0');
}
function checkGameEnd() {
	if (gameOverFlag) {
		return;
	}
	var summaryData = {
		score: score,
		maxCombo: maxCombo,
		bossWasActuallyDefeated: bossWasDefeatedThisSong,
		statusMessage: ""
	};
	if (playerCurrentHP <= 0) {
		gameOverFlag = true;
		console.log("GAME OVER - Player HP depleted");
		if (currentMusic && typeof currentMusic.stop === 'function') {
			currentMusic.stop();
		}
		summaryData.statusMessage = "GAME OVER";
		summaryData.bossWasActuallyDefeated = false; // Player lost, so boss effectively "wins" this round for status
		displayEndOfSongScreen(summaryData);
		return;
	}
	if (bossCurrentHP <= 0 && !bossWasDefeatedThisSong) {
		bossWasDefeatedThisSong = true;
		console.log("Boss HP depleted during song! Player continues playing.");
		if (currentFightingBossId && bossUnlockProgress.hasOwnProperty(currentFightingBossId)) {
			bossUnlockProgress[currentFightingBossId] = true;
			console.log("Boss " + currentFightingBossId + " marked as defeated in progress.");
			storage[BOSS_UNLOCK_KEY] = bossUnlockProgress; // ZMIANA TUTAJ
			console.log("Boss unlock progress saved to storage.");
		}
	}
	if (currentActiveRhythmMap && nextNoteIdx >= currentActiveRhythmMap.length && notes.length === 0) {
		gameOverFlag = true;
		console.log("SONG ENDED");
		if (currentMusic && typeof currentMusic.stop === 'function') {
			currentMusic.stop();
		}
		if (bossWasDefeatedThisSong) {
			summaryData.statusMessage = "VICTORY!";
		} else {
			summaryData.statusMessage = "SONG COMPLETED";
		}
		summaryData.bossWasActuallyDefeated = bossWasDefeatedThisSong;
		displayEndOfSongScreen(summaryData);
		return;
	}
}
function getSongStats(songMapKey) {
	if (!songMapKey) {
		return {
			bestScore: 0,
			bestCombo: 0
		};
	}
	var individualSongStorageKey = 'wf_stats_' + songMapKey; // Unikalny klucz dla piosenki
	var songStats = storage[individualSongStorageKey];
	if (songStats) {
		return {
			bestScore: parseInt(songStats.bestScore, 10) || 0,
			bestCombo: parseInt(songStats.bestCombo, 10) || 0
		};
	}
	return {
		bestScore: 0,
		bestCombo: 0
	};
}
function saveSongStats(songMapKey, currentScore, currentCombo) {
	if (!songMapKey) {
		return;
	}
	var individualSongStorageKey = 'wf_stats_' + songMapKey; // Unikalny klucz dla piosenki
	// Odczytaj istniejące statystyki dla tej konkretnej piosenki lub utwórz nowy obiekt
	var songStats = storage[individualSongStorageKey] ? JSON.parse(JSON.stringify(storage[individualSongStorageKey])) : {
		bestScore: 0,
		bestCombo: 0
	};
	var updated = false;
	var numericCurrentScore = parseInt(currentScore, 10) || 0;
	var numericCurrentCombo = parseInt(currentCombo, 10) || 0;
	if (numericCurrentScore > (parseInt(songStats.bestScore, 10) || 0)) {
		songStats.bestScore = numericCurrentScore;
		updated = true;
		console.log("New best score for " + songMapKey + " (" + individualSongStorageKey + "): " + numericCurrentScore);
	}
	if (numericCurrentCombo > (parseInt(songStats.bestCombo, 10) || 0)) {
		songStats.bestCombo = numericCurrentCombo;
		updated = true;
		console.log("New best combo for " + songMapKey + " (" + individualSongStorageKey + "): " + numericCurrentCombo);
	}
	if (updated) {
		storage[individualSongStorageKey] = songStats; // Zapisz obiekt statystyk dla tej piosenki
		console.log("Song stats saved to storage for key: " + individualSongStorageKey);
	}
}
function displayEndOfSongScreen(summaryData) {
	if (songSummaryContainer && songSummaryContainer.parent) {
		songSummaryContainer.destroy();
	}
	songSummaryContainer = new Container();
	songSummaryContainer.x = 0;
	songSummaryContainer.y = 0;
	game.addChild(songSummaryContainer);
	currentScreenState = 'songSummary';
	// Zapisz statystyki bieżącej gry i pobierz najlepsze
	if (lastPlayedSongKeyForRestart) {
		saveSongStats(lastPlayedSongKeyForRestart, summaryData.score, summaryData.maxCombo);
	}
	var bestStats = getSongStats(lastPlayedSongKeyForRestart || summaryData.songMapKey);
	var overlay = LK.getAsset('summaryOverlayAsset', {
		width: gameScreenWidth,
		height: gameScreenHeight,
		alpha: 0.7,
		interactive: true
	});
	songSummaryContainer.addChild(overlay);
	var popupWidth = gameScreenWidth * 0.6;
	var popupHeight = 720; // Zwiększona wysokość, aby zmieścić najlepsze wyniki
	var popupX = (gameScreenWidth - popupWidth) / 2;
	var popupY = (gameScreenHeight - popupHeight) / 2;
	var popupBackground = LK.getAsset('summaryPopupBackgroundAsset', {
		x: popupX,
		y: popupY,
		width: popupWidth,
		height: popupHeight
	});
	songSummaryContainer.addChild(popupBackground);
	var currentY = popupY;
	currentY += 40; // Margines górny
	var titleTextContent = summaryData.statusMessage || "SONG ENDED";
	var titleText = new Text2(titleTextContent, {
		size: 70,
		// Nieco mniejszy tytuł, jeśli potrzeba
		fill: 0xFFFFFF,
		align: 'center',
		wordWrap: true,
		wordWrapWidth: popupWidth * 0.9
	});
	titleText.anchor.set(0.5, 0);
	titleText.x = popupX + popupWidth / 2;
	titleText.y = currentY;
	songSummaryContainer.addChild(titleText);
	currentY += titleText.height + 35;
	// Boss Defeated
	var bossDefeatedStatusText = new Text2("Boss Defeated: ", {
		size: 60,
		fill: 0xFFFFFF
	});
	bossDefeatedStatusText.anchor.set(0, 0.5);
	var bossDefeatedValueText = new Text2(summaryData.bossWasActuallyDefeated ? "YES" : "NO", {
		size: 60,
		fill: summaryData.bossWasActuallyDefeated ? 0x00FF00 : 0xFF0000
	});
	bossDefeatedValueText.anchor.set(0, 0.5);
	var tempBossContainer = new Container();
	tempBossContainer.addChild(bossDefeatedStatusText);
	bossDefeatedValueText.x = bossDefeatedStatusText.width + 10;
	tempBossContainer.addChild(bossDefeatedValueText);
	var combinedBossTextWidth = tempBossContainer.width;
	bossDefeatedStatusText.x = popupX + (popupWidth - combinedBossTextWidth) / 2;
	bossDefeatedStatusText.y = currentY;
	bossDefeatedValueText.x = bossDefeatedStatusText.x + bossDefeatedStatusText.width + 10;
	bossDefeatedValueText.y = currentY;
	songSummaryContainer.addChild(bossDefeatedStatusText);
	songSummaryContainer.addChild(bossDefeatedValueText);
	currentY += bossDefeatedStatusText.height + 30;
	// Current Score
	var scoreText = new Text2("Score: " + summaryData.score, {
		size: 50,
		fill: 0xFFFFFF,
		align: 'center'
	});
	scoreText.anchor.set(0.5, 0.5);
	scoreText.x = popupX + popupWidth / 2;
	scoreText.y = currentY;
	songSummaryContainer.addChild(scoreText);
	currentY += scoreText.height + 25;
	// Current Max Combo
	var comboText = new Text2("Max Combo: " + summaryData.maxCombo, {
		size: 50,
		fill: 0xFFFFFF,
		align: 'center'
	});
	comboText.anchor.set(0.5, 0.5);
	comboText.x = popupX + popupWidth / 2;
	comboText.y = currentY;
	songSummaryContainer.addChild(comboText);
	currentY += comboText.height + 35; // Większy odstęp przed najlepszymi wynikami
	// Best Score
	var bestScoreText = new Text2("Best Score: " + bestStats.bestScore, {
		size: 50,
		fill: 0xFFFF00,
		align: 'center'
	}); // Żółty dla wyróżnienia
	bestScoreText.anchor.set(0.5, 0.5);
	bestScoreText.x = popupX + popupWidth / 2;
	bestScoreText.y = currentY;
	songSummaryContainer.addChild(bestScoreText);
	currentY += bestScoreText.height + 25;
	// Best Combo
	var bestComboText = new Text2("Best Combo: " + bestStats.bestCombo, {
		size: 50,
		fill: 0xFFFF00,
		align: 'center'
	}); // Żółty dla wyróżnienia
	bestComboText.anchor.set(0.5, 0.5);
	bestComboText.x = popupX + popupWidth / 2;
	bestComboText.y = currentY;
	songSummaryContainer.addChild(bestComboText);
	// Przyciski
	var buttonWidth = popupWidth * 0.4;
	var buttonHeight = 70;
	var buttonBottomMargin = 35;
	var buttonY = popupY + popupHeight - buttonHeight - buttonBottomMargin;
	var backButtonBg = LK.getAsset('summaryButtonBackgroundAsset', {
		x: popupX + (popupWidth / 2 - buttonWidth - 15),
		y: buttonY,
		width: buttonWidth,
		height: buttonHeight,
		interactive: true,
		cursor: "pointer"
	});
	songSummaryContainer.addChild(backButtonBg);
	var backToMenuButton = new Text2("Back to Menu", {
		size: 40,
		fill: 0xFFD700,
		stroke: 0x000000,
		strokeThickness: 2
	});
	backToMenuButton.anchor.set(0.5, 0.5);
	backToMenuButton.x = backButtonBg.x + buttonWidth / 2;
	backToMenuButton.y = backButtonBg.y + buttonHeight / 2;
	songSummaryContainer.addChild(backToMenuButton);
	backButtonBg.down = function () {
		if (songSummaryContainer && songSummaryContainer.parent) {
			songSummaryContainer.destroy();
			songSummaryContainer = null;
		}
		showBossSelectionScreen();
	};
	var restartButtonBg = LK.getAsset('summaryButtonBackgroundAsset', {
		x: popupX + (popupWidth / 2 + 15),
		y: buttonY,
		width: buttonWidth,
		height: buttonHeight,
		interactive: true,
		cursor: "pointer"
	});
	songSummaryContainer.addChild(restartButtonBg);
	var restartButton = new Text2("Restart Battle", {
		size: 40,
		fill: 0xFFD700,
		stroke: 0x000000,
		strokeThickness: 2
	});
	restartButton.anchor.set(0.5, 0.5);
	restartButton.x = restartButtonBg.x + buttonWidth / 2;
	restartButton.y = restartButtonBg.y + buttonHeight / 2;
	songSummaryContainer.addChild(restartButton);
	restartButtonBg.down = function () {
		if (songSummaryContainer && songSummaryContainer.parent) {
			songSummaryContainer.destroy();
			songSummaryContainer = null;
		}
		if (lastPlayedSongKeyForRestart) {
			loadSong(lastPlayedSongKeyForRestart);
		} else {
			showMainMenu();
		}
	};
	if (gameUIContainer) {
		gameUIContainer.visible = false;
	}
	if (hitZoneLine) {
		hitZoneLine.visible = false;
	}
}
function trySpawnRandomPowerUp() {
	var now = Date.now();
	if (now > lastPowerUpSpawnAttemptTime + POWERUP_SPAWN_INTERVAL) {
		lastPowerUpSpawnAttemptTime = now;
		if (Math.random() < POWERUP_SPAWN_CHANCE) {
			var powerUpTypes = ['potion', 'shield', 'swipeToTap'];
			var randomType = powerUpTypes[Math.floor(Math.random() * powerUpTypes.length)];
			var randomColumnIndex = Math.floor(Math.random() * NUM_COLUMNS);
			var spawnX = columnCenterXs[randomColumnIndex];
			var newPowerUp = new PowerUpItem(randomType, spawnX);
			game.addChild(newPowerUp);
			activePowerUpItems.push(newPowerUp);
			console.log("Spawnowano PowerUp: " + randomType + " w kolumnie " + (randomColumnIndex + 1));
		}
	}
}
function managePowerUpItems() {
	for (var i = activePowerUpItems.length - 1; i >= 0; i--) {
		var pItem = activePowerUpItems[i];
		// Sprawdzamy, czy obiekt w ogóle istnieje i czy ma rodzica (czy jest na scenie)
		// Jeśli został zebrany (collected=true) LUB nie ma rodzica (został zniszczony), to usuwamy z tablicy
		if (!pItem || pItem.collected || !pItem.parent) {
			activePowerUpItems.splice(i, 1);
		} else {
			pItem.update(); // Aktualizuj tylko, jeśli jest na scenie i niezebrany
		}
	}
}
game.onNoteMiss = function (note) {
	if (!note) {
		return;
	}
	note.showHitFeedback('miss');
	// NOWA ZMIANA: Sprawdzamy, czy tarcza jest aktywna przed zresetowaniem combo
	if (!isShieldActive) {
		resetCombo();
	} else {
		console.log("Gracz ominął nutę, ale tarcza jest aktywna! Combo NIE zresetowane.");
	}
	// Koniec NOWA ZMIANA
	if (isShieldActive) {
		console.log("Gracz ominął nutę, ale tarcza jest aktywna! Brak utraty HP.");
	} else if (!gameOverFlag) {
		playerCurrentHP = Math.max(0, playerCurrentHP - 1);
		updatePlayerHpDisplay();
		console.log("Player HP after miss: " + playerCurrentHP);
	}
	if (note.parent) {
		LK.effects.flashObject(note, 0xff0000, 300);
	}
};
game.down = function (x, y, obj) {
	// Usunięto logikę dla currentScreenState === 'bossselection' (stare przewijanie)
	if (currentScreenState === 'gameplay') {
		for (var i_gp_pu = activePowerUpItems.length - 1; i_gp_pu >= 0; i_gp_pu--) {
			var pItem_gp = activePowerUpItems[i_gp_pu];
			if (pItem_gp && !pItem_gp.collected && pItem_gp.visualAsset && pItem_gp.parent) {
				var pWidth_gp = pItem_gp.visualAsset.width * pItem_gp.scale.x;
				var pHeight_gp = pItem_gp.visualAsset.height * pItem_gp.scale.y;
				if (x >= pItem_gp.x - pWidth_gp / 2 && x <= pItem_gp.x + pWidth_gp / 2 && y >= pItem_gp.y - pHeight_gp / 2 && y <= pItem_gp.y + pHeight_gp / 2) {
					if (Math.abs(pItem_gp.y - hitZoneY) < pHeight_gp * 1.5) {
						pItem_gp.collect();
						return;
					}
				}
			}
		}
		if (inputLocked) {
			return;
		}
		swipeStart = {
			x: x,
			y: y,
			time: Date.now()
		};
		var noteUnderCursor_gp = findNoteAt(x, y, 'trap');
		if (noteUnderCursor_gp && !noteUnderCursor_gp.judged && noteUnderCursor_gp.isInHitWindow()) {
			noteUnderCursor_gp.judged = true;
			noteUnderCursor_gp.showHitFeedback('miss');
			if (isShieldActive) {
				console.log("Gracz trafił w TRAP NOTE, ale tarcza jest aktywna! Brak utraty HP i combo NIE zresetowane.");
			} else {
				resetCombo();
				LK.effects.flashScreen(0xff0000, 400);
				if (!gameOverFlag) {
					playerCurrentHP = Math.max(0, playerCurrentHP - 1);
					updatePlayerHpDisplay();
				}
			}
			inputLocked = true;
			LK.setTimeout(function () {
				inputLocked = false;
			}, 200);
			return;
		}
		noteUnderCursor_gp = findNoteAt(x, y, 'tap');
		if (noteUnderCursor_gp && !noteUnderCursor_gp.judged && noteUnderCursor_gp.isInHitWindow()) {
			var result_gp = noteUnderCursor_gp.getHitAccuracy();
			noteUnderCursor_gp.judged = true;
			noteUnderCursor_gp.showHitFeedback(result_gp);
			if (result_gp !== 'miss') {
				addScore(result_gp);
				addCombo();
				if (!gameOverFlag) {
					if (result_gp === 'perfect') {
						bossCurrentHP = Math.max(0, bossCurrentHP - 2);
					} else if (result_gp === 'good') {
						bossCurrentHP = Math.max(0, bossCurrentHP - 1);
					}
					updateBossHpDisplay();
				}
			} else {
				if (!isShieldActive) {
					resetCombo();
				} else {
					console.log("Tapnięcie nuty ocenione jako 'miss', ale tarcza jest aktywna! Combo NIE zresetowane.");
				}
			}
			inputLocked = true;
			LK.setTimeout(function () {
				inputLocked = false;
			}, 120);
			return;
		}
	}
	// Tutaj można dodać logikę dla innych stanów, jeśli będzie potrzebna
};
game.move = function (x, y, obj) {};
game.up = function (x, y, obj) {
	if (currentScreenState === 'gameplay') {
		if (inputLocked || !swipeStart) {
			swipeStart = null;
			return;
		}
		var swipeEndX = x;
		var swipeEndY = y;
		var swipeEndTime = Date.now();
		var dx = swipeEndX - swipeStart.x;
		var dy = swipeEndY - swipeStart.y;
		var dist = Math.sqrt(dx * dx + dy * dy);
		var potentialSwipe = dist >= MIN_SWIPE_DISTANCE;
		var swipedNoteSuccessfully = false;
		if (potentialSwipe) {
			var detectedDir = null;
			if (Math.abs(dx) > Math.abs(dy)) {
				detectedDir = dx > 0 ? 'right' : 'left';
			} else {
				detectedDir = dy > 0 ? 'down' : 'up';
			}
			var swipeBoundingBox = {
				x: Math.min(swipeStart.x, swipeEndX),
				y: Math.min(swipeStart.y, swipeEndY),
				width: Math.abs(dx),
				height: Math.abs(dy)
			};
			var notesHitThisSwipe = [];
			for (var i_swipe = 0; i_swipe < notes.length; i_swipe++) {
				var n_swipe = notes[i_swipe];
				if (n_swipe.judged || n_swipe.noteType !== 'swipe') {
					continue;
				}
				var overallSwipeTimeMatchesNote = false;
				if (n_swipe.targetHitTime >= swipeStart.time - hitWindowGood && n_swipe.targetHitTime <= swipeEndTime + hitWindowGood) {
					overallSwipeTimeMatchesNote = true;
				}
				if (!overallSwipeTimeMatchesNote) {
					if (swipeStart.time >= n_swipe.targetHitTime - hitWindowGood && swipeStart.time <= n_swipe.targetHitTime + hitWindowGood || swipeEndTime >= n_swipe.targetHitTime - hitWindowGood && swipeEndTime <= n_swipe.targetHitTime + hitWindowGood) {
						overallSwipeTimeMatchesNote = true;
					}
				}
				if (!overallSwipeTimeMatchesNote) {
					continue;
				}
				if (n_swipe.alpha === 0) {
					continue;
				}
				var noteCurrentWidth_swipe = SWIPE_NOTE_WIDTH * n_swipe.scale.x;
				var noteCurrentHeight_swipe = SWIPE_NOTE_WIDTH * n_swipe.scale.y;
				var noteBoundingBox_swipe = {
					x: n_swipe.x - noteCurrentWidth_swipe / 2,
					y: n_swipe.y - noteCurrentHeight_swipe / 2,
					width: noteCurrentWidth_swipe,
					height: noteCurrentHeight_swipe
				};
				if (rectsIntersect(swipeBoundingBox, noteBoundingBox_swipe)) {
					if (detectedDir === n_swipe.swipeDir) {
						var verticalProximity = Math.abs(n_swipe.y - n_swipe.centerY);
						var verticalTolerance = noteCurrentHeight_swipe / 1.5;
						if (verticalProximity < verticalTolerance) {
							notesHitThisSwipe.push(n_swipe);
						}
					}
				}
			}
			if (notesHitThisSwipe.length > 0) {
				notesHitThisSwipe.sort(function (a, b) {
					var da = Math.abs(swipeEndTime - a.targetHitTime);
					var db = Math.abs(swipeEndTime - b.targetHitTime);
					return da - db;
				});
				var maxNotesToHitPerSwipe = 1;
				if (notesHitThisSwipe.length > 0 && notesHitThisSwipe[0].isWiderSwipePart) {
					maxNotesToHitPerSwipe = 2;
				}
				var notesActuallyHitCount = 0;
				for (var k_swipe = 0; k_swipe < notesHitThisSwipe.length && notesActuallyHitCount < maxNotesToHitPerSwipe; k_swipe++) {
					var noteToJudge_swipe = notesHitThisSwipe[k_swipe];
					if (noteToJudge_swipe.judged) {
						continue;
					}
					if (notesActuallyHitCount === 1 && notesHitThisSwipe[0].isWiderSwipePart) {
						if (!noteToJudge_swipe.isWiderSwipePart || noteToJudge_swipe.mapData.widerSwipePairCenterX !== notesHitThisSwipe[0].mapData.widerSwipePairCenterX || noteToJudge_swipe.mapData.partOfWiderSwipe === notesHitThisSwipe[0].mapData.partOfWiderSwipe) {
							continue;
						}
					}
					var result_swipe = noteToJudge_swipe.getHitAccuracy();
					noteToJudge_swipe.judged = true;
					noteToJudge_swipe.showHitFeedback(result_swipe);
					if (result_swipe !== 'miss') {
						addScore(result_swipe);
						addCombo();
						if (!gameOverFlag) {
							if (result_swipe === 'perfect') {
								bossCurrentHP = Math.max(0, bossCurrentHP - 2);
							} else if (result_swipe === 'good') {
								bossCurrentHP = Math.max(0, bossCurrentHP - 1);
							}
							updateBossHpDisplay();
						}
					} else {
						resetCombo();
					}
					swipedNoteSuccessfully = true;
					notesActuallyHitCount++;
				}
			}
		}
		inputLocked = true;
		LK.setTimeout(function () {
			inputLocked = false;
		}, 80);
		swipeStart = null;
	}
};
game.update = function () {
	console.log("game.update - currentScreenState: " + currentScreenState + ", notes.length: " + (typeof notes !== 'undefined' ? notes.length : 'undefined'));
	if (typeof notes === 'undefined' || !Array.isArray(notes)) {
		notes = [];
	}
	if (typeof activePowerUpItems === 'undefined' || !Array.isArray(activePowerUpItems)) {
		activePowerUpItems = [];
	}
	if (currentScreenState === 'gameplay') {
		console.log("game.update - In 'gameplay' state, attempting to call spawnNotes.");
		if (!hpBarsInitialized) {
			setupHpBars();
			setupPowerUpDisplay();
			lastPowerUpSpawnAttemptTime = Date.now();
			hpBarsInitialized = true;
			updatePowerUpDisplayCounts();
		}
		var now = Date.now();
		if (isShieldActive) {
			if (now > shieldEndTime) {
				isShieldActive = false;
				if (shieldIcon) {
					shieldIcon.alpha = 1.0;
				}
				if (shieldTimerDisplayContainer) {
					shieldTimerDisplayContainer.visible = false;
				}
				console.log("Tarcza WYGASŁA.");
			} else {
				if (shieldTimerDisplayContainer && shieldTimerDisplayContainer.visible) {
					var remainingSecondsShield = (shieldEndTime - now) / 1000;
					if (shieldTimerTextDisplay) {
						shieldTimerTextDisplay.setText(remainingSecondsShield.toFixed(1) + "s");
					}
				}
			}
		} else {
			if (shieldTimerDisplayContainer && shieldTimerDisplayContainer.visible) {
				shieldTimerDisplayContainer.visible = false;
			}
		}
		if (isSwipeToTapBuffActive) {
			if (now > swipeToTapBuffEndTime) {
				isSwipeToTapBuffActive = false;
				if (swipeToTapIcon) {
					swipeToTapIcon.alpha = 1.0;
				}
				if (swipeToTapTimerDisplayContainer) {
					swipeToTapTimerDisplayContainer.visible = false;
				}
				console.log("Buff Swipe-to-Tap WYGASŁ.");
			} else {
				if (swipeToTapTimerDisplayContainer && swipeToTapTimerDisplayContainer.visible) {
					var remainingSecondsBuff = (swipeToTapBuffEndTime - now) / 1000;
					if (swipeToTapTimerTextDisplay) {
						swipeToTapTimerTextDisplay.setText(remainingSecondsBuff.toFixed(1) + "s");
					}
				}
			}
		} else {
			if (swipeToTapTimerDisplayContainer && swipeToTapTimerDisplayContainer.visible) {
				swipeToTapTimerDisplayContainer.visible = false;
			}
		}
		trySpawnRandomPowerUp();
		managePowerUpItems();
		spawnNotes();
		for (var i_update_notes = 0; i_update_notes < notes.length; i_update_notes++) {
			if (notes[i_update_notes] && notes[i_update_notes].update) {
				notes[i_update_notes].update();
			}
		}
		removeOldNotes();
		checkGameEnd();
	} else {
		if (notes.length > 0) {
			for (var i_notes_clear = notes.length - 1; i_notes_clear >= 0; i_notes_clear--) {
				var n_clear = notes[i_notes_clear];
				if (n_clear && n_clear.parent) {
					n_clear.destroy();
				}
			}
			notes = [];
		}
		if (activePowerUpItems.length > 0) {
			for (var i_pwup_clear = activePowerUpItems.length - 1; i_pwup_clear >= 0; i_pwup_clear--) {
				var p_clear = activePowerUpItems[i_pwup_clear];
				if (p_clear && p_clear.parent) {
					p_clear.destroy();
				}
			}
			activePowerUpItems = [];
		}
	}
};
// Load the specific song for testing
showStartScreen();

===================================================================
--- original.js
+++ change.js
@@ -387,35 +387,39 @@
 		}
 	}
 	mainMenuItemTextObjects = [];
 	currentScreenState = 'mainmenu_walkman';
-	if (gameUIContainer) gameUIContainer.visible = false;
-	if (hitZoneLine) hitZoneLine.visible = false;
-	if (shieldTimerDisplayContainer) shieldTimerDisplayContainer.visible = false;
-	if (swipeToTapTimerDisplayContainer) swipeToTapTimerDisplayContainer.visible = false;
-	if (songSummaryContainer && songSummaryContainer.parent) songSummaryContainer.destroy();
-	// Twoje ustawienia dla obszaru ekranu Walkmana, rozmiaru czcionki i odstępów
-	var walkmanScreenArea = {
-		x: gameScreenWidth * 0.21,
-		y: gameScreenHeight * 0.50,
-		width: gameScreenWidth * 0.5,
-		height: gameScreenHeight * 0.3
-	};
-	var menuItemFontSize = 120;
-	var menuItemSpacing = 250;
-	// Centrum obszaru, w którym będą przewijać się teksty (dla funkcji layoutAndHighlight)
-	// Te TARGET_ wartości odnoszą się do środka obszaru zdefiniowanego przez walkmanScreenArea
-	var TARGET_CENTER_X_FOR_MENU_ITEMS = walkmanScreenArea.x + walkmanScreenArea.width / 2;
-	var TARGET_CENTER_Y_FOR_SELECTED_ITEM = walkmanScreenArea.y + walkmanScreenArea.height / 2;
+	if (gameUIContainer) {
+		gameUIContainer.visible = false;
+	}
+	if (hitZoneLine) {
+		hitZoneLine.visible = false;
+	}
+	if (shieldTimerDisplayContainer) {
+		shieldTimerDisplayContainer.visible = false;
+	}
+	if (swipeToTapTimerDisplayContainer) {
+		swipeToTapTimerDisplayContainer.visible = false;
+	}
+	if (songSummaryContainer && songSummaryContainer.parent) {
+		songSummaryContainer.destroy();
+	}
+	// Definicje dla szkiełka - takie same jak w boss menu
+	var glassX = 384;
+	var glassY = 1050;
+	var glassWidth = 1000;
+	var glassHeight = 720;
+	var glassAlpha = 0.5;
+	// Ustawienia dla czcionki i odstępów menu - możesz je nadal dostosowywać
+	var menuItemFontSize = 120; // Twoja wartość
+	var menuItemSpacing = 250; // Twoja wartość
+	// Centrum obszaru "szkiełka" - tutaj będą centrowane opcje menu
+	var TARGET_CENTER_X_FOR_MENU_ITEMS = gameScreenWidth / 2 - 80;
+	var TARGET_CENTER_Y_FOR_SELECTED_ITEM = gameScreenHeight / 2 + 30;
 	// 1. Kontener na teksty menu (rysowany najgłębiej)
 	var menuTextContainer = new Container();
-	// Pozycjonujemy sam kontener, a teksty wewnątrz względem (0,0) kontenera, LUB
-	// teksty mają globalne pozycje, a kontener jest tylko do grupowania.
-	// Dla prostoty przewijania, teksty będą miały globalne X,Y obliczane w layoutAndHighlight.
-	// Kontener nie musi być dodawany do sceny, jeśli teksty dodajemy bezpośrednio do 'game'.
-	// Ale jeśli dodajemy teksty do kontenera, to kontener do 'game'.
-	game.addChild(menuTextContainer); // Dodajemy kontener do gry
-	mainMenuScreenElements.push(menuTextContainer); // Do czyszczenia
+	game.addChild(menuTextContainer);
+	mainMenuScreenElements.push(menuTextContainer);
 	selectedMainMenuItemIndex = 0;
 	for (var i = 0; i < mainMenuItems.length; i++) {
 		var itemText = new Text2(mainMenuItems[i], {
 			size: menuItemFontSize,
@@ -423,11 +427,10 @@
 			align: 'center'
 		});
 		itemText.anchor.set(0.5, 0.5);
 		itemText.interactive = false;
-		menuTextContainer.addChild(itemText); // Dodajemy tekst do kontenera tekstów
+		menuTextContainer.addChild(itemText);
 		mainMenuItemTextObjects.push(itemText);
-		// Nie dodajemy itemText bezpośrednio do mainMenuScreenElements, bo jest w kontenerze, który już tam jest
 	}
 	function layoutAndHighlightMainMenuItems() {
 		var defaultTint = 0xFFFFFF;
 		var highlightTint = 0xFFD700;
@@ -448,30 +451,29 @@
 			}
 		}
 	}
 	// 2. Dodaj "szkiełko" (glassAsset) - RYSOWANE NAD TEKSTAMI
-	// Używamy Twoich wartości z walkmanScreenArea do pozycjonowania i wymiarowania szkiełka
 	var glass = LK.getAsset('glass', {
-		x: walkmanScreenArea.x,
-		y: walkmanScreenArea.y,
-		width: walkmanScreenArea.width,
-		height: walkmanScreenArea.height,
-		alpha: 0.15,
-		// W boss menu było 0.3, tutaj może być subtelniejsze, dostosuj
+		x: glassX,
+		y: glassY,
+		width: glassWidth,
+		height: glassHeight,
+		alpha: glassAlpha,
 		interactive: false
 	});
-	game.addChild(glass); // Dodajemy NAD menuTextContainer
+	game.addChild(glass);
 	mainMenuScreenElements.push(glass);
 	// 3. Główna grafika Walkmana (asset 'mainmenu') - RYSOWANA NAD SZKIEŁKIEM I TEKSTAMI
+	// Zakładamy, że jej przezroczysty ekran idealnie pasuje do wymiarów i pozycji 'glass'
 	var walkmanFrame = LK.getAsset('mainmenu', {
 		x: 0,
 		y: 0,
 		width: gameScreenWidth,
 		height: gameScreenHeight
 	});
 	game.addChild(walkmanFrame);
 	mainMenuScreenElements.push(walkmanFrame);
-	// 4. Przyciski - RYSOWANE NAD GRAFIKĄ WALKMANA
+	// 4. Przyciski - RYSOWANE NAD GRAFIKĄ WALKMANA (ich pozycje pozostają takie same jak w boss menu)
 	var upButton = LK.getAsset('upbutton', {});
 	upButton.x = 210;
 	upButton.y = gameScreenHeight / 2 - 180;
 	upButton.anchor.set(0.5, 0.5);
@@ -526,12 +528,20 @@
 	fightButton.down = function () {
 		var selectedAction = mainMenuItems[selectedMainMenuItemIndex];
 		while (mainMenuScreenElements.length > 0) {
 			var elemToDestroy = mainMenuScreenElements.pop();
-			if (elemToDestroy && elemToDestroy.parent) elemToDestroy.destroy();
+			if (elemToDestroy && elemToDestroy.parent) {
+				elemToDestroy.destroy();
+			}
 		}
 		mainMenuItemTextObjects = [];
-		if (selectedAction === "Music Battle") showBossSelectionScreen();else if (selectedAction === "How To Play") showTutorial();else if (selectedAction === "Credits") showCreditsScreen();else if (selectedAction === "Stats") {
+		if (selectedAction === "Music Battle") {
+			showBossSelectionScreen();
+		} else if (selectedAction === "How To Play") {
+			showTutorial();
+		} else if (selectedAction === "Credits") {
+			showCreditsScreen();
+		} else if (selectedAction === "Stats") {
 			console.log("Stats screen selected - (Not yet implemented)");
 			var tempStatsPopup = new Text2("Stats Screen\n(Coming Soon!)", {
 				size: 100,
 				fill: 0xffffff,
@@ -541,9 +551,11 @@
 			tempStatsPopup.x = gameScreenWidth / 2;
 			tempStatsPopup.y = gameScreenHeight / 2;
 			game.addChild(tempStatsPopup);
 			LK.setTimeout(function () {
-				if (tempStatsPopup.parent) tempStatsPopup.destroy();
+				if (tempStatsPopup.parent) {
+					tempStatsPopup.destroy();
+				}
 			}, 2000);
 		}
 	};
 	game.addChild(fightButton);