/**** 
* 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();
				}
			});
		}
	};
	return self;
});
/** 
* 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
	});
	// Animation properties
	self.animationFrames = ['princess', 'princess2', 'princess3', 'princess4', 'princess3', 'princess2'];
	self.currentFrameIndex = 0;
	self.lastFrameTime = 0;
	self.frameInterval = 100; // 200ms per frame - smooth animation timing
	// Animation update method
	self.update = function () {
		var currentTime = Date.now();
		if (currentTime - self.lastFrameTime >= self.frameInterval) {
			self.lastFrameTime = currentTime;
			// Move to next frame
			self.currentFrameIndex = (self.currentFrameIndex + 1) % self.animationFrames.length;
			// Get the asset name for current frame
			var frameAsset = self.animationFrames[self.currentFrameIndex];
			// Destroy current graphic and create new one
			if (self.gfx) {
				self.gfx.destroy();
			}
			self.gfx = self.attachAsset(frameAsset, {
				anchorX: 0.5,
				anchorY: 0.5
			});
		}
	};
	return self;
});

/**** 
* Initialize Game
****/ 
/** 
* PlayableCell
* Responsibility: To model a single walkable, breakable cell in the top grid.
* It tracks its own health and visual state.
*/ 
/************************* 
* INITIALIZE & RUN GAME
*************************/
// 1. Create Game Instance
var game = new LK.Game({
	backgroundColor: 0,
	transparent: true
});

