Upit | Learn about creating the game Roll Souls with gen AI
Play
game-community-background
game-pic

3.8K

57

9mo

Playit
One boss huh now Two bosses Roll Master Mode – 4 attack types, and the longer you survive, the harder it gets (tested up to 3 minutes... after that: good luck xD) Cursed Crystal Mode In this mode, your goal is to collect as many souls as possible. The more souls you gather, the slower the cursed crystal charges. However, the longer you delay its full charge, the stronger the final boss will become. A thousand rolls Absolutely no balance Tap. Roll. Die. Repeat. Because death... is progress?
#SoulsLike
#ParodyGame
#RollToWin
#MinimalistGraphics
#DifficultGame
#UpitMemeGameContest

Creation History

Code edit (1 edits merged)

Please save this source code

Code edit (1 edits merged)

Please save this source code

Code edit (1 edits merged)

Please save this source code

Code edit (1 edits merged)

Please save this source code

Code edit (1 edits merged)

Please save this source code

Code edit (1 edits merged)

Please save this source code

Code edit (1 edits merged)

Please save this source code

Code edit (1 edits merged)

Please save this source code

Code edit (7 edits merged)

Please save this source code

User prompt

Please fix the bug: 'Cannot set properties of undefined (setting 'update')' in or related to this line: 'game.game.update = function () {' Line Number: 4529

Code edit (1 edits merged)

Please save this source code

Code edit (1 edits merged)

Please save this source code

Code edit (1 edits merged)

Please save this source code

Code edit (1 edits merged)

Please save this source code

Code edit (1 edits merged)

Please save this source code

Code edit (1 edits merged)

Please save this source code

Code edit (14 edits merged)

Please save this source code

User prompt

Please fix the bug: 'LLK is not defined' in or related to this line: 'var currentSceneElements = new Container();' Line Number: 1904

User prompt

Please fix the bug: 'LLK is not defined' in or related to this line: 'LLK.init.image('fireball0', {' Line Number: 1904

Code edit (1 edits merged)

Please save this source code

Code edit (1 edits merged)

Please save this source code

Code edit (1 edits merged)

Please save this source code

Code edit (1 edits merged)

Please save this source code

Code edit (21 edits merged)

Please save this source code

User prompt

add new assets linearattack1 to linearattack5

===================================================================
--- original.js
+++ change.js
@@ -947,8 +947,407 @@
 	self.attackCooldown = 120; // Początkowy cooldown przed pierwszym atakiem
 	self.dead = false;
 	return self;
 });
