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

/**** 
* Classes
****/ 
/** 
* BeatCell
* Responsibility: To model the state of a single cell on the beat grid. It no longer
* handles its own graphics updates directly, this is delegated to the GridService.
*/ 
var BeatCell = Container.expand(function (row) {
	var self = Container.call(this);
	self.active = false;
	self.row = row; // Know its row for external logic to interpret
	// Initialize with appropriate beat tile at 20% transparency
	var assetId = 'cell';
	if (row === 0) {
		assetId = 'cellActive';
	} else if (row === 1) {
		assetId = 'cellLeft';
	} else if (row === 2) {
		assetId = 'cellRight';
	} else if (row === 3) {
		assetId = 'cellDown';
	}
	self.gfx = self.attachAsset(assetId, {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0.1
	});
	self.toggle = function () {
		self.active = !self.active;
	};
	self.setActive = function (val) {
		if (self.active !== val) {
			self.toggle();
		}
	};
	// The `down` event is removed and is now handled by the central InputService.
	return self;
});
/** 
* Coin
* Responsibility: Collectible coin that can be picked up by the hero
*/ 
var Coin = Container.expand(function () {
	var self = Container.call(this);
	self.gfx = self.attachAsset('coin', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.collected = false;
	// Add wobble animation with random offset
	self.wobbleOffset = Math.random() * Math.PI * 2; // Random starting phase
	self.wobbleSpeed = 0.0015 + Math.random() * 0.001; // Slightly varied speed
	self.wobbleAmount = 0.05 + Math.random() * 0.02; // 5-7 degrees in radians
	self.wobbleDirection = Math.random() > 0.5 ? 1 : -1; // Random initial direction
	self.baseRotation = 0;
	self.update = function () {
		if (!self.collected) {
			// Calculate wobble using sine wave
			var time = Date.now() * self.wobbleSpeed + self.wobbleOffset;
			self.gfx.rotation = self.baseRotation + Math.sin(time) * self.wobbleAmount * self.wobbleDirection;
		}
	};
	self.collect = function () {
		if (!self.collected) {
			self.collected = true;
			tween(self, {
				scaleX: 1.5,
				scaleY: 1.5,
				alpha: 0
			}, {
				duration: 300,
				easing: tween.cubicOut,
				onComplete: function onComplete() {
					self.destroy();
					// checkRoundCompletion(); // removed: collecting a coin no longer completes the level
				}
			});
		}
	};
	return self;
});
/** 
* AntiCheatService
* Responsibility: Manages disabling random cells from each beat layer each round
*/ 
/** 
* Hero
* Responsibility: To model the player character. It manages its own state and animations,
* but no longer triggers its own sound effects.
*/ 
var Hero = Container.expand(function () {
	var self = Container.call(this);
	self.gfx = self.attachAsset('hero', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.currentCol = 0;
	self.gridRow = GameConstants.CHAR_ROW;
	// Track last direction and up-walk alternation
	self.lastDirection = "down"; // "left", "right", "up", "down"
	self.lastEat = false;
	self.upWalkAlt = false; // toggles for up-walk alternation
	// Helper to set hero frame based on direction and eating state
	self.setFrame = function (direction, isEating, isUpWalkAlt) {
		// Only update if changed
		var assetId = "hero";
		if (direction === "left") {
			assetId = isEating ? "Hero_Left_Eat" : "Hero_Left_Walk";
		} else if (direction === "right") {
			assetId = isEating ? "Hero_Right_Eat" : "Hero_Right_Walk";
		} else if (direction === "up") {
			assetId = isUpWalkAlt ? "Hero_Back_Walk_2" : "Hero_Back_Walk";
		} else if (direction === "down") {
			assetId = "hero";
		}
		// Only swap if different
		if (!self.gfx.assetId || self.gfx.assetId !== assetId) {
			if (self.gfx) {
				self.gfx.destroy();
			}
			self.gfx = self.attachAsset(assetId, {
				anchorX: 0.5,
				anchorY: 0.5
			});
			self.gfx.assetId = assetId; // Track for future checks
		}
		self.lastDirection = direction;
		self.lastEat = isEating;
		if (direction === "up") {
			self.upWalkAlt = isUpWalkAlt;
		}
	};
	self.moveTo = function (nx, ny, duration) {
		tween(self, {
			x: nx,
			y: ny
		}, {
			duration: duration || 180,
			easing: tween.cubicOut
		});
	};
	return self;
});
/** 
* Key
* Responsibility: Static visual marker for the key
*/ 
var Key = Container.expand(function () {
	var self = Container.call(this);
	self.gfx = self.attachAsset('key', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	return self;
});
/** 
* Princess
* Responsibility: Static visual marker for the princess goal
*/ 
var Princess = Container.expand(function () {
	var self = Container.call(this);
	self.gfx = self.attachAsset('princess', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	return self;
});

/**** 
* Initialize Game
****/ 
/************************* 
* SERVICES
*************************/ 
/** 
* AudioService
* Responsibility: To handle all requests to play sounds and music.
*/ 
/************************* 
* INITIALIZE & RUN GAME
*************************/ 
// 1. Create Game Instance
var game = new LK.Game({
	backgroundColor: 0xffffff
});

/**** 
* Game Code
****/ 
// Create layered containers for proper z-ordering
var backgroundContainer = new Container();
var midgroundContainer = new Container();
var foregroundContainer = new Container();
// Add containers to game in correct order
game.addChild(backgroundContainer);
game.addChild(midgroundContainer);
game.addChild(foregroundContainer);
/** 
* GameGrid
* Responsibility: Centralizes the entire grid (playable + beat area) into a single class.
* Provides accessors for both the playable area and the beat grid, and manages their state.
*/ 
/************************* 
* CORE GAME OBJECTS
*************************/ 
// 2. Instantiate All Services
/************************* 
* ASSETS & PLUGINS
*************************/ 
// Assets (Unchanged)
// Plugins (Unchanged)
/************************* 
* GAME CONFIGURATION
*************************/ 
/** 
* GameConstants
* Responsibility: To hold all static configuration and magic numbers in one place
* for easy tuning and maintenance.
*/ 
/** 
* AntiCheatService
* Responsibility: Manages disabling random cells from each beat layer each round
*/ 
function AntiCheatService(gridService, gameGrid) {
	this.gridService = gridService;
	this.gameGrid = gameGrid;
	this.disabledCells = []; // Array to store currently disabled cells
	this.prevDisabledCells = []; // Track previously disabled cells for re-enabling
	this.cellsPerLayer = 2; // Number of cells to disable per layer
	this.initialize = function () {
		// Disable initial cells for round 1
		this.disableRandomCells();
	};
	this.disableRandomCells = function () {
		// Store previously disabled cells
		this.prevDisabledCells = this.disabledCells.slice();
		this.disabledCells = [];
		// Process rows in order: up (0), left (1), right (2), down (3)
		for (var r = 0; r < GameConstants.BEAT_ROWS; r++) {
			var availableCols = [];
			// Get all columns for this row, excluding previously disabled ones
			for (var c = 0; c < GameConstants.GRID_COLS; c++) {
				var isValid = true;
				// Check if this column was previously disabled for this row
				for (var p = 0; p < this.prevDisabledCells.length; p++) {
					if (this.prevDisabledCells[p].row === r && this.prevDisabledCells[p].col === c) {
						isValid = false;
						break;
					}
				}
				// Check minimum distance constraint from already disabled cells in this row
				for (var d = 0; d < this.disabledCells.length; d++) {
					if (this.disabledCells[d].row === r) {
						var distance = Math.abs(this.disabledCells[d].col - c);
						if (distance < 3) {
							// Minimum 2 tiles between disabled cells
							isValid = false;
							break;
						}
					}
				}
				// Check diagonal constraint for rows below the first
				if (r > 0) {
					// Only check the immediately previous row for diagonal constraints
					var prevRow = r - 1;
					for (var d = 0; d < this.disabledCells.length; d++) {
						if (this.disabledCells[d].row === prevRow) {
							var prevCol = this.disabledCells[d].col;
							// Check if this column is diagonally adjacent to a disabled cell in the previous row
							if (c === prevCol - 1 || c === prevCol || c === prevCol + 1) {
								isValid = false;
								break;
							}
						}
					}
				}
				if (isValid) {
					availableCols.push(c);
				}
			}
			// Select cells with minimum distance constraint
			var selectedCols = [];
			var attempts = 0;
			while (selectedCols.length < this.cellsPerLayer && availableCols.length > 0 && attempts < 100) {
				attempts++;
				// Pick a random column from available
				var randomIndex = Math.floor(Math.random() * availableCols.length);
				var col = availableCols[randomIndex];
				// Check if this column maintains minimum distance from already selected
				var validChoice = true;
				for (var s = 0; s < selectedCols.length; s++) {
					if (Math.abs(selectedCols[s] - col) < 3) {
						validChoice = false;
						break;
					}
				}
				if (validChoice) {
					selectedCols.push(col);
					// Remove this column and nearby columns from available
					availableCols = availableCols.filter(function (c) {
						return Math.abs(c - col) >= 3;
					});
				} else {
					// Remove this column as it's too close
					availableCols.splice(randomIndex, 1);
				}
			}
			// Disable the selected columns
			for (var i = 0; i < selectedCols.length; i++) {
				var col = selectedCols[i];
				var cell = this.gameGrid.getBeatCell(r, col);
				if (cell) {
					this.disabledCells.push({
						row: r,
						col: col,
						cell: cell
					});
					// Hide the cell
					cell.visible = false;
				}
			}
		}
	};
	this.reset = function () {
		// First, enable ALL cells in the beat grid
		for (var r = 0; r < GameConstants.BEAT_ROWS; r++) {
			for (var c = 0; c < GameConstants.GRID_COLS; c++) {
				var cell = this.gameGrid.getBeatCell(r, c);
				if (cell) {
					cell.visible = true;
				}
			}
		}
		// Clear both arrays to start fresh
		this.prevDisabledCells = [];
		this.disabledCells = [];
		// Disable new random cells with a completely new pattern
		this.disableRandomCells();
	};
	// Check if a cell is disabled
	this.isCellDisabled = function (beatRow, col) {
		for (var i = 0; i < this.disabledCells.length; i++) {
			var disabled = this.disabledCells[i];
			if (disabled.row === beatRow && disabled.col === col) {
				return true;
			}
		}
		return false;
	};
}
function GameGrid(game) {
	this.game = game;
	this.rows = GameConstants.TOTAL_ROWS;
	this.cols = GameConstants.GRID_COLS;
	this.grid = []; // 2D array: [row][col] for all rows (playable + beat)
	this.beatRows = GameConstants.BEAT_ROWS;
	this.playableRows = this.rows - this.beatRows;
	// Initialize grid with nulls
	for (var r = 0; r < this.rows; r++) {
		this.grid[r] = [];
		for (var c = 0; c < this.cols; c++) {
			this.grid[r][c] = null;
		}
	}
	// Create background visuals for all cells
	this.initBackground = function () {
		for (var r = 0; r < this.rows; r++) {
			for (var c = 0; c < this.cols; c++) {
				var bgCell = LK.getAsset('emptycell', {
					anchorX: 0.5,
					anchorY: 0.5,
					alpha: 0.3
				});
				bgCell.x = GameConstants.GRID_LEFT + c * GameConstants.CELL_SIZE + GameConstants.CELL_SIZE / 2;
				bgCell.y = GameConstants.GRID_TOP + r * GameConstants.CELL_SIZE + GameConstants.CELL_SIZE / 2;
				backgroundContainer.addChild(bgCell);
				// No coin creation here
			}
		}
		// No return value needed
	};
	// Create BeatCell objects for the beat grid (bottom rows)
	this.initBeatGrid = function () {
		for (var r = 0; r < this.beatRows; r++) {
			var gridRow = this.playableRows + r;
			for (var c = 0; c < this.cols; c++) {
				var cell = new BeatCell(r);
				cell.x = GameConstants.GRID_LEFT + c * GameConstants.CELL_SIZE + GameConstants.CELL_SIZE / 2;
				cell.y = GameConstants.GRID_TOP + gridRow * GameConstants.CELL_SIZE + GameConstants.CELL_SIZE / 2;
				midgroundContainer.addChild(cell);
				this.grid[gridRow][c] = cell;
			}
		}
	};
	// Returns the BeatCell at a given (beatRow, col) in the beat grid
	this.getBeatCell = function (beatRow, col) {
		var gridRow = this.playableRows + beatRow;
		return this.grid[gridRow][col];
	};
	// Returns the BeatCell at a given (x, y) screen coordinate, or null if not in beat grid
	this.getBeatCellAt = function (x, y) {
		for (var r = 0; r < this.beatRows; r++) {
			var gridRow = this.playableRows + r;
			for (var c = 0; c < this.cols; c++) {
				var cell = this.grid[gridRow][c];
				if (!cell) {
					continue;
				}
				var cx = GameConstants.GRID_LEFT + c * GameConstants.CELL_SIZE + GameConstants.CELL_SIZE / 2;
				var cy = GameConstants.GRID_TOP + gridRow * GameConstants.CELL_SIZE + GameConstants.CELL_SIZE / 2;
				if (x >= cx - GameConstants.CELL_SIZE / 2 && x <= cx + GameConstants.CELL_SIZE / 2 && y >= cy - GameConstants.CELL_SIZE / 2 && y <= cy + GameConstants.CELL_SIZE / 2) {
					return cell;
				}
			}
		}
		return null;
	};
	// Returns true if (row, col) is in the playable area
	this.isPlayableCell = function (row, col) {
		return row >= 0 && row < this.playableRows && col >= 0 && col < this.cols;
	};
	// Returns true if (row, col) is in the beat grid
	this.isBeatCell = function (row, col) {
		return row >= this.playableRows && row < this.rows && col >= 0 && col < this.cols;
	};
	// Returns the BeatCell 2D array for the beat grid (bottom rows)
	this.getBeatGrid = function () {
		var arr = [];
		for (var r = 0; r < this.beatRows; r++) {
			arr[r] = [];
			for (var c = 0; c < this.cols; c++) {
				arr[r][c] = this.getBeatCell(r, c);
			}
		}
		return arr;
	};
	// Returns the playable area as a 2D array (nulls, or game objects if you want to add them)
	this.getPlayableGrid = function () {
		var arr = [];
		for (var r = 0; r < this.playableRows; r++) {
			arr[r] = [];
			for (var c = 0; c < this.cols; c++) {
				arr[r][c] = this.grid[r][c];
			}
		}
		return arr;
	};
	// Reset the playable grid with coins in all cells (no hero logic)
	this.resetGridWithCoins = function () {
		// Clear existing coins and enemies
		for (var r = 0; r < this.playableRows; r++) {
			for (var c = 0; c < this.cols; c++) {
				if (this.grid[r][c]) {
					this.grid[r][c].destroy();
					this.grid[r][c] = null;
				}
			}
		}
		// Add new coins to all playable cells
		var coinCount = 0;
		for (var r = 0; r < this.playableRows; r++) {
			for (var c = 0; c < this.cols; c++) {
				var coin = new Coin();
				coin.x = GameConstants.GRID_LEFT + c * GameConstants.CELL_SIZE + GameConstants.CELL_SIZE / 2;
				coin.y = GameConstants.GRID_TOP + r * GameConstants.CELL_SIZE + GameConstants.CELL_SIZE / 2;
				midgroundContainer.addChild(coin);
				this.grid[r][c] = coin;
				coinCount++;
			}
		}
		return coinCount;
	};
	// Call this to initialize all visuals
	this.initialize = function () {
		this.initBeatGrid();
	};
	// Destroys ALL objects currently managed by the grid (playable and beat)
	this.destroyAll = function () {
		for (var r = 0; r < this.rows; r++) {
			for (var c = 0; c < this.cols; c++) {
				if (this.grid[r][c] && typeof this.grid[r][c].destroy === 'function') {
					this.grid[r][c].destroy();
				}
				this.grid[r][c] = null; // Clear the reference
			}
		}
	};
}
var GameConstants = {
	GRID_COLS: 8,
	TOTAL_ROWS: 10,
	// Reduced from 11 to remove top row
	BEAT_ROWS: 4,
	// +1 for new down row
	CHAR_ROW: 3,
	// hero now starts at row 3 (was 4) due to removed top row
	JUMP_ROW: 2,
	// up movement now at row 2 (was 3) due to removed top row
	DOWN_ROW: 1,
	// new down movement row 1 (was 2) due to removed top row
	GRID_MARGIN_X: 40,
	get CELL_SIZE() {
		return Math.floor((2048 - 2 * this.GRID_MARGIN_X) / this.GRID_COLS);
	},
	get GRID_HEIGHT() {
		return this.TOTAL_ROWS * this.CELL_SIZE;
	},
	get GRID_TOP() {
		return 2732 - this.GRID_HEIGHT - 10;
	},
	get GRID_LEFT() {
		return this.GRID_MARGIN_X;
	},
	get HERO_MIN_X() {
		return this.GRID_LEFT + this.CELL_SIZE / 2;
	},
	get HERO_MAX_X() {
		return this.GRID_LEFT + (this.GRID_COLS - 1) * this.CELL_SIZE + this.CELL_SIZE / 2;
	},
	get HERO_START_COL() {
		return Math.floor(this.GRID_COLS / 2);
	},
	get HERO_START_X() {
		return this.GRID_LEFT + this.HERO_START_COL * this.CELL_SIZE + this.CELL_SIZE / 2;
	},
	get HERO_START_Y() {
		return this.GRID_TOP + this.CHAR_ROW * this.CELL_SIZE + this.CELL_SIZE / 2;
	},
	STEP_INTERVAL: 400,
	// ms per step (150bpm)
	COIN_SPAWN_BEATS: 8,
	COIN_SPAWN_CHANCE: 0.25
};
/************************* 
* SERVICES
*************************/ 
/** 
* AudioService
* Responsibility: To handle all requests to play sounds and music.
*/ 
var AudioService = {
	playBeat: function playBeat() {
		LK.getSound('beat').play();
	},
	playBeatUp: function playBeatUp() {
		LK.getSound('Sound_Up').play();
	},
	playBeatLeft: function playBeatLeft() {
		LK.getSound('Sound_Left').play();
	},
	playBeatRight: function playBeatRight() {
		LK.getSound('Sound_Right').play();
	},
	playBeatDown: function playBeatDown() {
		LK.getSound('Sound_Down').play();
	},
	playMove: function playMove() {
		LK.getSound('moveSnd').play();
	},
	playCoinCollect: function playCoinCollect() {
		LK.getSound('coinCollect').play();
	},
	playNewLevel: function playNewLevel() {
		LK.getSound('NewLevel').play();
	},
	startMusic: function startMusic() {
		LK.playMusic('bgmusic', {
			fade: {
				start: 0,
				end: 0.3,
				duration: 1200
			}
		});
	}
};
/** 
* UIService
* Responsibility: To create and manage all non-game-grid UI elements, such
* as the score text and the step indicators.
*/ 
function UIService(game) {
	this.game = game;
	this.scoreTxt = null;
	// --- LIVES UI STATE ---
	this.livesIcons = [];
	this.livesAnchorX = 0.5; // default center, can be set externally
	this.livesAnchorY = 0; // default top, can be set externally
	this.livesIconSpacing = 100; // px between icons
	this.initialize = function () {
		// Score Text
		this.scoreTxt = new Text2('0', {
			size: 100,
			fill: "#fff"
		});
		this.scoreTxt.anchor.set(0.5, 0);
		LK.gui.top.addChild(this.scoreTxt);
		// --- LIVES ICONS UI ---
		this.createLivesIcons(5);
		// Create columnHighlights for beat grid rows
		this.columnHighlights = [];
		for (var r = 0; r < GameConstants.BEAT_ROWS; r++) {
			var highlight = LK.getAsset('cellWhite', {
				anchorX: 0.5,
				anchorY: 0.5,
				alpha: 0 // invisible by default
			});
			// Position highlight at the leftmost column, correct row in the beat grid
			var gridRow = GameConstants.TOTAL_ROWS - GameConstants.BEAT_ROWS + r;
			highlight.x = GameConstants.GRID_LEFT + GameConstants.CELL_SIZE / 2;
			highlight.y = GameConstants.GRID_TOP + gridRow * GameConstants.CELL_SIZE + GameConstants.CELL_SIZE / 2;
			highlight.alpha = 0; // invisible by default, semi-transparent when shown
			foregroundContainer.addChild(highlight);
			this.columnHighlights.push(highlight);
		}
		// Hide all highlights at start
		for (var i = 0; i < this.columnHighlights.length; i++) {
			this.columnHighlights[i].alpha = 0;
		}
	};
	// Create the lives icons and add to gui overlay
	this.createLivesIcons = function (num) {
		if (this.livesIcons && this.livesIcons.length) {
			for (var i = 0; i < this.livesIcons.length; i++) {
				if (this.livesIcons[i] && typeof this.livesIcons[i].destroy === "function") {
					this.livesIcons[i].destroy();
				}
			}
		}
		this.livesIcons = [];
		for (var i = 0; i < num; i++) {
			var icon = LK.getAsset('Live', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			icon.width = 80;
			icon.height = 78.75;
			this.livesIcons.push(icon);
			LK.gui.addChild(icon);
		}
		this.updateLivesIconsPosition();
	};
	// Update the position of the lives icons based on anchor
	this.updateLivesIconsPosition = function () {
		var num = this.livesIcons.length;
		this.livesIconSpacing = 90; // Reduced spacing to move icons closer together
		var totalWidth = (num - 1) * this.livesIconSpacing;
		var anchorX = 0.85; // Position to the right side of screen
		var anchorY = this.livesAnchorY;
		var guiW = LK.gui.width || 2038;
		var guiH = LK.gui.height || 2732;
		var baseX = Math.floor(anchorX * guiW - totalWidth / 2);
		var baseY = Math.floor(anchorY * guiH + 40); // 40px margin from top by default
		for (var i = 0; i < this.livesIcons.length; i++) {
			var icon = this.livesIcons[i];
			icon.x = baseX + i * this.livesIconSpacing;
			icon.y = baseY;
			icon.visible = true;
		}
	};
	// Set the anchor for the lives UI (0..1 for x and y)
	this.setLivesAnchor = function (anchorX, anchorY) {
		this.livesAnchorX = anchorX;
		this.livesAnchorY = anchorY;
		this.updateLivesIconsPosition();
	};
	// Update the lives UI to show the correct number of icons
	this.updateLivesUI = function (currentLives) {
		for (var i = 0; i < this.livesIcons.length; i++) {
			// Hide icons from left to right as lives are lost
			this.livesIcons[i].visible = i >= this.livesIcons.length - currentLives;
		}
	};
	this.updateScore = function (newScore) {
		this.scoreTxt.setText(newScore);
	};
	// Main Highlighting Logic: highlights inactive cells in the current column
	this.updateColumnHighlight = function (currentColumnIndex) {
		// Hide all highlights first
		for (var i = 0; i < this.columnHighlights.length; i++) {
			this.columnHighlights[i].alpha = 0;
		}
		// Get active states for the current column
		var activeStates = gridService.getActiveStatesForColumn(currentColumnIndex);
		// Loop through each row in the beat grid
		for (var i = 0; i < GameConstants.BEAT_ROWS; i++) {
			if (!activeStates[i]) {
				// Position the highlight at the correct cell
				var gridRow = GameConstants.TOTAL_ROWS - GameConstants.BEAT_ROWS + i;
				this.columnHighlights[i].x = GameConstants.GRID_LEFT + currentColumnIndex * GameConstants.CELL_SIZE + GameConstants.CELL_SIZE / 2;
				this.columnHighlights[i].y = GameConstants.GRID_TOP + gridRow * GameConstants.CELL_SIZE + GameConstants.CELL_SIZE / 2;
				this.columnHighlights[i].alpha = 0.2; // semi-transparent highlight
			}
		}
	};
}
/** 
* GridService
* Responsibility: To create, manage the state of, and update the visuals of the beat grid.
*/ 
function GridService(game, gameGrid, antiCheatService) {
	this.game = game;
	this.gameGrid = gameGrid; // Centralized grid
	this.antiCheatService = antiCheatService;
	this.initialize = function () {
		this.gameGrid.initialize();
	};
	// Returns the BeatCell at a given (x, y) screen coordinate, or null if not in beat grid
	this.getCellAt = function (x, y) {
		var cell = this.gameGrid.getBeatCellAt(x, y);
		// Check if cell is disabled by anti-cheat
		if (cell && this.antiCheatService) {
			// Find the beat row of this cell
			var beatRow = cell.row;
			var col = -1;
			// Find column
			for (var c = 0; c < GameConstants.GRID_COLS; c++) {
				if (this.gameGrid.getBeatCell(beatRow, c) === cell) {
					col = c;
					break;
				}
			}
			if (col !== -1 && this.antiCheatService.isCellDisabled(beatRow, col)) {
				return null; // Return null if cell is disabled
			}
		}
		return cell;
	};
	// Returns an array of booleans representing the active state of each BeatCell in the given column
	this.getActiveStatesForColumn = function (columnIndex) {
		var states = [];
		for (var r = 0; r < GameConstants.BEAT_ROWS; r++) {
			var gridRow = GameConstants.TOTAL_ROWS - GameConstants.BEAT_ROWS + r;
			var cell = this.gameGrid.grid[gridRow][columnIndex];
			// Check if cell is disabled by anti-cheat
			var isDisabled = this.antiCheatService && this.antiCheatService.isCellDisabled(r, columnIndex);
			states.push(cell && cell.active && !isDisabled ? true : false);
		}
		return states;
	};
	// Toggle a beat cell, ensuring only one beat per layer per column
	this.toggleCell = function (cell, mode) {
		var needsChange = mode === 'add' && !cell.active || mode === 'remove' && cell.active;
		if (needsChange) {
			// If adding, remove any other active beat in this column (same col, different row)
			if (mode === 'add') {
				var col = null;
				// Find the column index of this cell
				for (var c = 0; c < GameConstants.GRID_COLS; c++) {
					// cell.row is the beat row (0..BEAT_ROWS-1), but grid is [playableRows+row][col]
					var gridRow = GameConstants.TOTAL_ROWS - GameConstants.BEAT_ROWS + cell.row;
					if (this.gameGrid.grid[gridRow][c] === cell) {
						col = c;
						break;
					}
				}
				if (col !== null) {
					for (var r = 0; r < GameConstants.BEAT_ROWS; r++) {
						var gridRow = GameConstants.TOTAL_ROWS - GameConstants.BEAT_ROWS + r;
						var otherCell = this.gameGrid.grid[gridRow][col];
						if (r !== cell.row && otherCell && otherCell.active) {
							otherCell.setActive(false);
							this.updateCellVisual(otherCell);
						}
					}
				}
			}
			cell.toggle();
			this.updateCellVisual(cell);
			// If a beat was just placed (cell became active), notify sequencerService
			if (cell.active && typeof sequencerService !== "undefined" && !sequencerService.hasPlacedBeat) {
				sequencerService.hasPlacedBeat = true;
			}
		}
	};
	this.updateCellVisual = function (cell) {
		cell.gfx.destroy();
		var assetId = 'cell';
		var alpha = 1.0;
		// Always show the appropriate beat tile based on row
		if (cell.row === 0) {
			assetId = 'cellActive';
		} else if (cell.row === 1) {
			assetId = 'cellLeft';
		} else if (cell.row === 2) {
			assetId = 'cellRight';
		} else if (cell.row === 3) {
			assetId = 'cellDown';
		}
		// Set transparency based on active state
		if (!cell.active) {
			alpha = 0.1;
		}
		cell.gfx = cell.attachAsset(assetId, {
			anchorX: 0.5,
			anchorY: 0.5,
			alpha: alpha
		});
	};
	// Returns the actions for a given step (column) by checking the beat grid
	this.getActiveActionsForStep = function (step) {
		// The beat grid is in the bottom rows of the grid
		var actions = {
			up: false,
			left: false,
			right: false,
			down: false
		};
		for (var r = 0; r < GameConstants.BEAT_ROWS; r++) {
			var gridRow = GameConstants.TOTAL_ROWS - GameConstants.BEAT_ROWS + r;
			var cell = this.gameGrid.grid[gridRow][step];
			if (!cell) {
				continue;
			}
			// Check if cell is disabled by anti-cheat
			var isDisabled = this.antiCheatService && this.antiCheatService.isCellDisabled(r, step);
			if (r === 0) {
				actions.up = cell.active && !isDisabled;
			} else if (r === 1) {
				actions.left = cell.active && !isDisabled;
			} else if (r === 2) {
				actions.right = cell.active && !isDisabled;
			} else if (r === 3) {
				actions.down = cell.active && !isDisabled;
			}
		}
		return actions;
	};
}
/** 
* PlayerService
* Responsibility: To create and manage the Hero instance, its state, and its actions.
* It translates logical actions ("move left") into animations and sound calls.
*/ 
function PlayerService(game, gameGrid) {
	this.game = game;
	this.gameGrid = gameGrid;
	this.hero = null;
	this.reset = function () {
		if (this.hero) {
			this.hero.destroy();
			this.hero = null;
		}
	};
	this.initialize = function () {
		if (this.hero) {
			this.hero.destroy(); // Destroy old one if it exists
		}
		this.hero = new Hero();
		// DO NOT set position here. DO NOT add to game here.
		// That will be handled by startNextRound.
	};
	this.getHeroInstance = function () {
		return this.hero;
	};
	this.handleDrag = function (x) {
		this.hero.x = Math.max(GameConstants.HERO_MIN_X, Math.min(GameConstants.HERO_MAX_X, x));
	};
	this.performActions = function (actions) {
		var didAction = false;
		var horizontalMove = 0;
		var hero = this.hero;
		var direction = "down";
		var isEating = false;
		var isUpWalkAlt = hero.upWalkAlt || false;
		if (actions.left && !actions.right) {
			horizontalMove = -1;
			direction = "left";
		}
		if (actions.right && !actions.left) {
			horizontalMove = 1;
			direction = "right";
		}
		if (actions.up && !actions.down) {
			direction = "up";
			// Alternate up-walk frame
			isUpWalkAlt = !hero.upWalkAlt;
			if (horizontalMove !== 0) {
				this.move(horizontalMove);
			}
			this.moveVertical(-1); // Move up
			didAction = true;
		} else if (actions.down && !actions.up) {
			direction = "down";
			hero.upWalkAlt = false; // Reset alternation on down
			if (horizontalMove !== 0) {
				this.move(horizontalMove);
			}
			this.moveVertical(1); // Move down
			didAction = true;
		} else if (horizontalMove !== 0) {
			// Only horizontal
			direction = horizontalMove === -1 ? "left" : "right";
			hero.upWalkAlt = false; // Reset alternation on horizontal
			this.move(horizontalMove);
			didAction = true;
		}
		// Set hero frame for movement (not eating)
		hero.setFrame(direction, false, isUpWalkAlt);
		if (didAction) {
			// Pop animation: scale up to 1.18, then back to 1.0
			tween.stop(hero, {
				scaleX: true,
				scaleY: true
			});
			hero.scaleX = 1.0;
			hero.scaleY = 1.0;
			tween(hero, {
				scaleX: 1.1,
				scaleY: 1.1
			}, {
				duration: 75,
				easing: tween.cubicOut,
				onFinish: function onFinish() {
					tween(hero, {
						scaleX: 1.0,
						scaleY: 1.0
					}, {
						duration: 125,
						easing: tween.cubicIn
					});
				}
			});
			AudioService.playBeat();
		}
	};
	this.move = function (direction) {
		var newCol = this.hero.currentCol + direction;
		if (newCol < 0) {
			newCol = GameConstants.GRID_COLS - 1;
		}
		if (newCol >= GameConstants.GRID_COLS) {
			newCol = 0;
		}
		this.hero.currentCol = newCol;
		var nx = GameConstants.GRID_LEFT + newCol * GameConstants.CELL_SIZE + GameConstants.CELL_SIZE / 2;
		this.hero.moveTo(nx, this.hero.y, 180);
		AudioService.playMove();
	};
	// Move up or down by 1 row, with vertical teleport at edges of playable area
	this.moveVertical = function (direction) {
		var minRow = 0;
		var maxRow = this.gameGrid.playableRows - 1; // Only teleport within playable area (rows 0-5 after removing top row)
		var newRow = this.hero.gridRow !== undefined ? this.hero.gridRow : GameConstants.CHAR_ROW;
		newRow += direction;
		// Teleport vertically if out of bounds
		if (newRow < minRow) {
			newRow = maxRow;
		} else if (newRow > maxRow) {
			newRow = minRow;
		}
		this.hero.gridRow = newRow;
		var ny = GameConstants.GRID_TOP + newRow * GameConstants.CELL_SIZE + GameConstants.CELL_SIZE / 2;
		this.hero.moveTo(this.hero.x, ny, 180);
		AudioService.playMove();
		// No longer update GameConstants.CHAR_ROW here; hero.gridRow is the source of truth
	};
}
/** 
* InputService
* Responsibility: To handle all raw user input (down, up, move) and delegate
* the appropriate actions to other services (GridService, PlayerService).
*/ 
function InputService(gridService, playerService) {
	this.gridService = gridService;
	this.playerService = playerService;
	this.isPainting = false;
	this.paintMode = null;
	this.lastPaintedCell = null;
	this.dragHero = false;
	this.handleDown = function (x, y) {
		var cell = this.gridService.getCellAt(x, y);
		if (cell) {
			this.isPainting = true;
			this.paintMode = cell.active ? 'remove' : 'add';
			this.lastPaintedCell = cell;
			this.gridService.toggleCell(cell, this.paintMode);
		} else {
			var hero = this.playerService.getHeroInstance();
			var dx = x - hero.x,
				dy = y - hero.y;
			if (dx * dx + dy * dy < 200 * 200) {
				this.dragHero = true;
			}
		}
	};
	this.handleUp = function () {
		this.isPainting = false;
		this.paintMode = null;
		this.lastPaintedCell = null;
		this.dragHero = false;
	};
	this.handleMove = function (x, y) {
		if (this.isPainting) {
			var cell = this.gridService.getCellAt(x, y);
			if (cell && cell !== this.lastPaintedCell) {
				this.lastPaintedCell = cell;
				this.gridService.toggleCell(cell, this.paintMode);
			}
		} else if (this.dragHero) {
			this.playerService.handleDrag(x);
		}
	};
}
/** 
* SequencerService
* Responsibility: To manage the main game loop timing (the "beat"). On each step,
* it orchestrates calls to the other services to update the game state.
*/ 
function SequencerService(gridService, playerService, uiService) {
	this.gridService = gridService;
	this.playerService = playerService;
	this.uiService = uiService;
	this.currentStep = 0;
	this.lastStepTime = 0;
	this.playing = true;
	this.comboMultiplier = 1;
	this.collectedThisBeat = false;
	this.prevComboMultiplier = 1; // Previous Fibonacci number
	this.comboCount = 0; // Track position in Fibonacci sequence
	this.enemyCellRow = undefined; // Track enemy cell position
	this.enemyCellCol = undefined; // Track enemy cell position
	this.levelTransitioning = false; // Add this new flag
	// --- LIVES SYSTEM STATE ---
	this.lives = 5;
	this.collectedInSequence = false; // Tracks if a coin was collected in the current 8-beat loop
	this.lifeSystemActive = false; // Only start deducting lives after first beat placed and sequence ends
	this.hasPlacedBeat = false; // Tracks if player has placed a beat at all
	this.initialize = function () {
		this.lastStepTime = Date.now();
	};
	this.update = function () {
		var now = Date.now();
		if (this.playing && now - this.lastStepTime >= GameConstants.STEP_INTERVAL) {
			this.lastStepTime = now;
			// 1. UPDATE HIGHLIGHT FIRST for the current step
			this.uiService.updateColumnHighlight(this.currentStep);
			// 2. THEN, advance the step to the next beat
			this.currentStep = (this.currentStep + 1) % GameConstants.GRID_COLS;
			// 3. FINALLY, perform actions for the new step.
			this.doStepActions();
		}
	};
	this.doStepActions = function () {
		// Reset collection flag for this beat
		this.collectedThisBeat = false;
		// Get actions for the PREVIOUS step (the one the highlight just left)
		var previousStep = (this.currentStep - 1 + GameConstants.GRID_COLS) % GameConstants.GRID_COLS;
		// --- NEW LIFE LOGIC ---
		// Check if a full sequence has just ended (i.e., we're about to play beat 0)
		if (previousStep === GameConstants.GRID_COLS - 1) {
			// If player has placed a beat and life system is not yet active, activate it now (but don't deduct a life this sequence)
			if (this.hasPlacedBeat && !this.lifeSystemActive) {
				this.lifeSystemActive = true;
			} else if (this.lifeSystemActive) {
				if (!this.collectedInSequence) {
					// Player failed to collect a coin in the last 8 beats. Deduct a life.
					this.lives--;
					uiService.updateLivesUI(this.lives); // Update the visual display
					if (this.lives <= 0) {
						LK.showGameOver();
						return; // Stop the game
					}
				}
			}
			// Reset the flag for the new sequence.
			this.collectedInSequence = false;
		}
		// --- END NEW LIFE LOGIC ---
		var actions = this.gridService.getActiveActionsForStep(previousStep);
		// Play beat sounds for the previous step
		if (actions.up) {
			AudioService.playBeatUp();
		} else if (actions.left) {
			AudioService.playBeatLeft();
		} else if (actions.right) {
			AudioService.playBeatRight();
		} else if (actions.down) {
			AudioService.playBeatDown();
		} else {
			AudioService.playBeat();
		}
		// Animate active beat cells for the previous step
		for (var r = 0; r < GameConstants.BEAT_ROWS; r++) {
			var cell = gameGrid.getBeatCell(r, previousStep);
			if (cell && cell.active && !antiCheatService.isCellDisabled(r, previousStep)) {
				// Create bump animation: scale up to 110% then back to 100%
				tween(cell, {
					scaleX: 1.1,
					scaleY: 1.1
				}, {
					duration: 100,
					easing: tween.easeOut,
					onFinish: function (targetCell) {
						return function () {
							tween(targetCell, {
								scaleX: 1.0,
								scaleY: 1.0
							}, {
								duration: 100,
								easing: tween.easeIn
							});
						};
					}(cell)
				});
			}
		}
		// Store hero's previous position before performing actions
		var hero = this.playerService.getHeroInstance();
		if (!hero) {
			return; // Exit early if hero doesn't exist
		}
		var prevHeroRow = hero.gridRow;
		var prevHeroCol = hero.currentCol;
		// Perform actions for the previous step
		this.playerService.performActions(actions);
		// Check if hero was on an enemy cell and has now moved away
		if (this.enemyCellRow !== undefined && this.enemyCellCol !== undefined) {
			// Check if hero has moved to a different cell
			if (hero.gridRow !== this.enemyCellRow || hero.currentCol !== this.enemyCellCol) {
				// Hero has left the enemy cell - trigger game over
				LK.showGameOver();
				return; // Exit early
			}
		}
		// Check for coin collection, key, princess, or enemy collision at current position
		var heroRow = hero.gridRow;
		var heroCol = hero.currentCol;
		var entity = gameGrid.grid[heroRow][heroCol];
		if (entity) {
			// --- Key logic ---
			if (entity instanceof Key) {
				playerHasKey = true;
				AudioService.playNewLevel(); // Play a special sound for key collection (reuse NewLevel for now)
				entity.destroy();
				gameGrid.grid[heroRow][heroCol] = null;
			}
			// --- Princess logic ---
			else if (entity instanceof Princess) {
				if (playerHasKey && !this.levelTransitioning) {
					// <-- ADD THIS CHECK
					this.levelTransitioning = true; // <-- SET THE FLAG IMMEDIATELY
					// Show transition screen instead of immediately advancing
					showTransitionScreen();
					return;
				}
				// If player doesn't have key, do nothing (can't win yet)
			}
			// --- Coin logic ---
			else if (entity.collect) {
				// It's a coin - clear any enemy tracking
				this.enemyCellRow = undefined;
				this.enemyCellCol = undefined;
				entity.collect();
				gameGrid.grid[heroRow][heroCol] = null;
				// (Projectile logic removed)
				// Apply combo multiplier to score (incremental: 1,2,3...)
				var points = this.comboMultiplier;
				LK.setScore(LK.getScore() + points);
				uiService.updateScore(LK.getScore());
				AudioService.playCoinCollect();
				// Set hero frame to Eat variant for this direction
				var eatDirection = hero.lastDirection || "down";
				var eatUpWalkAlt = hero.upWalkAlt || false;
				if (eatDirection === "down") {
					// Show hero_2 when eating facing camera, then revert to hero
					hero.gfx.destroy();
					hero.gfx = hero.attachAsset('hero_2', {
						anchorX: 0.5,
						anchorY: 0.5
					});
					hero.gfx.assetId = "hero_2";
					LK.setTimeout(function () {
						hero.setFrame("down", false, false);
					}, 299);
				} else {
					hero.setFrame(eatDirection, true, eatUpWalkAlt);
					// After 299ms, revert to walk frame (not eating)
					LK.setTimeout(function () {
						hero.setFrame(eatDirection, false, eatUpWalkAlt);
					}, 299);
				}
				// Mark that we collected a coin this beat
				this.collectedThisBeat = true;
				// Mark that we collected a coin in this sequence
				this.collectedInSequence = true;
				// Increment combo multiplier by 1 for each consecutive coin
				this.comboMultiplier++;
				this.comboCount++;
				// Update collected coins counter
				collectedCoins++;
				// Check if we should spawn the key (25% of coins collected)
				if (!keySpawned && collectedCoins >= Math.floor(totalCoins * 0.25)) {
					// Find any empty cell where a coin has been collected
					var emptyCell = null;
					for (var r = 0; r < gameGrid.playableRows && !emptyCell; r++) {
						for (var c = 0; c < GameConstants.GRID_COLS && !emptyCell; c++) {
							// Skip hero's current position
							var hero = this.playerService.getHeroInstance();
							if (r === hero.gridRow && c === hero.currentCol) {
								continue;
							}
							// Check if cell is empty (coin was collected)
							if (!gameGrid.grid[r][c]) {
								emptyCell = {
									row: r,
									col: c
								};
							}
						}
					}
					// Spawn key in the found empty cell
					if (emptyCell) {
						var key = new Key();
						key.x = GameConstants.GRID_LEFT + emptyCell.col * GameConstants.CELL_SIZE + GameConstants.CELL_SIZE / 2;
						key.y = GameConstants.GRID_TOP + emptyCell.row * GameConstants.CELL_SIZE + GameConstants.CELL_SIZE / 2;
						midgroundContainer.addChild(key);
						gameGrid.grid[emptyCell.row][emptyCell.col] = key;
						keySpawned = true;
					}
				}
				// Check if we should spawn the princess (51% of coins collected AND key collected)
				if (!princessSpawned && collectedCoins >= Math.floor(totalCoins * 0.51) && playerHasKey) {
					// Find any empty cell where a coin has been collected
					var emptyCell = null;
					for (var r = 0; r < gameGrid.playableRows && !emptyCell; r++) {
						for (var c = 0; c < GameConstants.GRID_COLS && !emptyCell; c++) {
							// Skip hero's current position
							var hero = this.playerService.getHeroInstance();
							if (r === hero.gridRow && c === hero.currentCol) {
								continue;
							}
							// Check if cell is empty (coin was collected) and not occupied by key
							if (!gameGrid.grid[r][c]) {
								emptyCell = {
									row: r,
									col: c
								};
							}
						}
					}
					// Spawn princess in the found empty cell
					if (emptyCell) {
						var princess = new Princess();
						princess.x = GameConstants.GRID_LEFT + emptyCell.col * GameConstants.CELL_SIZE + GameConstants.CELL_SIZE / 2;
						princess.y = GameConstants.GRID_TOP + emptyCell.row * GameConstants.CELL_SIZE + GameConstants.CELL_SIZE / 2;
						midgroundContainer.addChild(princess);
						gameGrid.grid[emptyCell.row][emptyCell.col] = princess;
						princessSpawned = true;
					}
				}
				// Do NOT call checkRoundCompletion here! Only call it when the coin is actually destroyed by the projectile or collected by the hero.
			}
		} else {
			// No entity at current position - clear any enemy tracking
			this.enemyCellRow = undefined;
			this.enemyCellCol = undefined;
			// No coin collected - reset combo if we had one
			if (this.comboMultiplier > 1) {
				this.comboMultiplier = 1;
				this.comboCount = 0;
			}
		}
	};
}
var currentRound = 1;
var totalCoins = 0;
var collectedCoins = 0;
var playerHasKey = false; // Track if player has the key for win condition
var keySpawnRow = 0;
var keySpawnCol = 0;
var princessSpawnRow = 0;
var princessSpawnCol = 0;
var keySpawned = false;
var princessSpawned = false;
var transitionScreen = null;
var transitionOverlay = null;
var transitionAsset = null;
var transitionText = null;
var currentStoryPanel = 1; // Track which story panel to show (1-8)
var maxStoryPanels = 8; // Total number of story panels
var storyTexts = ["One day, Pengu heard the most beautiful piano song in the village.", "Pengu dreamed of meeting the Princess, but fear held him back.", "An old penguin showed Pengu that music flows from the heart.", "Pengu found a piano and practiced from dawn till midnight.", "Even through mockery and pain, Pengu never gave up.", "His first performance was a complete fiasco.", "But playing with pure heart, Pengu found his true song.", "His heartfelt music finally won the Princess's love."];
var storyText = null;
function showTransitionScreen() {
	// Pause the sequencer to stop beats and movement
	sequencerService.playing = false;
	// Hide score text and lives icons
	if (uiService.scoreTxt) {
		uiService.scoreTxt.visible = false;
	}
	for (var i = 0; i < uiService.livesIcons.length; i++) {
		uiService.livesIcons[i].visible = false;
	}
	// Create white overlay covering entire screen
	transitionOverlay = LK.getAsset('cellWhite', {
		anchorX: 0,
		anchorY: 0,
		scaleX: 20,
		// Scale to cover full screen width
		scaleY: 30 // Scale to cover full screen height
	});
	transitionOverlay.x = 0;
	transitionOverlay.y = 0;
	foregroundContainer.addChild(transitionOverlay);
	// Determine which story panel to show based on current round
	var storyAssetName = 'Transition';
	if (currentStoryPanel > 1) {
		storyAssetName = 'Transition_' + currentStoryPanel;
	}
	// Create transition asset with current story panel
	transitionAsset = LK.getAsset(storyAssetName, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	transitionAsset.x = 2048 / 2; // Center horizontally
	transitionAsset.y = 2732 / 2; // Center vertically
	// Create "Tap to SKIP" text at top
	transitionText = new Text2('Tap to SKIP', {
		size: 80,
		fill: 0x000000 // Black text
	});
	transitionText.anchor.set(0.5, 0);
	transitionText.x = 2048 / 2; // Center horizontally
	transitionText.y = 100; // Near top of screen
	// Create story text at bottom
	var storyTextContent = storyTexts[currentStoryPanel - 1]; // currentStoryPanel is 1-indexed
	storyText = new Text2(storyTextContent, {
		size: 60,
		fill: 0x000000 // Black text
	});
	storyText.anchor.set(0.5, 1); // Center horizontally, anchor at bottom
	storyText.x = 2048 / 2; // Center horizontally
	storyText.y = 2732 - 100; // Near bottom of screen with margin
}
function hideTransitionScreen() {
	// Destroy all current board objects including hero, princess, coins
	gameGrid.destroyAll();
	playerService.reset();
	// Resume the sequencer
	sequencerService.playing = true;
	// Show score text and lives icons again
	if (uiService.scoreTxt) {
		uiService.scoreTxt.visible = true;
	}
	for (var i = 0; i < uiService.livesIcons.length; i++) {
		uiService.livesIcons[i].visible = true;
	}
	if (transitionOverlay) {
		transitionOverlay.destroy();
		transitionOverlay = null;
	}
	if (transitionAsset) {
		transitionAsset.destroy();
		transitionAsset = null;
	}
	if (transitionText) {
		transitionText.destroy();
		transitionText = null;
	}
	if (storyText) {
		storyText.destroy();
		storyText = null;
	}
}
/** 
* Resets the game state and starts the next round.
*/ 
function startNextRound() {
	// --- Step A: Full System Reset ---
	// 1. Destroy ALL objects on the grid (playable AND beat cells).
	gameGrid.destroyAll();
	// 2. Destroy the old hero.
	playerService.reset();
	// --- Step B: Reset Game State ---
	currentRound++;
	collectedCoins = 0;
	playerHasKey = false;
	// Reset lives system
	sequencerService.lives = 5;
	sequencerService.collectedInSequence = false;
	sequencerService.lifeSystemActive = false;
	sequencerService.hasPlacedBeat = false;
	uiService.updateLivesUI(sequencerService.lives);
	// --- Step C & D: Create and Shuffle the Cell Pool ---
	var cellPool = [];
	for (var r = 0; r < gameGrid.playableRows; r++) {
		for (var c = 0; c < GameConstants.GRID_COLS; c++) {
			cellPool.push({
				row: r,
				col: c
			});
		}
	}
	// Shuffle the pool
	for (var i = cellPool.length - 1; i > 0; i--) {
		var j = Math.floor(Math.random() * (i + 1));
		var temp = cellPool[i];
		cellPool[i] = cellPool[j];
		cellPool[j] = temp;
	}
	// --- Step E: Rebuild the World ---
	// 1. Re-initialize the background graphics. This must happen first.
	gameGrid.initBackground();
	// 2. Re-initialize the NEW beat grid.
	gameGrid.initBeatGrid();
	// 3. Initialize the NEW hero and get a reference to it.
	playerService.initialize();
	var hero = playerService.getHeroInstance();
	// 4. Place the Hero. (We need to update playerService.initialize to not place it randomly)
	var heroCell = cellPool.shift();
	hero.gridRow = heroCell.row;
	hero.currentCol = heroCell.col;
	hero.x = GameConstants.GRID_LEFT + heroCell.col * GameConstants.CELL_SIZE + GameConstants.CELL_SIZE / 2;
	hero.y = GameConstants.GRID_TOP + heroCell.row * GameConstants.CELL_SIZE + GameConstants.CELL_SIZE / 2;
	midgroundContainer.addChild(hero);
	// --- Step F: Fill with Coins Only ---
	// Place a coin in every empty playable cell (except hero's cell)
	totalCoins = 0;
	for (var r = 0; r < gameGrid.playableRows; r++) {
		for (var c = 0; c < GameConstants.GRID_COLS; c++) {
			// Prevent coin from spawning in the hero's cell
			if (!(r === heroCell.row && c === heroCell.col)) {
				var coin = new Coin();
				coin.x = GameConstants.GRID_LEFT + c * GameConstants.CELL_SIZE + GameConstants.CELL_SIZE / 2;
				coin.y = GameConstants.GRID_TOP + r * GameConstants.CELL_SIZE + GameConstants.CELL_SIZE / 2;
				midgroundContainer.addChild(coin);
				gameGrid.grid[r][c] = coin;
				totalCoins++;
			}
		}
	}
	// Store key and princess positions for later spawning
	var keyCell = cellPool.shift();
	var princessCell = cellPool.shift();
	// Store the key and princess positions globally for spawning later
	keySpawnRow = keyCell.row;
	keySpawnCol = keyCell.col;
	princessSpawnRow = princessCell.row;
	princessSpawnCol = princessCell.col;
	keySpawned = false;
	princessSpawned = false;
	// 1. Reset the Anti-Cheat Service for the new grid layout.
	antiCheatService.reset();
	// 2. Reset all beat grid cells to inactive so no beats remain from the previous level.
	for (var r = 0; r < GameConstants.BEAT_ROWS; r++) {
		for (var c = 0; c < GameConstants.GRID_COLS; c++) {
			var cell = gameGrid.getBeatCell(r, c);
			if (cell && cell.active) {
				cell.setActive(false);
				gridService.updateCellVisual(cell);
			}
		}
	}
	// 3. Play the sound.
	sequencerService.levelTransitioning = false; // <-- RESET THE FLAG
	AudioService.playNewLevel();
}
/** 
* Checks if the round is complete and triggers the next round if it is.
* This function will be called whenever a coin is collected.
*/ 
function checkRoundCompletion() {
	// No longer used for level completion
}
// --- Patch coin collection logic to update counter and reset on projectile fire ---
// We'll patch the doStepActions method in SequencerService below
var uiService = new UIService(game);
var gameGrid = new GameGrid(game);
var antiCheatService = new AntiCheatService(null, gameGrid); // Initialize before gridService
var gridService = new GridService(game, gameGrid, antiCheatService);
var playerService = new PlayerService(game, gameGrid);
// Do NOT call playerService.initialize() here; hero creation is handled in startNextRound only.
var inputService = new InputService(gridService, playerService);
var sequencerService = new SequencerService(gridService, playerService, uiService);
// 3. Initialize Services in correct order
uiService.initialize();
sequencerService.initialize();
antiCheatService.initialize();
// Set currentRound to 0 so first call to startNextRound makes it 1
currentRound = 0;
startNextRound();
// 4. Connect Input Handlers to the Input Service
game.down = function (x, y) {
	// Check if transition screen is active
	if (transitionOverlay) {
		// Advance to next story panel
		currentStoryPanel++;
		// Check if we've reached the end of the story
		if (currentStoryPanel > maxStoryPanels) {
			// Story is complete - show you win and end game
			hideTransitionScreen();
			LK.showYouWin();
			return;
		}
		// Dismiss transition screen and advance to next round
		hideTransitionScreen();
		LK.setTimeout(startNextRound, 100);
		return;
	}
	inputService.handleDown(x, y);
};
game.up = function (x, y) {
	inputService.handleUp(x, y);
};
game.move = function (x, y) {
	inputService.handleMove(x, y);
};
// 5. Set Main Game Loop to the Sequencer Service
game.update = function () {
	sequencerService.update();
};
// 6. Start background music
AudioService.startMusic();
// Debug button for instant level completion
var debugButton = LK.getAsset('enemy', {
	anchorX: 0.5,
	anchorY: 0
});
debugButton.width = 100;
debugButton.height = 92.6;
LK.gui.addChild(debugButton);
// Position debug button to the left of score text
debugButton.x = LK.gui.width * 0.3; // Left side of screen
debugButton.y = 40; // Same vertical position as score
// Add click handler for debug button
debugButton.down = function (x, y, obj) {
	// Instantly trigger level completion by simulating princess collection
	if (!sequencerService.levelTransitioning) {
		playerHasKey = true; // Ensure player has key
		sequencerService.levelTransitioning = true; // Set transition flag
		showTransitionScreen(); // Show transition screen
	}
};
;
;
// End of file. All round/game start logic is now centralized in startNextRound.;

===================================================================
--- original.js
+++ change.js
@@ -192,34 +192,42 @@
 
 /**** 
 * Game Code
 ****/ 
+// Create layered containers for proper z-ordering
+var backgroundContainer = new Container();
+var midgroundContainer = new Container();
+var foregroundContainer = new Container();
+// Add containers to game in correct order
+game.addChild(backgroundContainer);
+game.addChild(midgroundContainer);
+game.addChild(foregroundContainer);
 /** 
-* AntiCheatService
-* Responsibility: Manages disabling random cells from each beat layer each round
+* GameGrid
+* Responsibility: Centralizes the entire grid (playable + beat area) into a single class.
+* Provides accessors for both the playable area and the beat grid, and manages their state.
 */ 
-/** 
-* GameConstants
-* Responsibility: To hold all static configuration and magic numbers in one place
-* for easy tuning and maintenance.
-*/ 
 /************************* 
-* GAME CONFIGURATION
+* CORE GAME OBJECTS
 *************************/ 
-// Plugins (Unchanged)
-// Assets (Unchanged)
+// 2. Instantiate All Services
 /************************* 
 * ASSETS & PLUGINS
 *************************/ 
-// 2. Instantiate All Services
+// Assets (Unchanged)
+// Plugins (Unchanged)
 /************************* 
-* CORE GAME OBJECTS
+* GAME CONFIGURATION
 *************************/ 
 /** 
-* GameGrid
-* Responsibility: Centralizes the entire grid (playable + beat area) into a single class.
-* Provides accessors for both the playable area and the beat grid, and manages their state.
+* GameConstants
+* Responsibility: To hold all static configuration and magic numbers in one place
+* for easy tuning and maintenance.
 */ 
+/** 
+* AntiCheatService
+* Responsibility: Manages disabling random cells from each beat layer each round
+*/ 
 function AntiCheatService(gridService, gameGrid) {
 	this.gridService = gridService;
 	this.gameGrid = gameGrid;
 	this.disabledCells = []; // Array to store currently disabled cells
@@ -370,9 +378,9 @@
 					alpha: 0.3
 				});
 				bgCell.x = GameConstants.GRID_LEFT + c * GameConstants.CELL_SIZE + GameConstants.CELL_SIZE / 2;
 				bgCell.y = GameConstants.GRID_TOP + r * GameConstants.CELL_SIZE + GameConstants.CELL_SIZE / 2;
-				this.game.addChild(bgCell);
+				backgroundContainer.addChild(bgCell);
 				// No coin creation here
 			}
 		}
 		// No return value needed
@@ -384,9 +392,9 @@
 			for (var c = 0; c < this.cols; c++) {
 				var cell = new BeatCell(r);
 				cell.x = GameConstants.GRID_LEFT + c * GameConstants.CELL_SIZE + GameConstants.CELL_SIZE / 2;
 				cell.y = GameConstants.GRID_TOP + gridRow * GameConstants.CELL_SIZE + GameConstants.CELL_SIZE / 2;
-				this.game.addChild(cell);
+				midgroundContainer.addChild(cell);
 				this.grid[gridRow][c] = cell;
 			}
 		}
 	};
@@ -460,9 +468,9 @@
 			for (var c = 0; c < this.cols; c++) {
 				var coin = new Coin();
 				coin.x = GameConstants.GRID_LEFT + c * GameConstants.CELL_SIZE + GameConstants.CELL_SIZE / 2;
 				coin.y = GameConstants.GRID_TOP + r * GameConstants.CELL_SIZE + GameConstants.CELL_SIZE / 2;
-				this.game.addChild(coin);
+				midgroundContainer.addChild(coin);
 				this.grid[r][c] = coin;
 				coinCount++;
 			}
 		}