/**** 
* Game Code
****/ 
/** 
* PlayableCell
* Responsibility: To model a single walkable, breakable cell in the top grid.
* It tracks its own health and visual state.
*/ 
/** 
* 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.
*/ 
// Create layered containers for proper z-ordering
function PlayableCell(row, col) {
	// <-- Added row, col
	// Health: 4=pristine, 3, 2, 1=damaged, 0=hole
	this.health = 4;
	this.gfx = null; // The visual asset for this cell
	this.entity = null; // What's ON TOP of the cell (coin, key, etc.)
	this.row = row; // <-- Store its row
	this.col = col; // <-- Store its col
	this.updateVisual = function () {
		if (this.gfx) {
			this.gfx.destroy(); // Remove the old visual
		}
		var assetName = null;
		if (this.health === 4) {
			assetName = 'emptycell';
		} else if (this.health === 3) {
			assetName = 'emptycell2';
		} else if (this.health === 2) {
			assetName = 'emptycell3';
		} else if (this.health === 1) {
			assetName = 'emptycell4';
		}
		// If health is 0 or below, assetName stays null, creating a hole with no visual.
		if (assetName) {
			this.gfx = LK.getAsset(assetName, {
				anchorX: 0.5,
				anchorY: 0.5
			});
			// Position the new graphic and add it to the scene
			this.gfx.x = GameConstants.GRID_LEFT + this.col * GameConstants.CELL_SIZE + GameConstants.CELL_SIZE / 2;
			this.gfx.y = GameConstants.GRID_TOP + this.row * GameConstants.CELL_SIZE + GameConstants.CELL_SIZE / 2;
			midgroundContainer.addChild(this.gfx); // <-- Add it to the screen!
		} else {
			this.gfx = null; // Ensure gfx is null for holes - no visual asset should remain
		}
	};
	this.takeDamage = function () {
		if (this.health > 0) {
			this.health--;
			this.updateVisual();
		} else if (this.health === 0) {
			// Allow one more damage to fully remove the cell
			this.health--;
			this.updateVisual();
		}
	};
	this.isHole = function () {
		return this.health <= 0;
	};
	// Initialize the first visual
	this.updateVisual();
}
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.
*/ 
/** 
* GameConstants
* Responsibility: To hold all static configuration and magic numbers in one place
* for easy tuning and maintenance.
*/ 
function AntiCheatService(gridService, gameGrid) {
	this.gridService = gridService;
	this.gameGrid = gameGrid;
	this.disabledCells = []; // Array to store currently disabled cells
	this.cellsPerLayer = 2; // Number of cells to disable per layer
	this.initialize = function () {
		// Disable initial cells for round 1
		this.disableRandomCells();
	};
	this.disableRandomCells = function () {
		this.disabledCells = [];
		var disabledByRow = []; // Track disabled columns for each row
		// Process each beat layer in order: up (0), left (1), right (2), down (3)
		for (var r = 0; r < GameConstants.BEAT_ROWS; r++) {
			disabledByRow[r] = [];
			// Create list of available columns for this row
			var availableCols = [];
			for (var c = 0; c < 8; c++) {
				var canPlace = true;
				// Check minimum distance of 2 from already disabled cells in same row
				for (var i = 0; i < disabledByRow[r].length; i++) {
					if (Math.abs(c - disabledByRow[r][i]) < 3) {
						// minimum 2 tiles distance = 3 cells apart
						canPlace = false;
						break;
					}
				}
				// Check diagonal constraint for rows below the top layer
				// Only check the immediately previous row to avoid over-constraining
				if (r > 0 && canPlace) {
					var prevRow = r - 1; // Only check immediate previous row
					for (var j = 0; j < disabledByRow[prevRow].length; j++) {
						var prevCol = disabledByRow[prevRow][j];
						// Can't place if diagonally adjacent (same col, col-1, or col+1)
						if (c >= prevCol - 1 && c <= prevCol + 1) {
							canPlace = false;
							break;
						}
					}
				}
				if (canPlace) {
					availableCols.push(c);
				}
			}
			// If we don't have enough available columns, fall back to simpler constraints
			if (availableCols.length < this.cellsPerLayer) {
				availableCols = [];
				for (var c = 0; c < 8; c++) {
					var canPlace = true;
					// Only check minimum distance within same row
					for (var i = 0; i < disabledByRow[r].length; i++) {
						if (Math.abs(c - disabledByRow[r][i]) < 3) {
							canPlace = false;
							break;
						}
					}
					if (canPlace) {
						availableCols.push(c);
					}
				}
			}
			// Shuffle available columns
			for (var i = availableCols.length - 1; i > 0; i--) {
				var j = Math.floor(Math.random() * (i + 1));
				var temp = availableCols[i];
				availableCols[i] = availableCols[j];
				availableCols[j] = temp;
			}
			// Pick first two columns from shuffled available list
			var cellsToDisable = Math.min(this.cellsPerLayer, availableCols.length);
			for (var i = 0; i < cellsToDisable; i++) {
				var col = availableCols[i];
				disabledByRow[r].push(col);
				var cell = this.gameGrid.getBeatCell(r, col);
				if (cell) {
					this.disabledCells.push({
						row: r,
						col: col,
						cell: cell
					});
				}
			}
		}
	};
	this.reset = function () {
		// 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 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;
	};
	// Finds a random empty cell in the playable area
	this.findRandomEmptyPlayableCell = function () {
		var emptyCells = [];
		for (var r = 0; r < this.playableRows; r++) {
			for (var c = 0; c < this.cols; c++) {
				// Check if the cell is empty (no coin, no key, no hero)
				if (this.grid[r][c] && !this.grid[r][c].entity) {
					emptyCells.push({
						row: r,
						col: c
					});
				}
			}
		}
		if (emptyCells.length > 0) {
			var randomIndex = Math.floor(Math.random() * emptyCells.length);
			return emptyCells[randomIndex];
		}
		return null; // No empty cells found
	};
	// 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
};
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.createColumnHighlights = function () {
		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;
		}
	};
	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.createColumnHighlights();
	};
	// 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) - 50; // Move 50 pixels left
		var baseY = Math.floor(anchorY * guiH + 40) + 50; // Move 50 pixels down from original position
		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++) {
			// Show icons from left to right, hide from right to left as lives are lost
			this.livesIcons[i].visible = this.livesIcons.length - i <= currentLives;
		}
	};
	this.updateScore = function (newScore) {
		this.scoreTxt.setText(newScore);
	};
	// Main Highlighting Logic: shows current beat column position
	this.updateColumnHighlight = function (currentColumnIndex) {
		// Hide all highlights first
		for (var i = 0; i < this.columnHighlights.length; i++) {
			this.columnHighlights[i].alpha = 0;
		}
		// Show highlight for all rows in the current column
		for (var i = 0; i < GameConstants.BEAT_ROWS; 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.5; // much more visible highlight to show current column
			this.columnHighlights[i].tint = 0xffffff; // bright yellow tint for better visibility
			// Add pulsing animation to make it even more obvious
			tween(this.columnHighlights[i], {
				alpha: 0.25
			}, {
				duration: 300,
				easing: tween.easeInOut,
				loop: true,
				pingPong: true
			});
		}
	};
}
/** 
* 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 () {
		// --- ADD THIS BLOCK BACK IN ---
		// 1. Create a static background for each cell in the BEAT GRID
		for (var r = this.gameGrid.playableRows; r < this.gameGrid.rows; r++) {
			for (var c = 0; c < this.gameGrid.cols; c++) {
				// Get the 'cell' asset instead of 'emptycell'
				var bgCell = LK.getAsset('cell', {
					// <-- THE KEY CHANGE IS HERE
					anchorX: 0.5,
					anchorY: 0.5,
					alpha: 1.0 // Make it fully visible
				});
				// Position it correctly
				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;
				// Add it to the midground, behind the interactive icons
				midgroundContainer.addChild(bgCell);
			}
		}
		// --- END OF THE BLOCK TO ADD ---
		// 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 isDisabled = this.antiCheatService.isCellDisabled(beatRow, col); // CHECK STATUS
		var gfx = LK.getAsset(assetId, {
			anchorX: 0.5,
			anchorY: 0.5,
			alpha: isDisabled ? 0 : 0.25 // SET ALPHA BASED ON STATUS
		});
		// 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 pos = this.getGridPositionFromCoords(x, y);
		// If the click was outside the beat grid, pos will be null.
		if (!pos) {
			return null;
		}
		// Now that we have a definitive {row, col}, check if it's disabled.
		if (this.antiCheatService.isCellDisabled(pos.row, pos.col)) {
			return null; // Return null if disabled.
		}
		// If it's valid, get the cell object from the gameGrid.
		return this.gameGrid.getBeatCell(pos.row, pos.col);
	};
	// 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) {
		// --- Step 1: Find the column of the cell we're trying to modify.
		var col = -1;
		for (var c = 0; c < GameConstants.GRID_COLS; c++) {
			// We use cell.row, which is the beat row index (0-3)
			if (this.gameGrid.getBeatCell(cell.row, c) === cell) {
				col = c;
				break;
			}
		}
		// --- Step 2: The Unbreakable Guard Clause ---
		// If we couldn't find the cell's column OR if the AntiCheatService says it's disabled,
		// do absolutely nothing.
		if (col === -1 || this.antiCheatService.isCellDisabled(cell.row, col)) {
			return;
		}
		// --- Step 3: Perform the Toggle ---
		var needsChange = mode === 'add' && !cell.active || mode === 'remove' && cell.active;
		if (needsChange) {
			// If we are ADDING a beat, we must first deactivate any other beat in the same column.
			if (mode === 'add') {
				for (var r = 0; r < GameConstants.BEAT_ROWS; r++) {
					// Skip the cell we are currently trying to activate.
					if (r === cell.row) {
						continue;
					}
					var otherCellInColumn = this.gameGrid.getBeatCell(r, col);
					// --- THE FINAL FIX IS HERE ---
					// We MUST check if the "other" cell is disabled before we try to change its state.
					if (otherCellInColumn && otherCellInColumn.active && !this.antiCheatService.isCellDisabled(r, col)) {
						otherCellInColumn.setActive(false);
						this.updateCellVisual(otherCellInColumn, r, col);
					}
				}
			}
			// Now, toggle the state of the originally clicked cell.
			cell.toggle();
			// Update the visual of the originally clicked cell.
			this.updateCellVisual(cell, cell.row, col);
			// Notify the sequencer that a beat was placed.
			if (cell.active && typeof sequencerService !== "undefined" && !sequencerService.hasPlacedBeat) {
				sequencerService.hasPlacedBeat = true;
			}
		}
	};
	// Add this new method to GridService
	this.getGridPositionFromCoords = function (x, y) {
		// Check if the click is within the horizontal bounds of the beat grid
		if (x < GameConstants.GRID_LEFT || x > GameConstants.GRID_LEFT + GameConstants.GRID_COLS * GameConstants.CELL_SIZE) {
			return null;
		}
		// Check if the click is within the vertical bounds of the beat grid
		var beatGridTop = GameConstants.GRID_TOP + this.gameGrid.playableRows * GameConstants.CELL_SIZE;
		if (y < beatGridTop || y > beatGridTop + GameConstants.BEAT_ROWS * GameConstants.CELL_SIZE) {
			return null;
		}
		// If it's within the bounds, calculate the row and column
		var col = Math.floor((x - GameConstants.GRID_LEFT) / GameConstants.CELL_SIZE);
		var row = Math.floor((y - beatGridTop) / GameConstants.CELL_SIZE);
		// Return the logical grid position
		return {
			row: row,
			col: col
		};
	};
	this.updateCellVisual = function (cell, beatRow, col) {
		if (cell.gfx) {
			// No need to find the row and col, they are passed in directly.
			var isDisabled = this.antiCheatService.isCellDisabled(beatRow, col);
			if (isDisabled) {
				cell.gfx.alpha = 0; // Always force disabled cells to be transparent
			} else {
				cell.gfx.alpha = cell.active ? 1.0 : 0.25; // Normal behavior
			}
		}
	};
	// 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) {
		// --- Capture the state BEFORE the move ---
		var oldRow = this.hero.gridRow;
		var oldCol = this.hero.currentCol;
		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;
		// --- Add the onFinish callback to the tween ---
		tween(this.hero, {
			x: nx,
			y: this.hero.y
		}, {
			duration: 180,
			easing: tween.cubicOut,
			onFinish: function onFinish() {
				// This code runs ONLY after the hero arrives
				var previousCell = gameGrid.grid[oldRow][oldCol];
				if (previousCell) {
					previousCell.takeDamage();
				}
				// Check if hero landed on a hole after movement completes
				var currentCell = gameGrid.grid[playerService.hero.gridRow][playerService.hero.currentCol];
				if (currentCell && currentCell.isHole()) {
					LK.showGameOver();
					return;
				}
			}
		});
		AudioService.playMove();
	};
	// Move up or down by 1 row, with vertical teleport at edges of playable area
	this.moveVertical = function (direction) {
		// --- Capture the state BEFORE the move ---
		var oldRow = this.hero.gridRow;
		var oldCol = this.hero.currentCol;
		var minRow = 0;
		var maxRow = this.gameGrid.playableRows - 1;
		var newRow = this.hero.gridRow !== undefined ? this.hero.gridRow : GameConstants.CHAR_ROW;
		newRow += direction;
		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;
		// --- Add the onFinish callback to the tween ---
		tween(this.hero, {
			x: this.hero.x,
			y: ny
		}, {
			duration: 180,
			easing: tween.cubicOut,
			onFinish: function onFinish() {
				// This code runs ONLY after the hero arrives
				var previousCell = gameGrid.grid[oldRow][oldCol];
				if (previousCell) {
					previousCell.takeDamage();
				}
				// Check if hero landed on a hole after movement completes
				var currentCell = gameGrid.grid[playerService.hero.gridRow][playerService.hero.currentCol];
				if (currentCell && currentCell.isHole()) {
					LK.showGameOver();
					return;
				}
			}
		});
		AudioService.playMove();
	};
}
/** 
* 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, antiCheatService) {
	this.gridService = gridService;
	this.playerService = playerService;
	this.antiCheatService = antiCheatService;
	this.isPainting = false;
	this.paintMode = null;
	this.lastPaintedCell = null;
	this.handleDown = function (x, y) {
		// gridService.getCellAt now automatically returns null for disabled cells.
		var cell = this.gridService.getCellAt(x, y);
		// If cell is not null, we know for a fact it's a valid, clickable cell.
		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) {
			// gridService.getCellAt already returns null for disabled cells.
			var cell = this.gridService.getCellAt(x, y);
			// If we found a valid (non-disabled) cell and it's a new one...
			if (cell && cell !== this.lastPaintedCell) {
				this.lastPaintedCell = cell;
				// The now-fortified toggleCell will handle the rest.
				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, gameState, gameRulesService) {
	this.gridService = gridService;
	this.playerService = playerService;
	this.uiService = uiService;
	this.gameState = gameState;
	this.gameRulesService = gameRulesService;
	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;
		// --- LIFE SYSTEM LOGIC ---
		// Check if a full sequence has just ended (i.e., we're about to play beat 0)
		if (previousStep === GameConstants.GRID_COLS - 1) {
			// Delegate life system logic to GameRulesService
			if (this.gameRulesService.checkLifeSystem()) {
				return; // Game over - stop the game
			}
		}
		// --- END LIFE SYSTEM 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
			}
		}
		// Hole check is now handled in movement completion callbacks
		// (The rest of the function, like processPlayerCollision, comes after this)
		// Delegate all rule-based logic to GameRulesService
		this.gameRulesService.processPlayerCollision(hero);
	};
}
// Initialize GameStateManager
var gameState = new GameStateManager();
var transitionScreen = null;
var transitionOverlay = null;
var transitionAsset = null;
var transitionText = null;
var storyTexts = ["One day, Pengu heard the Princess playing from her tower, and the beautiful sound made his small world feel suddenly vast.", "That music sparked a deep longing in him, but he could only look at his own clumsy flippers with despair, hopeless he could ever play for her.", "Lost in his sorrow by the water's edge, an elder maestro found him. \"Music is not in the flippers,\" the old one said, \"it is a feeling that guides them.\"", "Taking the maestro's lesson to heart, Pengu began to practice in secret, filling the lonely nights with his tireless, hopeful effort.", "Feeling a flicker of confidence, he tried to share his music with friends, but their cruel mockery shattered his spirit like thin ice.", "So when he finally stood before the Princess, his nerve completely failed him. Overwhelmed, his flippers fumbled and he fled from his disastrous performance.", "Alone again, he finally understood. He had been playing for approval. Forgetting the others, he played only his true feelings, and a breathtaking melody rose up to enchant the village.", "Drawn by this magical new song, the Princess found him. As he played with all his heart, she began to play too, their two harmonies joining to become the perfect love song."];
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 (gameState.currentStoryPanel > 1) {
		storyAssetName = 'Transition_' + gameState.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 with word wrapping
	var storyTextContent = storyTexts[gameState.currentStoryPanel - 1]; // currentStoryPanel is 1-indexed
	// Word wrap the text to fit within screen bounds
	var maxWidth = 1800; // Maximum width for text (with margins)
	var words = storyTextContent.split(' ');
	var lines = [];
	var currentLine = '';
	for (var i = 0; i < words.length; i++) {
		var testLine = currentLine + (currentLine ? ' ' : '') + words[i];
		// Create temporary text to measure width
		var tempText = new Text2(testLine, {
			size: 60
		});
		if (tempText.width <= maxWidth) {
			currentLine = testLine;
		} else {
			if (currentLine) {
				lines.push(currentLine);
				currentLine = words[i];
			} else {
				// Single word is too long, force it onto a line
				lines.push(words[i]);
			}
		}
		tempText.destroy(); // Clean up temporary text
	}
	if (currentLine) {
		lines.push(currentLine);
	}
	// Create the wrapped text
	var wrappedText = lines.join('\n');
	storyText = new Text2(wrappedText, {
		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() {
	// Now it's a clean, high-level summary of the process
	_clearSceneAndState();
	_setupLogicalGrid();
	_createVisuals();
	_finalizeRoundSetup();
}
function _clearSceneAndState() {
	// Move all container.removeChildren() and gameState.resetForNewRound() calls here.
	backgroundContainer.removeChildren();
	midgroundContainer.removeChildren();
	foregroundContainer.removeChildren();
	// Add background asset to cover entire screen
	var backgroundAsset = LK.getAsset('Background', {
		anchorX: 0,
		anchorY: 0
	});
	backgroundAsset.x = 0;
	backgroundAsset.y = 0;
	backgroundContainer.addChild(backgroundAsset);
	playerService.reset();
	gameState.resetForNewRound();
	sequencerService.collectedInSequence = false;
	sequencerService.lifeSystemActive = false;
	sequencerService.hasPlacedBeat = false;
	uiService.updateLivesUI(gameState.lives);
	// 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;
		}
	}
}
function _setupLogicalGrid() {
	// Move all the logic for creating and placing logical objects
	// (coins, hero) into the gameGrid.grid array.
	// Create the logical beat cells
	gameGrid.initBeatGrid();
	antiCheatService.reset();
	// 1. Create a PlayableCell for every spot in the playable area
	for (var r = 0; r < gameGrid.playableRows; r++) {
		for (var c = 0; c < GameConstants.GRID_COLS; c++) {
			gameGrid.grid[r][c] = new PlayableCell(r, c);
		}
	}
	// 2. Now place entities ON TOP of these cells
	var cellPool = []; // We still need this to pick random spots
	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;
	}
	// Place Hero
	playerService.initialize();
	var hero = playerService.getHeroInstance();
	var heroCellPos = cellPool.shift();
	hero.gridRow = heroCellPos.row;
	hero.currentCol = heroCellPos.col;
	// IMPORTANT: Don't replace the cell, set the hero as its entity
	gameGrid.grid[heroCellPos.row][heroCellPos.col].entity = hero;
	// Place Coins
	gameState.totalCoins = 0;
	for (var r = 0; r < gameGrid.playableRows; r++) {
		for (var c = 0; c < GameConstants.GRID_COLS; c++) {
			// If the cell doesn't already have an entity (the hero)
			if (gameGrid.grid[r][c].entity === null) {
				var coin = new Coin();
				gameGrid.grid[r][c].entity = coin;
				gameState.totalCoins++;
			}
		}
	}
	// Store key and princess positions for later spawning
	var keyCell = cellPool.shift();
	var princessCell = cellPool.shift();
	gameState.keySpawnRow = keyCell.row;
	gameState.keySpawnCol = keyCell.col;
	gameState.princessSpawnRow = princessCell.row;
	gameState.princessSpawnCol = princessCell.col;
}
function _createVisuals() {
	// Create the background visuals (gridService.createAllVisuals())
	// Loop through the logical grid and create the visuals for coins, hero, etc.
	// and add them to the correct containers.
	gridService.createAllVisuals();
	// Create the visuals for the playable items
	for (var r = 0; r < gameGrid.playableRows; r++) {
		for (var c = 0; c < gameGrid.cols; c++) {
			var playableCell = gameGrid.grid[r][c];
			var entity = playableCell.entity;
			// Draw the entity on top of the cell (coin, hero, etc.)
			if (entity) {
				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;
				// Add entities to the FOREGROUND
				foregroundContainer.addChild(entity);
			}
		}
	}
	uiService.createColumnHighlights();
}
function _finalizeRoundSetup() {
	// Reset all beat grid cells to inactive and update visuals
	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.setActive(false);
				// The grid service is responsible for its own visuals
				gridService.updateCellVisual(cell, r, c);
			}
		}
	}
	AudioService.playNewLevel();
}
// --- 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 gameRulesService = new GameRulesService(gameState, gameGrid, uiService);
var inputService = new InputService(gridService, playerService, antiCheatService);
var sequencerService = new SequencerService(gridService, playerService, uiService, gameState, gameRulesService);
// 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)
gameState.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
		gameState.currentStoryPanel++;
		// Check if we've reached the end of the story
		if (gameState.currentStoryPanel > gameState.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 (!gameState.levelTransitioning) {
		gameState.playerHasKey = true; // Ensure player has key
		gameState.levelTransitioning = true; // Set transition flag
		showTransitionScreen(); // Show transition screen
	}
};
// End of file. All round/game start logic is now centralized in startNextRound.
/** 
* GameStateManager
* Responsibility: Single source of truth for the game's session state
*/ 
function GameStateManager() {
	this.currentRound = 1;
	this.totalCoins = 0;
	this.collectedCoins = 0;
	this.playerHasKey = false;
	this.keySpawned = false;
	this.princessSpawned = false;
	this.lives = 5;
	this.levelTransitioning = false;
	this.keySpawnRow = 0;
	this.keySpawnCol = 0;
	this.princessSpawnRow = 0;
	this.princessSpawnCol = 0;
	this.currentStoryPanel = 1;
	this.maxStoryPanels = 8;
	this.resetForNewRound = function () {
		this.currentRound++;
		this.collectedCoins = 0;
		this.playerHasKey = false;
		this.keySpawned = false;
		this.princessSpawned = false;
		this.levelTransitioning = false;
		this.lives = 5;
	};
	this.collectCoin = function () {
		this.collectedCoins++;
	};
	this.shouldSpawnKey = function () {
		return !this.keySpawned && this.collectedCoins >= Math.floor(this.totalCoins * 0.25);
	};
	this.shouldSpawnPrincess = function () {
		return !this.princessSpawned && this.collectedCoins >= Math.floor(this.totalCoins * 0.51) && this.playerHasKey;
	};
	this.setKeySpawned = function () {
		this.keySpawned = true;
	};
	this.setPrincessSpawned = function () {
		this.princessSpawned = true;
	};
	this.setPlayerHasKey = function (hasKey) {
		this.playerHasKey = hasKey;
	};
	this.setLevelTransitioning = function (transitioning) {
		this.levelTransitioning = transitioning;
	};
	this.setKeySpawnPosition = function (row, col) {
		this.keySpawnRow = row;
		this.keySpawnCol = col;
	};
	this.setPrincessSpawnPosition = function (row, col) {
		this.princessSpawnRow = row;
		this.princessSpawnCol = col;
	};
	this.advanceStoryPanel = function () {
		this.currentStoryPanel++;
		return this.currentStoryPanel > this.maxStoryPanels;
	};
	this.setLives = function (lives) {
		this.lives = lives;
	};
	this.setTotalCoins = function (total) {
		this.totalCoins = total;
	};
}
/** 
* GameRulesService
* Responsibility: To handle the consequences of player actions including coin collection,
* key/princess spawning, and life management logic.
*/ 
function GameRulesService(gameState, gameGrid, uiService) {
	this.gameState = gameState;
	this.gameGrid = gameGrid;
	this.uiService = uiService;
	this.checkLifeSystem = function () {
		// 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 (sequencerService.hasPlacedBeat && !sequencerService.lifeSystemActive) {
			sequencerService.lifeSystemActive = true;
		} else if (sequencerService.lifeSystemActive) {
			if (!sequencerService.collectedInSequence) {
				// Player failed to collect a coin in the last 8 beats. Deduct a life.
				this.gameState.lives--;
				this.uiService.updateLivesUI(this.gameState.lives); // Update the visual display
				if (this.gameState.lives <= 0) {
					LK.showGameOver();
					return true; // Indicate game over
				}
			}
		}
		// Reset the flag for the new sequence.
		sequencerService.collectedInSequence = false;
		return false; // Game continues
	};
	this.processPlayerCollision = function (hero) {
		var heroRow = hero.gridRow;
		var heroCol = hero.currentCol;
		var entity = this.gameGrid.grid[heroRow][heroCol].entity;
		if (entity instanceof Coin) {
			// Handle coin collection
			entity.collect();
			this.gameGrid.grid[heroRow][heroCol].entity = null;
			// Update collected coins counter
			this.gameState.collectedCoins++;
			// Apply combo multiplier to score
			var points = sequencerService.comboMultiplier;
			LK.setScore(LK.getScore() + points);
			this.uiService.updateScore(LK.getScore());
			AudioService.playCoinCollect();
			// Mark that we collected a coin in this sequence
			sequencerService.collectedInSequence = true;
			sequencerService.collectedThisBeat = true;
			// Increment combo multiplier by 1 for each consecutive coin
			sequencerService.comboMultiplier++;
			sequencerService.comboCount++;
			// Clear any enemy tracking
			sequencerService.enemyCellRow = undefined;
			sequencerService.enemyCellCol = undefined;
			// 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);
			}
			// Check spawns after coin collection
			this.checkSpawns();
			return true; // Coin was collected
		} else if (entity instanceof Key) {
			// Handle key collection
			this.gameState.playerHasKey = true;
			AudioService.playNewLevel(); // Play a special sound for key collection
			entity.destroy();
			this.gameGrid.grid[heroRow][heroCol].entity = null;
			// Check spawns after key collection in case princess should now appear
			this.checkSpawns();
			return true; // Key was collected
		} else if (entity instanceof Princess) {
			// Handle princess collision
			if (this.gameState.playerHasKey && !this.gameState.levelTransitioning) {
				this.gameState.levelTransitioning = true;
				showTransitionScreen();
				return true; // Princess interaction successful
			}
			// If player doesn't have key, do nothing (can't win yet)
		} else {
			// No entity at current position - clear any enemy tracking
			sequencerService.enemyCellRow = undefined;
			sequencerService.enemyCellCol = undefined;
			// No coin collected - reset combo if we had one
			if (sequencerService.comboMultiplier > 1) {
				sequencerService.comboMultiplier = 1;
				sequencerService.comboCount = 0;
			}
		}
		return false; // No significant collision
	};
	this.checkSpawns = function () {
		// Check if we should spawn the key (25% of coins collected)
		if (!this.gameState.keySpawned && this.gameState.collectedCoins >= Math.floor(this.gameState.totalCoins * 0.25)) {
			this.spawnKey();
		}
		// Check if we should spawn the princess (51% of coins collected AND key collected)
		if (!this.gameState.princessSpawned && this.gameState.collectedCoins >= Math.floor(this.gameState.totalCoins * 0.51) && this.gameState.playerHasKey) {
			this.spawnPrincess();
		}
	};
	this.spawnKey = function () {
		// Find a random empty cell in the playable area
		var emptyCell = this.gameGrid.findRandomEmptyPlayableCell();
		// 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);
			this.gameGrid.grid[emptyCell.row][emptyCell.col].entity = key;
			this.gameState.keySpawned = true;
		}
	};
	this.spawnPrincess = function () {
		// Find a random empty cell in the playable area
		var emptyCell = this.gameGrid.findRandomEmptyPlayableCell();
		// 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);
			this.gameGrid.grid[emptyCell.row][emptyCell.col].entity = princess;
			this.gameState.princessSpawned = true;
		}
	};
}

===================================================================
--- original.js
+++ change.js
@@ -634,10 +634,10 @@
 		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
+		var baseX = Math.floor(anchorX * guiW - totalWidth / 2) - 50; // Move 50 pixels left
+		var baseY = Math.floor(anchorY * guiH + 40) + 50; // Move 50 pixels down from original position
 		for (var i = 0; i < this.livesIcons.length; i++) {
 			var icon = this.livesIcons[i];
 			icon.x = baseX + i * this.livesIconSpacing;
 			icon.y = baseY;