/**** * 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 ****/ // 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. */ /** * PlayableCell * Responsibility: To model a single walkable, breakable cell in the top grid. * It tracks its own health and visual state. */ 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()) { // Create and show splash effect var splash = LK.getAsset('Splash', { anchorX: 0.5, anchorY: 0.5 }); splash.x = playerService.hero.x; splash.y = playerService.hero.y; foregroundContainer.addChild(splash); // Hide hero playerService.hero.visible = false; // Show splash for 200ms then game over LK.setTimeout(function () { LK.showGameOver(); }, 200); 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()) { // Create and show splash effect var splash = LK.getAsset('Splash', { anchorX: 0.5, anchorY: 0.5 }); splash.x = playerService.hero.x; splash.y = playerService.hero.y; foregroundContainer.addChild(splash); // Hide hero playerService.hero.visible = false; // Show splash for 200ms then game over LK.setTimeout(function () { LK.showGameOver(); }, 200); 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(); // 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; } }; }