@@ -606,9 +614,9 @@
 			var gridRow = GameConstants.TOTAL_ROWS - GameConstants.BEAT_ROWS + r;
 			highlight.x = GameConstants.GRID_LEFT + GameConstants.CELL_SIZE / 2;
 			highlight.y = GameConstants.GRID_TOP + gridRow * GameConstants.CELL_SIZE + GameConstants.CELL_SIZE / 2;
 			highlight.alpha = 0; // invisible by default, semi-transparent when shown
-			this.game.addChild(highlight);
+			foregroundContainer.addChild(highlight);
 			this.columnHighlights.push(highlight);
 		}
 		// Hide all highlights at start
 		for (var i = 0; i < this.columnHighlights.length; i++) {
@@ -1210,9 +1218,9 @@
 					if (emptyCell) {
 						var key = new Key();
 						key.x = GameConstants.GRID_LEFT + emptyCell.col * GameConstants.CELL_SIZE + GameConstants.CELL_SIZE / 2;
 						key.y = GameConstants.GRID_TOP + emptyCell.row * GameConstants.CELL_SIZE + GameConstants.CELL_SIZE / 2;
-						game.addChild(key);
+						midgroundContainer.addChild(key);
 						gameGrid.grid[emptyCell.row][emptyCell.col] = key;
 						keySpawned = true;
 					}
 				}