+// -------- POCZĄTEK ZAKTUALIZOWANEJ KLASY MinibossCC --------
+var MinibossCC = Container.expand(function (options) {
+	var self = Container.call(this);
+	options = options || {};
+	self.maxHp = options.maxHp || 200;
+	self.hp = self.maxHp;
+	self.speed = options.speed || 1.5;
+	self.isDead = false;
+	self.attackPattern = ['explosiveProjectile', 'laserWall'];
+	self.currentAttackIndex = 0;
+	self.attackCooldowns = {
+		'explosiveProjectile': 8 * 60,
+		'laserWall': 5 * 60
+	};
+	self.attackCooldown = 120;
+	self.currentAttackName = '';
+	try {
+		self.graphics = self.attachAsset('miniboss_cc_asset', {
+			anchorX: 0.5,
+			anchorY: 0.5
+		});
+	} catch (e) {
+		console.warn("Nie udało się załadować 'miniboss_cc_asset', używam awaryjnego Shape:", e);
+		self.graphics = new Shape({
+			width: 120,
+			height: 120,
+			color: 0xFF8C00,
+			shape: 'box'
+		});
+		self.addChild(self.graphics);
+	}
+	if (self.graphics && typeof self.graphics.width !== 'undefined') {
+		self.width = self.graphics.width * (self.graphics.scaleX || 1);
+		self.height = self.graphics.height * (self.graphics.scaleY || 1);
+	} else {
+		self.width = 120;
+		self.height = 120;
+	}
+	self.x = options.x || 2048 / 2;
+	self.y = options.y || 300;
+	self.update = function () {
+		if (self.isDead || gameState.currentState !== "cursedCrystal") {
+			return;
+		}
+		if (self.attackCooldown > 0) {
+			self.attackCooldown--;
+		} else if (player && !player.dead) {
+			self.performAttack();
+			self.attackCooldown = self.attackCooldowns[self.currentAttackName] || 180;
+		}
+	};
+	self.performAttack = function () {
+		if (!player || player.dead) {
+			return;
+		}
+		self.currentAttackName = self.attackPattern[self.currentAttackIndex];
+		console.log("MinibossCC performs attack: " + self.currentAttackName);
+		if (self.currentAttackName === 'explosiveProjectile') {
+			var projectile = new MinibossExplosiveProjectile({
+				x: self.x,
+				y: self.y,
+				target: player,
+				speed: 7,
+				explosionRadius: 150
+			});
+			game.addChild(projectile);
+			if (gameState.cursedCrystalActiveProjectiles === undefined) {
+				gameState.cursedCrystalActiveProjectiles = [];
+			}
+			gameState.cursedCrystalActiveProjectiles.push(projectile);
+		} else if (self.currentAttackName === 'laserWall') {
+			var numLaserSegments = 5;
+			var laserSegmentWidth = 30;
+			var laserSegmentHeight = 120;
+			var spacingBetweenSegments = 10;
+			var totalWallEffectiveHeight = numLaserSegments * laserSegmentHeight + (numLaserSegments - 1) * spacingBetweenSegments;
+			var wallPivotX = self.x; // Punkt obrotu ściany
+			var wallPivotY = self.y; // Punkt obrotu ściany
+			var warningDuration = 1500;
+			var activeDuration = 2000; // 2 sekundy obracania się
+			// Pełen obrót (2*PI radianów) w ciągu activeDuration (np. 120 klatek)
+			// rotationSpeed = (2 * Math.PI) / (activeDuration / (1000/60)); // Radianów na klatkę
+			var rotationSpeed = 2 * Math.PI / 120; // ~3 stopnie na klatkę dla pełnego obrotu w 2s @ 60fps
+			var laserWallInstance = {
+				pivotX: wallPivotX,
+				pivotY: wallPivotY,
+				segments: [],
+				currentAngle: 0,
+				// Początkowy kąt
+				rotationSpeed: rotationSpeed,
+				activeTimer: activeDuration,
+				// w ms
+				isDead: false,
+				warningVisuals: [] // Do przechowania wizualizacji ostrzeżeń
+			};
+			// Faza Ostrzeżenia
+			var initialSegmentOffsetY = -(totalWallEffectiveHeight / 2) + laserSegmentHeight / 2;
+			for (var i = 0; i < numLaserSegments; i++) {
+				var segmentOffsetY = initialSegmentOffsetY + i * (laserSegmentHeight + spacingBetweenSegments);
+				// Pozycja ostrzeżenia jest na razie statyczna względem Minibossa
+				var warningPosX = wallPivotX; // Ostrzeżenie w linii X Minibossa
+				var warningPosY = wallPivotY + segmentOffsetY; // Rozłożone pionowo
+				var warningFrames = [];
+				for (var wf = 0; wf < 5; wf++) {
+					try {
+						warningFrames.push(LK.getAsset('rmattack3_warning_' + wf, {
+							anchorX: 0.5,
+							anchorY: 0.5
+						}));
+					} catch (e) {
+						warningFrames.push(new Shape({
+							width: laserSegmentWidth,
+							height: laserSegmentHeight,
+							color: 0xFF0000,
+							shape: 'box'
+						}));
+					}
+				}
+				var warningAnim = new SpriteAnimation({
+					frames: warningFrames,
+					frameDuration: 100,
+					loop: true,
+					x: warningPosX,
+					y: warningPosY,
+					anchorX: 0.5,
+					anchorY: 0.5,
+					alpha: 0.7
+				});
+				game.addChild(warningAnim);
+				laserWallInstance.warningVisuals.push(warningAnim);
+				warningAnim.play();
+				// Zapisz offsetY dla późniejszego obliczenia pozycji obracanych segmentów
+				// offsetX jest 0, bo na razie ściana jest idealnie pionowa i wycentrowana na X bossa
+				laserWallInstance.segments.push({
+					initialOffsetX: 0,
+					// Względem pivotX
+					initialOffsetY: segmentOffsetY,
+					// Względem pivotY
+					width: laserSegmentWidth,
+					height: laserSegmentHeight,
+					visual: null,
+					// Grafika lasera zostanie stworzona później
+					currentX: warningPosX,
+					// Na razie to samo co warning
+					currentY: warningPosY // Na razie to samo co warning
+				});
+			}
+			LK.setTimeout(function () {
+				// Po zakończeniu ostrzeżenia
+				// Usuń ostrzeżenia
+				laserWallInstance.warningVisuals.forEach(function (warnVis) {
+					if (warnVis && warnVis.parent) {
+						warnVis.parent.removeChild(warnVis);
+						warnVis.destroy();
+					}
+				});
+				laserWallInstance.warningVisuals = [];
+				// Stwórz aktywne segmenty laserowe
+				laserWallInstance.segments.forEach(function (segment) {
+					var laserStrikeFrames = [];
+					var useStrikeAnimation = false;
+					try {
+						for (var sf = 0; sf < 5; sf++) {
+							laserStrikeFrames.push(LK.getAsset('rmattack3_strike_' + sf, {
+								anchorX: 0.5,
+								anchorY: 0.5,
+								width: segment.width,
+								height: segment.height
+							}));
+						}
+						useStrikeAnimation = true;
+					} catch (e) {/* Użyj Shape */}
+					if (useStrikeAnimation) {
+						segment.visual = new SpriteAnimation({
+							frames: laserStrikeFrames,
+							frameDuration: 40,
+							loop: true,
+							x: segment.currentX,
+							y: segment.currentY,
+							anchorX: 0.5,
+							anchorY: 0.5
+						});
+						segment.visual.play();
+					} else {
+						segment.visual = new Shape({
+							width: segment.width,
+							height: segment.height,
+							color: 0xFF0000,
+							shape: 'box',
+							x: segment.currentX,
+							y: segment.currentY,
+							anchorX: 0.5,
+							anchorY: 0.5 // Shape też może mieć anchor, jeśli jest zdefiniowany w Twojej klasie Shape
+						});
+					}
+					game.addChild(segment.visual);
+				});
+				if (gameState.cursedCrystalActiveLaserWalls === undefined) {
+					gameState.cursedCrystalActiveLaserWalls = [];
+				}
+				gameState.cursedCrystalActiveLaserWalls.push(laserWallInstance);
+			}, warningDuration);
+		}
+		self.currentAttackIndex = (self.currentAttackIndex + 1) % self.attackPattern.length;
+	};
+	self.takeDamage = function (amount) {
+		if (self.isDead) {
+			return;
+		}
+		self.hp -= amount;
+		gameState.cursedCrystalMinibossHP = self.hp;
+		LK.effects.flashObject(self.graphics || self, 0xFF0000, 200);
+		if (self.hp <= 0) {
+			self.hp = 0;
+			gameState.cursedCrystalMinibossHP = self.hp;
+			self.die();
+		}
+		if (ui && ui.updateMinibossHealthCC) {
+			ui.updateMinibossHealthCC(self.hp, self.maxHp, true);
+		}
+	};
+	self.die = function () {
+		if (self.isDead) {
+			return;
+		}
+		self.isDead = true;
+		console.log("MinibossCC has been defeated!");
+		if (gameState.cursedCrystalActiveProjectiles) {
+			gameState.cursedCrystalActiveProjectiles.forEach(function (proj) {
+				if (proj.graphics && proj.graphics.parent) {
+					proj.graphics.parent.removeChild(proj.graphics);
+				}
+				if (proj.destroy) {
+					proj.destroy();
+				}
+				proj.isDead = true;
+			});
+			gameState.cursedCrystalActiveProjectiles = [];
+		}
+		if (gameState.cursedCrystalActiveExplosions) {
+			gameState.cursedCrystalActiveExplosions = [];
+		}
+		if (gameState.cursedCrystalActiveLaserWalls) {
+			// Czyszczenie ścian laserów przy śmierci bossa
+			gameState.cursedCrystalActiveLaserWalls.forEach(function (wall) {
+				wall.segments.forEach(function (seg) {
+					if (seg.visual && seg.visual.parent) {
+						seg.visual.parent.removeChild(seg.visual);
+					}
+					if (seg.visual && seg.visual.destroy) {
+						seg.visual.destroy();
+					}
+				});
+				wall.isDead = true;
+			});
+			gameState.cursedCrystalActiveLaserWalls = [];
+		}
+		if (typeof gameState.endCursedCrystalMode === 'function') {
+			gameState.endCursedCrystalMode(true);
+		}
+		if (self.parent) {
+			self.parent.removeChild(self);
+		}
+		self.destroy();
+		gameState.cursedCrystalMinibossObject = null;
+		gameState.isMinibossActiveCC = false;
+	};
+	return self;
+});
+// -------- KONIEC ZAKTUALIZOWANEJ KLASY MinibossCC --------
+var MinibossExplosiveProjectile = Container.expand(function (options) {
+	var self = Container.call(this);
+	options = options || {};
+	self.x = options.x || 0;
+	self.y = options.y || 0;
+	self.speed = options.speed || 7; // Prędkość pocisku (w pikselach na klatkę)
+	self.target = options.target; // Referencja do obiektu gracza
+	self.lifeTimer = 120; // 2 sekundy przy 60fps
+	self.isDead = false; // Czy pocisk powinien zostać usunięty z listy aktywnych
+	self.hasExploded = false; // Czy pocisk już eksplodował
+	self.explosionRadius = options.explosionRadius || 100; // Promień eksplozji (dla średnicy 200x200)
+	// Możemy to zwiększyć do ~500 dla 1/6 mapy
+	self.explosionDamage = 1; // Obrażenia eksplozji
+	// Grafika pocisku (placeholder - dostosujesz asset)
+	try {
+		self.graphics = self.attachAsset('placeholder_projectile_asset', {
+			// Użyj własnego assetu
+			anchorX: 0.5,
+			anchorY: 0.5,
+			width: 40,
+			// Jak wspomniałeś
+			height: 40
+		});
+	} catch (e) {
+		console.warn("Nie udało się załadować 'placeholder_projectile_asset' dla MinibossExplosiveProjectile, używam Shape.", e);
+		self.graphics = new Shape({
+			width: 40,
+			height: 40,
+			color: 0xFF4500,
+			// Pomarańczowo-czerwony
+			shape: 'ellipse'
+		});
+		self.addChild(self.graphics);
+	}
+	self.width = self.graphics.width;
+	self.height = self.graphics.height;
+	self.update = function () {
+		if (self.isDead || self.hasExploded || !self.target || self.target.dead) {
+			if (!self.hasExploded && !self.isDead) {
+				// Jeśli cel zniknął, a pocisk nie wybuchł, oznacz do usunięcia
+				self.isDead = true;
+			}
+			return;
+		}
+		self.lifeTimer--;
+		// Logika naprowadzania
+		var dx = self.target.x - self.x;
+		var dy = self.target.y - self.y;
+		var distanceToTarget = Math.sqrt(dx * dx + dy * dy);
+		if (distanceToTarget > 0) {
+			var moveX = dx / distanceToTarget * self.speed;
+			var moveY = dy / distanceToTarget * self.speed;
+			self.x += moveX;
+			self.y += moveY;
+		}
+		// Kolizja z graczem
+		var playerRadius = (self.target.width || 150) / 2 * 0.7; // Użyj promienia gracza
+		var projectileRadius = self.width / 2;
+		if (distanceToTarget < playerRadius + projectileRadius) {
+			// Nie zadajemy obrażeń bezpośrednio od pocisku, tylko od eksplozji
+			self.explode();
+			return; // Zatrzymaj dalsze przetwarzanie tego pocisku
+		}
+		// Sprawdzenie timera życia
+		if (self.lifeTimer <= 0) {
+			self.explode();
+			return;
+		}
+		// (Opcjonalnie) Sprawdzenie granic ekranu, jeśli chcesz, by wybuchał na krawędziach
+		// if (self.x < 0 || self.x > 2048 || self.y < 0 || self.y > 2732) {
+		//     self.explode();
+		//     return;
+		// }
+	};
+	self.explode = function () {
+		if (self.hasExploded) {
+			return;
+		}
+		self.hasExploded = true;
+		self.isDead = true; // Oznacz do usunięcia z listy aktywnych pocisków
+		if (self.graphics && self.graphics.parent) {
+			self.graphics.parent.removeChild(self.graphics);
+			self.graphics.destroy();
+		}
+		// Stwórz efekt wizualny eksplozji (placeholder)
+		var explosionVisual = new Shape({
+			// Użyjesz tu własnej animacji/assetu
+			width: self.explosionRadius * 2,
+			// Średnica
+			height: self.explosionRadius * 2,
+			color: 0xFF8C00,
+			// Ciemnopomarańczowy
+			shape: 'ellipse'
+		});
+		explosionVisual.x = self.x;
+		explosionVisual.y = self.y;
+		explosionVisual.alpha = 0.7;
+		game.addChild(explosionVisual); // Dodaj do głównej sceny
+		tween(explosionVisual, {
+			scaleX: 1.2,
+			scaleY: 1.2,
+			alpha: 0
+		}, {
+			duration: 500,
+			// Czas trwania wizualizacji eksplozji
+			easing: tween.easeOutQuad,
+			onFinish: function onFinish() {
+				if (explosionVisual.parent) {
+					explosionVisual.parent.removeChild(explosionVisual);
+				}
+				explosionVisual.destroy();
+			}
+		});
+		// Dodaj obiekt logiczny eksplozji do śledzenia obrażeń
+		if (gameState && gameState.cursedCrystalActiveExplosions) {
+			gameState.cursedCrystalActiveExplosions.push({
+				x: self.x,
+				y: self.y,
+				radius: self.explosionRadius,
+				damage: self.explosionDamage,
+				durationTimer: 30,
+				// Klatki, przez które eksplozja zadaje obrażenia (np. 0.5s)
+				hitPlayerThisFrame: false // Flaga, aby zadać obrażenia tylko raz
+			});
+		}
+		// console.log("Pocisk eksplodował w: X=" + self.x.toFixed(0) + ", Y=" + self.y.toFixed(0));
+	};
+	return self;
+});
 // Zamykająca klamra dla Container.expand klasy Boss
 // --- POCZĄTEK BLOKU DO SKOPIOWANIA ---
 var Player = Container.expand(function () {
 	var self = Container.call(this);
@@ -1021,8 +1420,9 @@
 		if (!self.rolling && self.rollCooldown <= 0 && !self.dead) {
 			var targetScaleX = direction.x >= 0 || direction.x === 0 ? 1 : -1;
 			var currentRollDuration = duration || self.rollDuration;
 			self.rolling = true;
+			self.hasRolledThroughMinibossCCThisRoll = false;
 			self.rollDirection = direction;
 			self.rollCooldown = 45;
 			var durationRatio = currentRollDuration / self.rollDuration;
 			self.invulnerabilityFrames = Math.round(self.defaultInvulnerabilityFrames * durationRatio);
@@ -1386,9 +1786,24 @@
 					self.hasRolledThroughBossThisRoll = true;
 					LK.effects.flashObject(boss, 0x00FF00, 200);
 				}
 			}
-			// TODO: W Cursed Crystal, kolizja rolla z Duszami lub Minibossem CC będzie tutaj
+			if (gameState.currentState === "cursedCrystal" && gameState.isMinibossActiveCC === true && gameState.cursedCrystalMinibossObject && !gameState.cursedCrystalMinibossObject.isDead && !self.hasRolledThroughMinibossCCThisRoll) {
+				var minibossCC = gameState.cursedCrystalMinibossObject;
+				var dx_mcc = self.x - minibossCC.x;
+				var dy_mcc = self.y - minibossCC.y;
+				var distance_mcc = Math.sqrt(dx_mcc * dx_mcc + dy_mcc * dy_mcc);
+				// pWidth jest już obliczone wyżej w tym bloku if(self.rolling)
+				var playerRollRadius = pWidth / 2 * 0.8; // Efektywny promień gracza podczas rolla
+				var minibossCCRadius = (minibossCC.width || 120) / 2 * 0.9; // Efektywny promień Minibossa CC (asset ma 120x120, mnożnik 0.9 dla lekkiego zmniejszenia hitboxa)
+				if (distance_mcc < playerRollRadius + minibossCCRadius) {
+					minibossCC.takeDamage(10); // Zadaj 10 obrażeń
+					self.hasRolledThroughMinibossCCThisRoll = true; // Ustaw flagę, aby nie zadawać obrażeń wielokrotnie w tym samym rollu
+					// Możesz dodać efekt wizualny trafienia, np. flashObject dla Minibossa
+					// LK.effects.flashObject(minibossCC.graphics || minibossCC, 0x00FF00, 150); 
+					console.log("Player rolled through Miniboss CC and dealt damage!");
+				}
+			}
 		} else if (self.invulnerable && !self.rolling) {
 			// Niewrażliwość po otrzymaniu ciosu
 			if (currentVisualSprite) {
 				currentVisualSprite.alpha = Math.floor(Date.now() / 100) % 4 > 1 ? 0.3 : 1;
@@ -2272,8 +2687,67 @@
 				}
 				break;
 			case "cursedCrystalGameOver":
 				if (self.titleText) {
+					// Tekst i styl są ustawiane w gameState.endCursedCrystalMode
+					self.titleText.alpha = 1;
+					self.titleText.x = 2048 / 2;
+					self.titleText.y = 600; // Wyżej niż poprzednio
+					self.titleText.anchor.set(0.5);
+				}
+				if (self.messageText) {
+					// Tekst i styl są ustawiane w gameState.endCursedCrystalMode
+					self.messageText.alpha = 1;
+					self.messageText.x = 2048 / 2;
+					self.messageText.y = 800; // Pod tytułem
+					self.messageText.anchor.set(0.5, 0.5); // Wyśrodkowanie tekstu wieloliniowego
+				}
+				// Pozycjonowanie przycisków (zakładając, że są w gameState.activeButtons)
+				if (gameState.activeButtons && gameState.activeButtons.length > 0) {
+					var buttonYStart = 1100;
+					var buttonSpacing = 150;
+					gameState.activeButtons.forEach(function (button, index) {
+						if (button) {
+							button.x = 2048 / 2;
+							button.y = buttonYStart + index * buttonSpacing;
+							// Zakładamy, że przyciski mają anchor 0.5, 0.5 dla ich własnych BG i Text
+						}
+					});
+				}
+				// Ukryj elementy niepotrzebne na ekranie końca gry CC
+				if (self.heartContainer) {
+					self.heartContainer.alpha = 0;
+				}
+				if (self.timerText) {
+					self.timerText.alpha = 0;
+				} // Standardowy timer gry
+				if (self.highScoreText) {
+					self.highScoreText.alpha = 0;
+				} // Ten od Roll Master
+				if (self.bossHealthBarContainer) {
+					self.bossHealthBarContainer.alpha = 0;
+				}
+				if (self.deathsText) {
+					self.deathsText.alpha = 0;
+				}
+				if (self.tutorialText) {
+					self.tutorialText.alpha = 0;
+				}
+				// Ukryj UI specyficzne dla Cursed Crystal (w grze)
+				if (self.ccScoreText) {
+					self.ccScoreText.alpha = 0;
+				}
+				if (self.ccHighScoreText) {
+					self.ccHighScoreText.alpha = 0;
+				} // Ten od wyniku na żywo
+				if (self.crystalChargeBarContainer) {
+					self.crystalChargeBarContainer.alpha = 0;
+				}
+				// Upewnij się, że tło gry (jeśli jakieś jest) jest odpowiednie lub wyczyszczone
+				// game.setBackgroundColor(0x222222); // Np. ciemne tło
+				break;
+			case "cursedCrystalGameOver":
+				if (self.titleText) {
 					// Tekst ustawiany w gameState.endCursedCrystalMode
 					self.titleText.alpha = 1;
 					self.titleText.x = 2048 / 2;
 					self.titleText.y = 600;
@@ -2337,8 +2811,9 @@
 // Globalny kontener na elementy scen intro/tutoriali i Grill Screena (do łatwego czyszczenia)
 // Komentarze o assetach pominięte dla zwięzłości
 // Ciemnofioletowe tło
 // Fioletowy klejnot
+// Pomarańczowy kwadrat dla Minibossa
 if (typeof LK.getGameTime === 'undefined') {
 	LK.getGameTime = function () {
 		return Date.now(); // Zwraca aktualny czas w milisekundach
 	};
@@ -2394,9 +2869,9 @@
 	// Startowe HP gracza w tym trybie
 	cursedCrystalPlayerMaxHealth: 10,
 	cursedCrystalChargeLevel: 0,
 	// Aktualny poziom naładowania Klejnotu (0-100%)
-	cursedCrystalTargetCharge: 100,
+	cursedCrystalTargetCharge: 15,
 	// Wartość naładowania do przywołania Minibossa
 	cursedCrystalSoulsHitCrystal: 0,
 	// Licznik dusz, które dotarły do kryształu (do skalowania Minibossa)
 	cursedCrystalScore: 0,
@@ -2420,8 +2895,14 @@
 	isMinibossActiveCC: false,
 	cursedCrystalMinibossObject: null,
 	cursedCrystalMinibossHP: 0,
 	cursedCrystalMinibossMaxHP: 200,
+	cursedCrystalActiveProjectiles: [],
+	// Dla pocisków Minibossa
+	cursedCrystalActiveExplosions: [],
+	cursedCrystalActiveLasers: [],
+	cursedCrystalActiveLaserWalls: [],
+	// Dla aktywnych obszarów eksplozji
 	// Bazowe HP Minibossa, będzie skalowane
 	cursedCrystalMinibossAttackTimer: 0,
 	cursedCrystalMinibossAttackInterval: 180,
 	rollMasterTime: 0,
@@ -4416,20 +4897,68 @@
 		timeText.y = 2732 / 2 + 250;
 		currentSceneElements.addChild(timeText);
 		// Timeout przed przejściem do grillMenu
 		LK.setTimeout(function () {
-			console.log("DEBUG: Wykonuje się timeout w gameState.endRollMasterMode.");
-			clearScene(); // Czyści losowy mem śmierci i timeText
-			// Zniszcz gracza, jeśli istnieje
+			console.log("DEBUG: Wykonuje się timeout w gameState.gameOver. isDeath:", isDeath, "isNewBossPlusMode:", isNewBossPlusMode);
+			clearScene(); // Czyści losowy mem śmierci i extraText z currentSceneElements
+			// Niszczenie coffinDanceMeme jest teraz w onFinish jego tweentu
+			// Zniszcz gracza, bossa, tło...
 			if (player && player.destroy && !player.destroyed) {
 				player.destroy();
 			}
 			player = null;
-			// Przejdź do grillMenu
-			if (_this3 && typeof _this3.showGrillScreen === 'function') {
-				console.log("[EndRollMaster] Przechodzenie do showGrillScreen.");
-				_this3.showGrillScreen();
-			} else {/* ... obsługa błędu ... */}
+			if (boss && boss.destroy && !boss.destroyed) {
+				boss.destroy();
+			}
+			boss = null;
+			if (currentBackground) {
+				currentBackground.destroy();
+			}
+			currentBackground = null;
+			// Resetuj UI 
+			ui.titleText.setText("");
+			ui.titleText.alpha = 0;
+			ui.messageText.setText("");
+			ui.messageText.alpha = 0;
+			ui.tutorialText.setText("");
+			ui.tutorialText.alpha = 0;
+			ui.updateDeathsCounter();
+			ui.updateBossHealth(0, 1);
+			ui.updateHearts(0, parseInt(storage.maxHearts, 10) || 5);
+			// Logika przejścia do następnego stanu
+			if (isDeath && !isNewBossPlusMode) {
+				console.log("gameOver timeout: Standard death -> Restarting standard game...");
+				isNewBossPlusMode = false;
+				if (typeof gameState.startGame === 'function') {
+					gameState.startGame();
+				} else {
+					console.error("Nie można wywołać startGame po standardowej śmierci!");
+				}
+			} else if (isDeath && isNewBossPlusMode) {
+				console.log("gameOver timeout: Boss+ death -> Going to Grill Menu...");
+				isNewBossPlusMode = false;
+				if (typeof gameState.showGrillScreen === 'function') {
+					gameState.showGrillScreen();
+				} else {
+					console.error("Nie można wywołać showGrillScreen po śmierci w Boss+!");
+				}
+			} else if (!isDeath && isNewBossPlusMode) {
+				console.log("gameOver timeout: Boss+ timeout -> Going to Grill Menu...");
+				isNewBossPlusMode = false;
+				if (typeof gameState.showGrillScreen === 'function') {
+					gameState.showGrillScreen();
+				} else {
+					console.error("Nie można wywołać showGrillScreen po timeout w Boss+!");
+				}
+			} else {
+				console.log("gameOver timeout: Fallback case -> Going to Grill Menu...");
+				isNewBossPlusMode = false;
+				if (typeof gameState.showGrillScreen === 'function') {
+					gameState.showGrillScreen();
+				} else {
+					console.error("Nie można wywołać showGrillScreen w fallbacku gameOver!");
+				}
+			}
 		}, 5000);
 	},
 	startCursedCrystalMode: function startCursedCrystalMode() {
 		console.log("[StartCursedCrystal] Rozpoczynanie trybu Cursed Crystal...");
@@ -4693,8 +5222,222 @@
 		if (ui && ui.showMessage) {
 			ui.showMessage("Cursed Crystal - MINIMAL TEST (RollCD=0)", 3000);
 		}
 	},
+	endCursedCrystalMode: function endCursedCrystalMode(isVictory) {
+		console.log("DEBUG: gameState.endCursedCrystalMode called. Victory: " + isVictory);
+		this.currentState = "cursedCrystalGameOver";
+		// --- CZYSZCZENIE AKTYWNYCH ELEMENTÓW TRYBU CC ---
+		// 1. Dusze (SoulEnemy)
+		if (this.cursedCrystalEnemies && this.cursedCrystalEnemies.length > 0) {
+			console.log("DEBUG: Clearing " + this.cursedCrystalEnemies.length + " remaining SoulEnemies.");
+			this.cursedCrystalEnemies.forEach(function (enemy) {
+				if (enemy && enemy.destroy && !enemy.destroyed) {
+					if (enemy.parent) {
+						enemy.parent.removeChild(enemy);
+					}
+					enemy.destroy();
+				}
+			});
+		}
+		this.cursedCrystalEnemies = [];
+		// 2. Pociski Minibossa CC (jeśli gracz zginął, a boss jeszcze strzelał)
+		if (this.cursedCrystalActiveProjectiles && this.cursedCrystalActiveProjectiles.length > 0) {
+			console.log("DEBUG: Clearing " + this.cursedCrystalActiveProjectiles.length + " remaining projectiles.");
+			this.cursedCrystalActiveProjectiles.forEach(function (proj) {
+				if (proj && proj.destroy && !proj.destroyed) {
+					if (proj.graphics && proj.graphics.parent) {
+						proj.graphics.parent.removeChild(proj.graphics);
+					}
+					if (proj.graphics && proj.graphics.destroy) {
+						proj.graphics.destroy();
+					}
+					proj.destroy();
+				}
+			});
+		}
+		this.cursedCrystalActiveProjectiles = [];
+		// 3. Eksplozje Minibossa CC
+		if (this.cursedCrystalActiveExplosions && this.cursedCrystalActiveExplosions.length > 0) {
+			console.log("DEBUG: Clearing " + this.cursedCrystalActiveExplosions.length + " active explosions.");
+			// Wizualizacje eksplozji są zarządzane przez tweeny i powinny same zniknąć,
+			// ale czyścimy tablicę logiczną.
+		}
+		this.cursedCrystalActiveExplosions = [];
+		// 4. Ściany Laserowe Minibossa CC
+		if (this.cursedCrystalActiveLaserWalls && this.cursedCrystalActiveLaserWalls.length > 0) {
+			console.log("DEBUG: Clearing " + this.cursedCrystalActiveLaserWalls.length + " laser walls.");
+			this.cursedCrystalActiveLaserWalls.forEach(function (wall) {
+				if (wall && wall.segments) {
+					wall.segments.forEach(function (seg) {
+						if (seg.visual && seg.visual.destroy && !seg.visual.destroyed) {
+							if (seg.visual.parent) {
+								seg.visual.parent.removeChild(seg.visual);
+							}
+							seg.visual.destroy();
+						}
+					});
+				}
+				if (wall && wall.warningVisuals && wall.warningVisuals.length > 0) {
+					wall.warningVisuals.forEach(function (warnVis) {
+						if (warnVis && warnVis.destroy && !warnVis.destroyed) {
+							if (warnVis.parent) {
+								warnVis.parent.removeChild(warnVis);
+							}
+							warnVis.destroy();
+						}
+					});
+				}
+			});
+		}
+		this.cursedCrystalActiveLaserWalls = [];
+		// 5. Sam Miniboss CC (jeśli gracz zginął, a Miniboss nie został pokonany)
+		//    Metoda MinibossCC.die() czyści po sobie, gdy jest pokonany.
+		//    Jeśli gracz umiera, obiekt Minibossa może nadal istnieć.
+		if (!isVictory && this.cursedCrystalMinibossObject && !this.cursedCrystalMinibossObject.isDead) {
+			console.log("DEBUG: Player died, clearing active MinibossCC.");
+			if (this.cursedCrystalMinibossObject.parent) {
+				this.cursedCrystalMinibossObject.parent.removeChild(this.cursedCrystalMinibossObject);
+			}
+			if (this.cursedCrystalMinibossObject.destroy) {
+				this.cursedCrystalMinibossObject.destroy();
+			}
+		}
+		this.cursedCrystalMinibossObject = null;
+		this.isMinibossActiveCC = false;
+		// 6. Obiekt Klejnotu (jeśli był i nie został zniszczony przy spawnie minibossa)
+		if (typeof crystalCoreObject !== 'undefined' && crystalCoreObject && crystalCoreObject.destroy && !crystalCoreObject.destroyed) {
+			if (crystalCoreObject.parent) {
+				crystalCoreObject.parent.removeChild(crystalCoreObject);
+			}
+			crystalCoreObject.destroy();
+		}
+		crystalCoreObject = null;
+		// 7. Zatrzymaj muzykę Cursed Crystal, jeśli jest
+		// if (this.currentCursedCrystalMusic && this.currentCursedCrystalMusic.stop) {
+		//     this.currentCursedCrystalMusic.stop();
+		//     this.currentCursedCrystalMusic = null;
+		// }
+		// Uruchom muzykę menu/grilla (jeśli jest taka potrzeba, np. showGrillScreen to zrobi)
+		// --- LOGIKA WYNIKU I REKORDU ---
+		var finalScore = this.cursedCrystalScore;
+		if (isVictory) {
+			var minutesSurvived = Math.floor(this.cursedCrystalTimeSurvived / (60 * 60)); // Zakładając 60 FPS
+			var bonusPoints = 1000 + minutesSurvived * 100;
+			finalScore += bonusPoints;
+			console.log("DEBUG: Victory! Base score: " + this.cursedCrystalScore + ", Time survived (frames): " + this.cursedCrystalTimeSurvived + " (" + minutesSurvived + " min), Bonus: " + bonusPoints + ", Final score: " + finalScore);
+		}
+		this.cursedCrystalScore = finalScore; // Zaktualizuj wynik w gameState
+		var highScore = parseInt(storage.cursedCrystalHighScore, 10) || 0;
+		var newRecord = false;
+		if (finalScore > highScore) {
+			storage.cursedCrystalHighScore = finalScore;
+			highScore = finalScore;
+			newRecord = true;
+			console.log("DEBUG: New High Score for Cursed Crystal: " + highScore);
+		}
+		// --- WYŚWIETLANIE UI ---
+		if (ui) {
+			ui.titleText.setText(isVictory ? "ZWYCIĘSTWO!" : "PORAŻKA!");
+			ui.titleText.style = {
+				size: 120,
+				fill: isVictory ? 0x00FF00 : 0xFF0000,
+				align: 'center',
+				stroke: 0x000000,
+				strokeThickness: 6
+			};
+			var message = "Twój wynik: " + finalScore + "\n";
+			message += "Najlepszy wynik: " + highScore;
+			if (newRecord && isVictory) {
+				message += "\n(NOWY REKORD!)";
+			} else if (newRecord && !isVictory) {
+				message += "\n(Nowy rekord... mimo wszystko!)";
+			}
+			ui.messageText.setText(message);
+			ui.messageText.style = {
+				size: 70,
+				fill: 0xFFFFFF,
+				align: 'center',
+				stroke: 0x000000,
+				strokeThickness: 4
+			};
+			// Usunięcie starych przycisków, jeśli istnieją
+			if (this.activeButtons && this.activeButtons.length > 0) {
+				this.activeButtons.forEach(function (btn) {
+					if (btn && btn.destroy) {
+						btn.destroy();
+					}
+				});
+			}
+			this.activeButtons = [];
+			// Przycisk "Powrót do Menu"
+			var menuButton = new Container();
+			menuButton.interactive = true;
+			menuButton.cursor = "pointer";
+			var menuButtonBg = new Shape({
+				width: 400,
+				height: 100,
+				color: 0x555555,
+				shape: 'box'
+			}); // Placeholder
+			var menuButtonText = new Text2("Menu Główne", {
+				size: 40,
+				fill: 0xFFFFFF
+			});
+			menuButtonText.anchor.set(0.5);
+			menuButton.addChild(menuButtonBg);
+			menuButton.addChild(menuButtonText);
+			// Pozycja będzie ustawiona w ui.positionElements("cursedCrystalGameOver")
+			menuButton.down = function () {
+				if (gameState.currentState === "cursedCrystalGameOver") {
+					gameState.activeButtons.forEach(function (btn) {
+						if (btn && btn.destroy) {
+							btn.destroy();
+						}
+					});
+					gameState.activeButtons = [];
+					gameState.showGrillScreen();
+				}
+			};
+			currentSceneElements.addChild(menuButton); // Dodajemy do currentSceneElements
+			this.activeButtons.push(menuButton);
+			// Przycisk "Restartuj Tryb"
+			var restartButton = new Container();
+			restartButton.interactive = true;
+			restartButton.cursor = "pointer";
+			var restartButtonBg = new Shape({
+				width: 400,
+				height: 100,
+				color: 0x555555,
+				shape: 'box'
+			}); // Placeholder
+			var restartButtonText = new Text2("Restartuj Tryb", {
+				size: 40,
+				fill: 0xFFFFFF
+			});
+			restartButtonText.anchor.set(0.5);
+			restartButton.addChild(restartButtonBg);
+			restartButton.addChild(restartButtonText);
+			// Pozycja będzie ustawiona w ui.positionElements("cursedCrystalGameOver")
+			restartButton.down = function () {
+				if (gameState.currentState === "cursedCrystalGameOver") {
+					gameState.activeButtons.forEach(function (btn) {
+						if (btn && btn.destroy) {
+							btn.destroy();
+						}
+					});
+					gameState.activeButtons = [];
+					gameState.startCursedCrystalMode();
+				}
+			};
+			currentSceneElements.addChild(restartButton); // Dodajemy do currentSceneElements
+			this.activeButtons.push(restartButton);
+			// Upewnij się, że wszystkie elementy UI są widoczne
+			ui.titleText.alpha = 1;
+			ui.messageText.alpha = 1;
+			ui.positionElements("cursedCrystalGameOver"); // Pozycjonowanie po utworzeniu przycisków
+		}
+	},
 	processTouchGesture: function processTouchGesture() {
 		// ... (kod obsługi fake tutorial) ...
 		var dx = this.touchEnd.x - this.touchStart.x;
 		var dy = this.touchEnd.y - this.touchStart.y;
@@ -5234,48 +5977,42 @@
 }
 // --- Główna pętla aktualizacji gry ---
 game.update = function () {
 	if (gameState.currentState === "cursedCrystal") {
-		console.log("Game Update Tick - CURSED CRYSTAL"); // Log specyficzny dla CC
+		// console.log("Game Update Tick - CURSED CRYSTAL");
 	}
-	// Aktualizacja UI (wspólna dla wielu stanów)
 	if (ui) {
 		if (gameState.currentState !== "cursedCrystal" && gameState.currentState !== "cursedCrystalGameOver") {
-			ui.updateDeathsCounter(); // Licznik śmierci niepotrzebny w CC
+			ui.updateDeathsCounter();
 		}
 		if (boss && (gameState.currentState === "game" || gameState.currentState === "gameOver" && !gameOverReasonIsDeath && isNewBossPlusMode)) {
 			var maxHpBoss = boss.maxHealth > 0 ? boss.maxHealth : 1;
 			ui.updateBossHealth(boss.health, maxHpBoss);
 		} else if (gameState.currentState !== "cursedCrystal" && gameState.currentState !== "cursedCrystalGameOver") {
-			// Ukryj pasek bossa, jeśli nie jest w grze/gameover boss+ lub w trybie CC
 			ui.updateBossHealth(0, 1);
 		}
-		// Aktualizacja serc gracza dla trybów innych niż CC (dla CC jest w Player.takeDamage i setup)
 		if (player && gameState.currentState !== "cursedCrystal" && gameState.currentState !== "cursedCrystalGameOver") {
 			if (gameState.currentState === "rollMaster") {
 				ui.updateHearts(player.health, 1);
 			} else {
 				ui.updateHearts(player.health, parseInt(storage.maxHearts, 10) || 5);
 			}
 		} else if (gameState.currentState !== "game" && gameState.currentState !== "gameOver" && gameState.currentState !== "rollMaster" && gameState.currentState !== "cursedCrystal" && gameState.currentState !== "cursedCrystalGameOver") {
-			// Jeśli nie ma gracza i nie jesteśmy w aktywnych trybach walki ani CC, pokaż domyślne serca (np. dla menu)
-			ui.updateHearts(parseInt(storage.maxHearts, 10) || 5, parseInt(storage.maxHearts, 10) || 5); // Lub (0, max) jeśli chcesz puste
+			ui.updateHearts(parseInt(storage.maxHearts, 10) || 5, parseInt(storage.maxHearts, 10) || 5);
 		}
 	}
-	// Logika mema z trumną (tylko dla trybu "game")
 	if (coffinMemeImage && !coffinMemeImage.destroyed) {
 		if (gameState.currentState === "game" && player) {
-			// Upewnij się, że player istnieje
 			if (!player.dead) {
 				var currentHp = player.health;
 				var maxHp = parseInt(storage.maxHearts, 10) || 5;
-				var visibilityFactor = 1 - Math.max(0, currentHp) / maxHp; // Upewnij się, że currentHp nie jest ujemne
+				var visibilityFactor = 1 - Math.max(0, currentHp) / maxHp;
 				visibilityFactor = Math.max(0, Math.min(1, visibilityFactor));
 				var memeHeight = coffinMemeImage.height || 200;
 				var screenBottom = 2732;
 				var hiddenOffsetY = memeHeight;
 				var targetY = screenBottom + hiddenOffsetY * (1 - visibilityFactor) + 300;
-				var targetAlpha = visibilityFactor > 0.1 ? visibilityFactor * 0.8 : 0; // Mniejsza alfa, bardziej subtelne
+				var targetAlpha = visibilityFactor > 0.1 ? visibilityFactor * 0.8 : 0;
 				var positionChangeSpeed = 10;
 				var currentY = coffinMemeImage.y;
 				if (Math.abs(currentY - targetY) > 1) {
 					coffinMemeImage.y = currentY < targetY ? Math.min(targetY, currentY + positionChangeSpeed) : Math.max(targetY, currentY - positionChangeSpeed);
@@ -5285,20 +6022,17 @@
 				if (Math.abs(currentAlpha - targetAlpha) > 0.01) {
 					coffinMemeImage.alpha = currentAlpha < targetAlpha ? Math.min(targetAlpha, currentAlpha + alphaChangeSpeed) : Math.max(targetAlpha, currentAlpha - alphaChangeSpeed);
 				}
 			} else {
-				// Gracz jest martwy w trybie "game"
 				coffinMemeImage.y = 2932;
 				coffinMemeImage.alpha = 1.0;
 			}
 		} else if (gameState.currentState !== "gameOver") {
-			// Ukryj mema jeśli nie jesteśmy w grze i nie na gameOver
 			if (coffinMemeImage.alpha > 0) {
 				coffinMemeImage.alpha = Math.max(0, coffinMemeImage.alpha - 0.05);
 			}
 		}
 	}
-	// Główna logika stanów gry
 	if (gameState.currentState === "game") {
 		if (player) {
 			player.update();
 		}
@@ -5308,18 +6042,17 @@
 	} else if (gameState.currentState === "rollMaster") {
 		if (player) {
 			player.update();
 		}
-		// --- Logika spawnowania i aktualizacji ataków RollMaster (pozostaje bez zmian, skopiowana z Twojego kodu) ---
 		if (gameState.unlockedAttacks.includes('rmattack1')) {
 			if (!gameState.randomRmattack1Timer) {
 				var _spawnRandomRmattack = function spawnRandomRmattack1() {
 					if (gameState.currentState !== "rollMaster" || !gameState.unlockedAttacks.includes('rmattack1')) {
 						gameState.randomRmattack1Timer = null;
 						return;
 					}
 					launchRmattack1();
-					var nextDelay = 800 + Math.random() * 1500; // Zwiększono minimalne opóźnienie
+					var nextDelay = 800 + Math.random() * 1500;
 					gameState.randomRmattack1Timer = LK.setTimeout(_spawnRandomRmattack, nextDelay);
 				};
 				_spawnRandomRmattack();
 			}
@@ -5365,9 +6098,9 @@
 					if (player && !player.dead && !player.rolling && !player.invulnerable) {
 						var dx_p = player.x - atk.visual.x;
 						var dy_p = player.y - atk.visual.y;
 						var dist_p = Math.sqrt(dx_p * dx_p + dy_p * dy_p);
-						var playerRadius_p = player.width / 2 * 0.8;
+						var playerRadius_p = (player.width || 150) / 2 * 0.8;
 						var projectileRadius = atk.radius || 45;
 						if (dist_p < playerRadius_p + projectileRadius) {
 							player.takeDamage(1);
 							shouldRemove = true;
@@ -5388,9 +6121,9 @@
 					if (!atk.damageDealt && player && !player.dead && !player.rolling && !player.invulnerable) {
 						var dx_e = player.x - atk.visual.x;
 						var dy_e = player.y - atk.visual.y;
 						var dist_e = Math.sqrt(dx_e * dx_e + dy_e * dy_e);
-						var playerRadius_e = player.width / 2 * 0.8;
+						var playerRadius_e = (player.width || 150) / 2 * 0.8;
 						if (dist_e < playerRadius_e + atk.radius) {
 							player.takeDamage(1);
 							atk.damageDealt = true;
 						}
@@ -5399,18 +6132,18 @@
 				case 'laser':
 					if (player && !player.dead && !player.rolling && !player.invulnerable) {
 						var laserHalfWidth = (atk.width || 100) / 2;
 						var laserHalfHeight = (atk.height || 100) / 2;
-						var playerHalfWidth = player.width / 2 * 0.8;
-						var playerHalfHeight = player.height / 2 * 0.8;
+						var playerHalfWidth_l = (player.width || 150) / 2 * 0.8;
+						var playerHalfHeight_l = (player.height || 150) / 2 * 0.8;
 						var laserLeft = atk.visual.x - laserHalfWidth;
 						var laserRight = atk.visual.x + laserHalfWidth;
 						var laserTop = atk.visual.y - laserHalfHeight;
 						var laserBottom = atk.visual.y + laserHalfHeight;
-						var playerLeft = player.x - playerHalfWidth;
-						var playerRight = player.x + playerHalfWidth;
-						var playerTop = player.y - playerHalfHeight;
-						var playerBottom = player.y + playerHalfHeight;
+						var playerLeft = player.x - playerHalfWidth_l;
+						var playerRight = player.x + playerHalfWidth_l;
+						var playerTop = player.y - playerHalfHeight_l;
+						var playerBottom = player.y + playerHalfHeight_l;
 						if (laserLeft < playerRight && laserRight > playerLeft && laserTop < playerBottom && laserBottom > playerTop) {
 							player.takeDamage(1);
 						}
 					}
@@ -5422,24 +6155,24 @@
 					atk.timer--;
 					if (atk.timer <= 0) {
 						var originX = atk.visual.x;
 						var originY = atk.visual.y;
-						var projectileSpeed = 5 + gameState.rollMasterDifficulty * 0.5;
-						var projectileRadius = 45;
-						var numProjectiles = 12;
-						for (var j = 0; j < numProjectiles; j++) {
-							var angle = Math.PI * 2 / numProjectiles * j;
-							var vx = Math.cos(angle) * projectileSpeed;
-							var vy = Math.sin(angle) * projectileSpeed;
-							var projectileFrames = [];
-							for (var k = 0; k <= 6; k++) {
-								projectileFrames.push(LK.getAsset('rmattack1_' + k, {
+						var projectileSpeed_s = 5 + gameState.rollMasterDifficulty * 0.5;
+						var projectileRadius_s = 45;
+						var numProjectiles_s = 12;
+						for (var j = 0; j < numProjectiles_s; j++) {
+							var angle_s = Math.PI * 2 / numProjectiles_s * j;
+							var vx_s = Math.cos(angle_s) * projectileSpeed_s;
+							var vy_s = Math.sin(angle_s) * projectileSpeed_s;
+							var projectileFrames_s = [];
+							for (var k_s = 0; k_s <= 6; k_s++) {
+								projectileFrames_s.push(LK.getAsset('rmattack1_' + k_s, {
 									anchorX: 0.5,
 									anchorY: 0.5
 								}));
 							}
-							var projectileVisual = new SpriteAnimation({
-								frames: projectileFrames,
+							var projectileVisual_s = new SpriteAnimation({
+								frames: projectileFrames_s,
 								frameDuration: 100,
 								loop: true,
 								x: originX,
 								y: originY,
@@ -5447,128 +6180,253 @@
 								anchorY: 0.5,
 								scaleX: 1.2,
 								scaleY: 1.2
 							});
-							projectileVisual.rotation = Math.atan2(vy, vx);
-							var projectileObject = game.addChild(projectileVisual);
+							projectileVisual_s.rotation = Math.atan2(vy_s, vx_s);
+							var projectileObject_s = game.addChild(projectileVisual_s);
 							gameState.rollMasterAttacks.push({
 								type: 'projectile',
-								visual: projectileObject,
-								vx: vx,
-								vy: vy,
-								radius: projectileRadius
+								visual: projectileObject_s,
+								vx: vx_s,
+								vy: vy_s,
+								radius: projectileRadius_s
 							});
 						}
 						shouldRemove = true;
 					}
 					break;
-				// Typy 'line' i 'circle' są z trybu bossa, nie powinny tu być, ale zostawiam na wszelki wypadek
-				case 'line':
-				case 'circle':
-					atk.lifeTime--;
-					if (player && !player.dead && !player.rolling && !player.invulnerable) {
-						var dx_lc = player.x - atk.visual.x;
-						var dy_lc = player.y - atk.visual.y;
-						var distance_lc = Math.sqrt(dx_lc * dx_lc + dy_lc * dy_lc);
-						var playerRadius_lc = player.width / 2 * 0.8;
-						var attackRadius_lc = atk.radius;
-						if (distance_lc < playerRadius_lc + attackRadius_lc) {
-							player.takeDamage(1);
-							shouldRemove = true;
-						}
-					}
-					if (atk.lifeTime <= 0) {
-						shouldRemove = true;
-					}
-					break;
 				default:
 					console.warn("Nieznany typ ataku w RollMaster: ", atk.type, atk);
 					break;
 			}
 			if (shouldRemove) {
 				if (atk.visual && atk.visual.destroy && !atk.visual.destroyed) {
 					if (atk.visual.parent) {
 						atk.visual.parent.removeChild(atk.visual);
-					} // Dodatkowe zabezpieczenie
+					}
 					atk.visual.destroy();
 				}
 				gameState.rollMasterAttacks.splice(i, 1);
 			}
 		}
 		if (player && player.dead && gameState.currentState === "rollMaster") {
-			// Sprawdzaj stan przed wywołaniem
 			if (typeof gameState.endRollMasterMode === 'function') {
 				gameState.endRollMasterMode(gameState.rollMasterTime);
 			} else {
 				console.error("Cannot call endRollMasterMode, function undefined");
 			}
 		}
 	} else if (gameState.currentState === "cursedCrystal") {
 		if (player) {
-			player.update(); // Aktualizacja gracza
+			player.update();
 		}
-		// --- Logika Spawnowania Dusz ---
-		gameState.cursedCrystalEnemySpawnTimer++; // Zwiększ timer spawnu
-		if (gameState.cursedCrystalEnemySpawnTimer >= gameState.cursedCrystalCurrentSpawnInterval) {
-			gameState.cursedCrystalEnemySpawnTimer = 0; // Zresetuj timer
-			spawnCursedSoul(); // Wywołaj funkcję spawnowania nowej Duszy
+		if (!gameState.isMinibossActiveCC) {
+			gameState.cursedCrystalTimeSurvived++;
+			gameState.cursedCrystalEnemySpawnTimer++;
+			if (gameState.cursedCrystalEnemySpawnTimer >= gameState.cursedCrystalCurrentSpawnInterval) {
+				gameState.cursedCrystalEnemySpawnTimer = 0;
+				spawnCursedSoul();
+			}
+			gameState.cursedCrystalDifficultyTimer++;
+			if (gameState.cursedCrystalDifficultyTimer >= gameState.cursedCrystalDifficultyInterval) {
+				gameState.cursedCrystalDifficultyTimer = 0;
+				var spawnIntervalDecrease = 5;
+				gameState.cursedCrystalCurrentSpawnInterval = Math.max(gameState.cursedCrystalMinSpawnInterval, gameState.cursedCrystalCurrentSpawnInterval - spawnIntervalDecrease);
+				var speedIncrease = 0.25;
+				gameState.cursedCrystalEnemyCurrentMaxSpeed += speedIncrease;
+			}
 		}
-		// --- Logika Aktualizacji Dusz (ruch, kolizje) ---
-		// TO ZOSTANIE DODANE W NASTĘPNYM KROKU
-		// for (var i = gameState.cursedCrystalEnemies.length - 1; i >= 0; i--) {
-		//     var enemy = gameState.cursedCrystalEnemies[i];
-		//     if (enemy && !enemy.isDead) { // Upewnij się, że wróg istnieje i nie jest już martwy
-		//         enemy.update(); // Metoda update z SoulEnemy (ruch w kierunku klejnotu)
-		//         // Kolizja Duszy z Klejnotem jest obsługiwana w enemy.update() -> enemy.onHitCrystal()
-		//         // TODO: Kolizja "rolla" gracza z Duszami
-		//         // if (player && player.rolling && !player.invulnerable && /* warunek kolizji */) {
-		//         //     enemy.takeDamage(1); // Przykładowe obrażenia
-		//         //     // Możliwe, że gracz powinien zadać obrażenia tylko jednej Duszy na roll,
-		//         //     // lub że Dusza powinna mieć cooldown na otrzymywanie obrażeń.
-		//         // }
-		//     }
-		//     // Usuwanie martwych Dusz (które zginęły od gracza lub uderzyły w klejnot i same się zniszczyły)
-		//     // Metody SoulEnemy.die() i SoulEnemy.onHitCrystal() powinny usuwać obiekt z `game`
-		//     // i oznaczać isDead. Tutaj tylko usuwamy z tablicy gameState.cursedCrystalEnemies.
-		//     if (enemy && enemy.isDead) {
-		//         gameState.cursedCrystalEnemies.splice(i, 1);
-		//     }
-		// }
-		// --- Logika Zwiększania Trudności ---
-		// TO ZOSTANIE DODANE PÓŹNIEJ
-		// gameState.cursedCrystalDifficultyTimer++;
-		// if (gameState.cursedCrystalDifficultyTimer >= gameState.cursedCrystalDifficultyInterval) {
-		//     gameState.cursedCrystalDifficultyTimer = 0;
-		//     // increaseCursedCrystalDifficulty(); // Funkcja do zaimplementowania
-		// }
-		// --- Logika Minibossa (jeśli aktywny) ---
-		// TO ZOSTANIE DODANE PÓŹNIEJ
-		// if (gameState.isMinibossActiveCC && gameState.cursedCrystalMinibossObject) {
-		//    gameState.cursedCrystalMinibossObject.update();
-		//    // Kolizje Minibossa z graczem, rollem gracza
-		// }
-		// Sprawdzenie warunków zakończenia gry
-		if (player && player.dead) {
-			// Funkcja player.die() dla trybu "cursedCrystal" powinna już wywołać 
-			// gameState.endCursedCrystalMode(false), więc nie ma potrzeby robić tego tutaj ponownie.
-			// console.log("Cursed Crystal: Player is dead, endCursedCrystalMode should have been called.");
+		for (var i = gameState.cursedCrystalEnemies.length - 1; i >= 0; i--) {
+			var enemy = gameState.cursedCrystalEnemies[i];
+			if (!enemy) {
+				gameState.cursedCrystalEnemies.splice(i, 1);
+				continue;
+			}
+			if (enemy.isDead) {
+				gameState.cursedCrystalEnemies.splice(i, 1);
+				continue;
+			}
+			enemy.update();
+			if (enemy.isDead) {
+				gameState.cursedCrystalEnemies.splice(i, 1);
+				continue;
+			}
+			if (player && player.rolling && player.invulnerable) {
+				var dx_soul = player.x - enemy.x;
+				var dy_soul = player.y - enemy.y;
+				var distance_soul = Math.sqrt(dx_soul * dx_soul + dy_soul * dy_soul);
+				var playerRollRadius_soul = (player.width || 150) / 2 * 0.7;
+				var soulRadius_coll = (enemy.width || 30) / 2 * 0.8;
+				if (distance_soul < playerRollRadius_soul + soulRadius_coll) {
+					enemy.takeDamage(1);
+				}
+			}
 		}
-		// TODO: Sprawdzenie, czy Miniboss został pokonany (jeśli jest aktywny) -> gameState.endCursedCrystalMode(true)
-		// Aktualizacja elementów UI specyficznych dla Cursed Crystal, które tego wymagają w pętli gry.
-		// Wiele aktualizacji UI (wynik, pasek naładowania) dzieje się teraz w metodach SoulEnemy.
-		// Pasek HP Minibossa będzie wymagał aktualizacji tutaj, gdy miniboss zostanie dodany.
-		// if (ui) {
-		//     if (gameState.isMinibossActiveCC && gameState.cursedCrystalMinibossObject) {
-		//         ui.updateMinibossHealthCC(gameState.cursedCrystalMinibossHP, gameState.cursedCrystalMinibossMaxHP, true);
-		//     } else if (ui.bossHealthBarContainer && ui.bossHealthBarContainer.alpha !== 0) { 
-		//          // Ukryj pasek, jeśli nie ma minibossa, a jest widoczny
-		//         ui.updateMinibossHealthCC(0, 1, false);
-		//     }
-		// }
+		if (!gameState.isMinibossActiveCC && gameState.cursedCrystalChargeLevel >= gameState.cursedCrystalTargetCharge) {
+			gameState.isMinibossActiveCC = true;
+			console.log("MINIBOSS SPAWNING! Charge: " + gameState.cursedCrystalChargeLevel + "/" + gameState.cursedCrystalTargetCharge);
+			var crystalPosX = 2048 / 2;
+			var crystalPosY = 2732 / 2;
+			if (typeof crystalCoreObject !== 'undefined' && crystalCoreObject && !crystalCoreObject.destroyed) {
+				crystalPosX = crystalCoreObject.x;
+				crystalPosY = crystalCoreObject.y;
+				if (crystalCoreObject.parent) {
+					crystalCoreObject.parent.removeChild(crystalCoreObject);
+				}
+				crystalCoreObject.destroy();
+				crystalCoreObject = null;
+			}
+			var timeSurvivedInMinutes = Math.floor(gameState.cursedCrystalTimeSurvived / 3600);
+			var baseMinibossHp = 100;
+			var hpPerMinute = 100;
+			var scaledMaxHp = baseMinibossHp + timeSurvivedInMinutes * hpPerMinute;
+			scaledMaxHp = Math.max(baseMinibossHp, scaledMaxHp);
+			gameState.cursedCrystalMinibossMaxHP = scaledMaxHp;
+			gameState.cursedCrystalMinibossHP = scaledMaxHp;
+			var minibossOptions = {
+				maxHp: scaledMaxHp,
+				x: crystalPosX,
+				y: crystalPosY
+			};
+			gameState.cursedCrystalEnemies.forEach(function (soul) {
+				if (soul && !soul.isDead) {
+					if (soul.parent) {
+						soul.parent.removeChild(soul);
+					}
+					if (soul.destroy) {
+						soul.destroy();
+					}
+				}
+			});
+			gameState.cursedCrystalEnemies = [];
+			gameState.cursedCrystalMinibossObject = game.addChild(new MinibossCC(minibossOptions));
+			if (ui && ui.updateMinibossHealthCC) {
+				ui.updateMinibossHealthCC(gameState.cursedCrystalMinibossHP, gameState.cursedCrystalMinibossMaxHP, true);
+			}
+			if (ui && ui.showMessage) {
+				ui.showMessage("The Guardian Wakes!", 3000);
+			}
+		}
+		if (gameState.isMinibossActiveCC && gameState.cursedCrystalMinibossObject && !gameState.cursedCrystalMinibossObject.isDead) {
+			gameState.cursedCrystalMinibossObject.update();
+		}
+		// --- Aktualizacja Pocisków Minibossa ---
+		if (typeof gameState.cursedCrystalActiveProjectiles === 'undefined' || !gameState.cursedCrystalActiveProjectiles) {
+			gameState.cursedCrystalActiveProjectiles = [];
+		}
+		for (var k = gameState.cursedCrystalActiveProjectiles.length - 1; k >= 0; k--) {
+			var projectile = gameState.cursedCrystalActiveProjectiles[k];
+			if (!projectile || projectile.isDead) {
+				if (projectile && projectile.graphics && projectile.graphics.parent) {
+					projectile.graphics.parent.removeChild(projectile.graphics);
+					if (projectile.graphics.destroy) {
+						projectile.graphics.destroy();
+					}
+				}
+				gameState.cursedCrystalActiveProjectiles.splice(k, 1);
+				continue;
+			}
+			projectile.update();
+			if (projectile.isDead) {
+				if (projectile.graphics && projectile.graphics.parent) {
+					projectile.graphics.parent.removeChild(projectile.graphics);
+					if (projectile.graphics.destroy) {
+						projectile.graphics.destroy();
+					}
+				}
+				gameState.cursedCrystalActiveProjectiles.splice(k, 1);
+			}
+		}
+		// --- Sprawdzanie Obrażeń od Eksplozji Minibossa ---
+		if (typeof gameState.cursedCrystalActiveExplosions === 'undefined' || !gameState.cursedCrystalActiveExplosions) {
+			gameState.cursedCrystalActiveExplosions = [];
+		}
+		for (var expIdx = gameState.cursedCrystalActiveExplosions.length - 1; expIdx >= 0; expIdx--) {
+			var explosion = gameState.cursedCrystalActiveExplosions[expIdx];
+			if (!explosion) {
+				gameState.cursedCrystalActiveExplosions.splice(expIdx, 1);
+				continue;
+			}
+			explosion.durationTimer--;
+			if (player && !player.dead && !player.invulnerable && !explosion.hitPlayerThisFrame) {
+				var distToExplosion = Math.sqrt(Math.pow(player.x - explosion.x, 2) + Math.pow(player.y - explosion.y, 2));
+				if (distToExplosion < (player.width || 150) / 2 * 0.7 + explosion.radius) {
+					player.takeDamage(explosion.damage);
+					explosion.hitPlayerThisFrame = true;
+				}
+			}
+			if (explosion.durationTimer <= 0) {
+				gameState.cursedCrystalActiveExplosions.splice(expIdx, 1);
+			}
+		}
+		// --- LOGIKA DLA AKTYWNYCH ŚCIAN LASEROWYCH MINIBOSSA ---
+		if (typeof gameState.cursedCrystalActiveLaserWalls === 'undefined' || !gameState.cursedCrystalActiveLaserWalls) {
+			gameState.cursedCrystalActiveLaserWalls = [];
+		}
+		for (var wallIdx = gameState.cursedCrystalActiveLaserWalls.length - 1; wallIdx >= 0; wallIdx--) {
+			var wall = gameState.cursedCrystalActiveLaserWalls[wallIdx];
+			if (!wall || wall.isDead) {
+				// Upewnij się, że wszystkie wizualizacje segmentów są usunięte, jeśli ściana jest martwa
+				if (wall && wall.segments) {
+					wall.segments.forEach(function (seg) {
+						if (seg.visual && seg.visual.parent) {
+							seg.visual.parent.removeChild(seg.visual);
+							if (seg.visual.destroy) {
+								seg.visual.destroy();
+							}
+						}
+					});
+				}
+				gameState.cursedCrystalActiveLaserWalls.splice(wallIdx, 1);
+				continue;
+			}
+			// Sprawdź, czy wizualizacje segmentów już istnieją (tj. czy faza ostrzeżenia minęła)
+			if (wall.segments.length > 0 && wall.segments[0].visual) {
+				wall.activeTimer -= 1000 / 60; // Zmniejsz timer aktywności (w ms)
+				if (wall.activeTimer > 0) {
+					wall.currentAngle += wall.rotationSpeed; // Obracaj ścianę
+					wall.segments.forEach(function (segment) {
+						// Oblicz nową pozycję segmentu na podstawie obrotu ściany
+						var rotatedOffsetX = segment.initialOffsetX * Math.cos(wall.currentAngle) - segment.initialOffsetY * Math.sin(wall.currentAngle);
+						var rotatedOffsetY = segment.initialOffsetX * Math.sin(wall.currentAngle) + segment.initialOffsetY * Math.cos(wall.currentAngle);
+						segment.currentX = wall.pivotX + rotatedOffsetX;
+						segment.currentY = wall.pivotY + rotatedOffsetY;
+						if (segment.visual) {
+							segment.visual.x = segment.currentX;
+							segment.visual.y = segment.currentY;
+							segment.visual.rotation = wall.currentAngle; // Obróć również grafikę segmentu
+							if (typeof segment.visual.update === 'function') {
+								// Dla SpriteAnimation
+								segment.visual.update();
+							}
+							// Kolizja z graczem dla tego segmentu
+							if (player && !player.dead && !player.invulnerable) {
+								// Prosta kolizja AABB (można ulepszyć dla obróconych prostokątów)
+								var playerHalfWidth_lw = (player.width || 150) / 2 * 0.7;
+								var playerHalfHeight_lw = (player.height || 150) / 2 * 0.7;
+								var segmentHalfWidth_lw = segment.width / 2;
+								var segmentHalfHeight_lw = segment.height / 2;
+								// Używamy aktualnej pozycji segmentu (segment.currentX, segment.currentY)
+								if (Math.abs(player.x - segment.currentX) < playerHalfWidth_lw + segmentHalfWidth_lw && Math.abs(player.y - segment.currentY) < playerHalfHeight_lw + segmentHalfHeight_lw) {
+									player.takeDamage(1);
+									// Można dodać flagę trafienia dla tego segmentu/ściany, aby uniknąć wielokrotnych trafień w tej samej klatce
+								}
+							}
+						}
+					});
+				} else {
+					// Czas aktywności ściany minął
+					wall.isDead = true; // Oznacz do usunięcia (grafiki są usuwane w pętli powyżej przy isDead)
+				}
+			}
+			// Jeśli segment.visual jeszcze nie istnieje, to znaczy, że jesteśmy w fazie ostrzeżenia,
+			// która jest zarządzana przez setTimeout w MinibossCC.performAttack.
+			// Tutaj nie ma potrzeby dodatkowej logiki dla samej fazy ostrzeżenia.
+		}
+		if (player && player.dead) {/* Obsługiwane przez player.die() */}
 	}
-	// Inne stany (title, gameOver, grillMenu etc.) nie mają zazwyczaj aktywnej logiki w game.update,
-	// ale mogą mieć np. animacje UI, które są obsługiwane przez LK lub tween.
-}; // Koniec game.update
+};
+// -------- KONIEC CAŁEJ, PEŁNEJ, ZAKTUALIZOWANEJ FUNKCJI game.update -------- // Koniec game.update
 // --- Rozpoczęcie gry ---
 // Zakładamy, że obiekt gameState jest zdefiniowany gdzieś wcześniej w kodzie
 if (typeof gameState !== 'undefined' && typeof gameState.init === 'function') {
 	gameState.init();
Showing 226 to 250 of 1089
1...89101112...44

Images

Sounds & Music

🎶

RollSouls

Music

🎶

introMusic

Music

🎵

rollmaster

Sound effect

🎶

CursedCrystal

Music

🎶

cursedcrystal2

Music

Used plugins

@upit/tween@upit/storage
Home
Discover
Play
Profile