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

/**** 
* Classes
****/ 
/** 
* 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
/** 
* 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.
*/ 
function BeatCell(row) {
	this.active = false;
	this.row = row;
	this.gfx = null; // We will create and manage the graphic externally
	this.visible = true; // Track visibility state
	this.toggle = function () {
		this.active = !this.active;
	};
	this.setActive = function (val) {
		if (this.active !== val) {
			this.toggle();
		}
	};
}
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;
					if (cell.gfx) {
						cell.gfx.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;
					if (cell.gfx) {
						cell.gfx.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 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); // Create the logical object.
				this.grid[gridRow][c] = cell; // Store it in the data grid.
			}
		}
	};
	// 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();
	};
}
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();
	};
	// Create visual representation for a BeatCell
	this.createAllVisuals = function () {
		// 1. Create the background cells and add them to the midground
		for (var r = 0; r < this.gameGrid.rows; r++) {
			for (var c = 0; c < this.gameGrid.cols; c++) {
				var bgCell = LK.getAsset('emptycell', {
					anchorX: 0.5,
					anchorY: 0.5,
					alpha: 1.0
				});
				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;
				midgroundContainer.addChild(bgCell);
			}
		}
		// 2. Create the beat cell graphics based on the logical grid
		for (var r = 0; r < this.gameGrid.beatRows; r++) {
			for (var c = 0; c < this.gameGrid.cols; c++) {
				var cell = this.gameGrid.getBeatCell(r, c);
				if (cell) {
					this.createCellVisual(cell, r, c);
				}
			}
		}
	};
	this.createCellVisual = function (cell, beatRow, col) {
		var assetId = 'cell';
		if (beatRow === 0) assetId = 'cellActive';else if (beatRow === 1) assetId = 'cellLeft';else if (beatRow === 2) assetId = 'cellRight';else if (beatRow === 3) assetId = 'cellDown';
		var gfx = LK.getAsset(assetId, {
			anchorX: 0.5,
			anchorY: 0.5,
			alpha: 0.1 // Start dim
		});
		// Position it
		var gridRow = this.gameGrid.playableRows + beatRow;
		gfx.x = GameConstants.GRID_LEFT + col * GameConstants.CELL_SIZE + GameConstants.CELL_SIZE / 2;
		gfx.y = GameConstants.GRID_TOP + gridRow * GameConstants.CELL_SIZE + GameConstants.CELL_SIZE / 2;
		// Add the graphic to the correct layer and attach it to the logical cell
		foregroundContainer.addChild(gfx);
		cell.gfx = gfx;
	};
	// 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) {
		if (cell.gfx) {
			cell.gfx.alpha = cell.active ? 1.0 : 0.1;
		}
	};
	// 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.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);
		}
	};
	this.handleUp = function () {
		this.isPainting = false;
		this.paintMode = null;
		this.lastPaintedCell = null;
	};
	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);
			}
		}
	};
}
/** 
* 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) && cell.gfx) {
				// Create bump animation: scale up to 110% then back to 100%
				tween(cell.gfx, {
					scaleX: 1.1,
					scaleY: 1.1
				}, {
					duration: 100,
					easing: tween.easeOut,
					onFinish: function (targetGfx) {
						return function () {
							tween(targetGfx, {
								scaleX: 1.0,
								scaleY: 1.0
							}, {
								duration: 100,
								easing: tween.easeIn
							});
						};
					}(cell.gfx)
				});
			}
		}
		// 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
	foregroundContainer.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
	foregroundContainer.addChild(transitionText);
	// 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
	foregroundContainer.addChild(storyText);
}
function hideTransitionScreen() {
	// Destroy all current board objects including hero, princess, coins
	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: Clear Containers and Reset Logic ---
	backgroundContainer.removeChildren();
	midgroundContainer.removeChildren();
	foregroundContainer.removeChildren();
	playerService.reset();
	// Reset all game state variables
	currentRound++;
	collectedCoins = 0;
	playerHasKey = false;
	keySpawned = false;
	princessSpawned = false;
	sequencerService.levelTransitioning = false;
	sequencerService.lives = 5;
	sequencerService.collectedInSequence = false;
	sequencerService.lifeSystemActive = false;
	sequencerService.hasPlacedBeat = false;
	uiService.updateLivesUI(sequencerService.lives);
	// --- Step B: Clear the logical grid data ---
	for (var r = 0; r < gameGrid.rows; r++) {
		for (var c = 0; c < gameGrid.cols; c++) {
			gameGrid.grid[r][c] = null;
		}
	}
	// --- Step C: Set up the LOGICAL Grid ---
	// 1. Create the logical beat cells
	gameGrid.initBeatGrid();
	// 2. Create and shuffle the cell pool for playable area
	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 D: Place LOGICAL objects and prepare data ---
	// 1. Initialize the logical Hero object
	playerService.initialize();
	var hero = playerService.getHeroInstance();
	// 2. Place Hero in logical grid
	var heroCell = cellPool.shift();
	hero.gridRow = heroCell.row;
	hero.currentCol = heroCell.col;
	// Store the hero in the logical grid, just like a coin.
	gameGrid.grid[heroCell.row][heroCell.col] = hero;
	// DO NOT add to container here.
	// 3. Create logical coins and store in grid (NO visuals)
	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();
				gameGrid.grid[r][c] = coin;
				totalCoins++;
			}
		}
	}
	// Store key and princess positions for later spawning
	var keyCell = cellPool.shift();
	var princessCell = cellPool.shift();
	keySpawnRow = keyCell.row;
	keySpawnCol = keyCell.col;
	princessSpawnRow = princessCell.row;
	princessSpawnCol = princessCell.col;
	// --- Step E: CREATE THE VISUALS ---
	// Now that the data grid is fully prepared, create all the visuals.
	gridService.createAllVisuals();
	// Now create the visuals for the playable items
	for (var r = 0; r < gameGrid.playableRows; r++) {
		for (var c = 0; c < gameGrid.cols; c++) {
			var entity = gameGrid.grid[r][c];
			if (entity) {
				// Set its position and add it to the midground container
				entity.x = GameConstants.GRID_LEFT + c * GameConstants.CELL_SIZE + GameConstants.CELL_SIZE / 2;
				entity.y = GameConstants.GRID_TOP + r * GameConstants.CELL_SIZE + GameConstants.CELL_SIZE / 2;
				midgroundContainer.addChild(entity);
			}
		}
	}
	// --- Step F: Final Housekeeping ---
	antiCheatService.reset();
	// Reset all beat grid cells to inactive
	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);
			}
		}
	}
	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
// 1. Instantiate All Services (no change here)
var uiService = new UIService(game);
var gameGrid = new GameGrid(game);
var antiCheatService = new AntiCheatService(null, gameGrid);
var gridService = new GridService(game, gameGrid, antiCheatService);
var playerService = new PlayerService(game, gameGrid);
var inputService = new InputService(gridService, playerService);
var sequencerService = new SequencerService(gridService, playerService, uiService);
// Pass the gridService reference back to antiCheatService now that it exists
antiCheatService.gridService = gridService;
// 2. Initialize Core Services
uiService.initialize();
sequencerService.initialize();
// 3. Start the First Round (places logical objects and non-beat-grid visuals)
currentRound = 0;
startNextRound();
// 4. NOW, create the beat grid visuals
gridService.createAllVisuals(); // <-- This will now work correctly
// 5. Initialize the anti-cheat system last, now that visuals exist
antiCheatService.initialize();
// 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
@@ -1392,8 +1392,11 @@
 	// 2. Place Hero in logical grid
 	var heroCell = cellPool.shift();
 	hero.gridRow = heroCell.row;
 	hero.currentCol = heroCell.col;
+	// Store the hero in the logical grid, just like a coin.
+	gameGrid.grid[heroCell.row][heroCell.col] = hero;
+	// DO NOT add to container here.
 	// 3. Create logical coins and store in grid (NO visuals)
 	totalCoins = 0;
 	for (var r = 0; r < gameGrid.playableRows; r++) {
 		for (var c = 0; c < GameConstants.GRID_COLS; c++) {