@@ -1240,9 +1248,9 @@
 					if (emptyCell) {
 						var princess = new Princess();
 						princess.x = GameConstants.GRID_LEFT + emptyCell.col * GameConstants.CELL_SIZE + GameConstants.CELL_SIZE / 2;
 						princess.y = GameConstants.GRID_TOP + emptyCell.row * GameConstants.CELL_SIZE + GameConstants.CELL_SIZE / 2;
-						game.addChild(princess);
+						midgroundContainer.addChild(princess);
 						gameGrid.grid[emptyCell.row][emptyCell.col] = princess;
 						princessSpawned = true;
 					}
 				}
@@ -1297,9 +1305,9 @@
 		scaleY: 30 // Scale to cover full screen height
 	});
 	transitionOverlay.x = 0;
 	transitionOverlay.y = 0;
-	game.addChild(transitionOverlay);
+	foregroundContainer.addChild(transitionOverlay);
 	// Determine which story panel to show based on current round
 	var storyAssetName = 'Transition';
 	if (currentStoryPanel > 1) {
 		storyAssetName = 'Transition_' + currentStoryPanel;
@@ -1310,18 +1318,16 @@
 		anchorY: 0.5
 	});
 	transitionAsset.x = 2048 / 2; // Center horizontally
 	transitionAsset.y = 2732 / 2; // Center vertically
-	game.addChild(transitionAsset);
 	// Create "Tap to SKIP" text at top
 	transitionText = new Text2('Tap to SKIP', {
 		size: 80,
 		fill: 0x000000 // Black text
 	});
 	transitionText.anchor.set(0.5, 0);
 	transitionText.x = 2048 / 2; // Center horizontally
 	transitionText.y = 100; // Near top of screen
-	game.addChild(transitionText);
 	// Create story text at bottom
 	var storyTextContent = storyTexts[currentStoryPanel - 1]; // currentStoryPanel is 1-indexed
 	storyText = new Text2(storyTextContent, {
 		size: 60,
@@ -1329,9 +1335,8 @@
 	});
 	storyText.anchor.set(0.5, 1); // Center horizontally, anchor at bottom
 	storyText.x = 2048 / 2; // Center horizontally
 	storyText.y = 2732 - 100; // Near bottom of screen with margin
-	game.addChild(storyText);
 }
 function hideTransitionScreen() {
 	// Destroy all current board objects including hero, princess, coins
 	gameGrid.destroyAll();
@@ -1411,9 +1416,9 @@
 	hero.gridRow = heroCell.row;
 	hero.currentCol = heroCell.col;
 	hero.x = GameConstants.GRID_LEFT + heroCell.col * GameConstants.CELL_SIZE + GameConstants.CELL_SIZE / 2;
 	hero.y = GameConstants.GRID_TOP + heroCell.row * GameConstants.CELL_SIZE + GameConstants.CELL_SIZE / 2;
-	game.addChild(hero);
+	midgroundContainer.addChild(hero);
 	// --- Step F: Fill with Coins Only ---
 	// Place a coin in every empty playable cell (except hero's cell)
 	totalCoins = 0;
 	for (var r = 0; r < gameGrid.playableRows; r++) {
@@ -1422,9 +1427,9 @@
 			if (!(r === heroCell.row && c === heroCell.col)) {
 				var coin = new Coin();
 				coin.x = GameConstants.GRID_LEFT + c * GameConstants.CELL_SIZE + GameConstants.CELL_SIZE / 2;
 				coin.y = GameConstants.GRID_TOP + r * GameConstants.CELL_SIZE + GameConstants.CELL_SIZE / 2;
-				game.addChild(coin);
+				midgroundContainer.addChild(coin);
 				gameGrid.grid[r][c] = coin;
 				totalCoins++;
 			}
 		}