// ============================================================ // PAW MATCH — Complete Match-3 Puzzle Engine // All game logic: board gen, swap, match, cascade, scoring // ============================================================ const ROWS = 8; const COLS = 8; const TYPES = ['paw', 'bone', 'ball', 'treat', 'bowl', 'yarn', 'fish']; const KNOWN_TYPES = { paw: true, bone: true, ball: true, treat: true, bowl: true, yarn: true, fish: true, collar: true, toy: true, }; const MAX_CASCADE_DEPTH = 50; const MAX_RESOLVE_PHASES = 160; const MAX_RESOLVE_MS = 15000; // --------------- Arcade Shuffle Music System --------------- var ARCADE_TRACKS = [ 'cdn/music-instrumental-retro-arcade-upbeat-puzzle.mp3', 'cdn/music-instrumental-pixel-puzzle-bouncy-chiptune.mp3', 'cdn/music-instrumental-funky-arcade-groove.mp3', 'cdn/music-instrumental-happy-puzzle-pop-bounce.mp3', 'cdn/music-instrumental-energetic-8bit-arcade-loop.mp3', 'cdn/music-instrumental-cheerful-puzzle-game-loop.mp3', ]; var MUSIC_SHUFFLE_INTERVAL = 90; // seconds between track changes // --------------- Helpers --------------- function idx(r, c) { return r * COLS + c; } function row(i) { return (i / COLS) | 0; } function col(i) { return i % COLS; } function isAdjacent(a, b) { const ra = row(a), ca = col(a), rb = row(b), cb = col(b); return (Math.abs(ra - rb) + Math.abs(ca - cb)) === 1; } // --------------- Progressive Difficulty: Active Types --------------- function getActiveTypes(level) { if (level < 50) return TYPES.slice(0, 4); // paw, bone, ball, treat if (level < 100) return TYPES.slice(0, 5); // + bowl return TYPES.slice(0, 6); // + yarn (cap at 6, never 7) } function randType(api, level) { var active = getActiveTypes(level || 1); return active[(api.random() * active.length) | 0]; } // Pick a tile type biased toward creating near-matches (2-in-a-row) // without creating instant 3-matches. ~40% chance to pick a neighbor type. function biasedType(api, board, r, c, level) { var BIAS_CHANCE = 0.4; var active = getActiveTypes(level || 1); if (api.random() < BIAS_CHANCE) { // Gather types that would create a 2-in-a-row (but NOT a 3-match) var candidates = []; for (var t = 0; t < active.length; t++) { var tp = active[t]; if (wouldMatchAtFull(board, r, c, tp)) continue; // skip — would create instant match if (hasAdjacentOfType(board, r, c, tp)) { candidates.push(tp); } } if (candidates.length > 0) { return candidates[(api.random() * candidates.length) | 0]; } } // Fallback: fully random from active types return randType(api, level); } // Check if any immediate neighbor already has this type (creating a 2-in-a-row) function hasAdjacentOfType(board, r, c, type) { // Check below (most important — gravity drops tiles down) if (r < ROWS - 1) { var below = board[idx(r + 1, c)]; if (below && below.type === type) return true; } // Check left if (c > 0) { var left = board[idx(r, c - 1)]; if (left && left.type === type) return true; } // Check right if (c < COLS - 1) { var right = board[idx(r, c + 1)]; if (right && right.type === type) return true; } // Check above if (r > 0) { var above = board[idx(r - 1, c)]; if (above && above.type === type) return true; } return false; } function isKnownType(type) { return !!KNOWN_TYPES[type]; } function stampTilePosition(tile, r, c) { if (!tile) return null; tile.row = r; tile.col = c; return tile; } function syncBoardCoordinates(board) { for (var i = 0; i < ROWS * COLS; i++) { if (board[i]) stampTilePosition(board[i], row(i), col(i)); } return board; } function analyzeBoard(board) { var seenIds = {}; var nullCount = 0; var unknownCount = 0; var duplicateIdCount = 0; var coordMismatchCount = 0; var outOfBoundsCount = 0; for (var i = 0; i < ROWS * COLS; i++) { var tile = board[i]; if (!tile) { nullCount++; continue; } if (!isKnownType(tile.type)) unknownCount++; if (tile.id === undefined || tile.id === null || seenIds[tile.id]) duplicateIdCount++; else seenIds[tile.id] = true; var rr = row(i), cc = col(i); if (tile.row !== rr || tile.col !== cc) coordMismatchCount++; if (tile.row === undefined || tile.col === undefined || tile.row < 0 || tile.row >= ROWS || tile.col < 0 || tile.col >= COLS) { outOfBoundsCount++; } } var fatal = unknownCount > 0 || duplicateIdCount > 0 || coordMismatchCount > 0 || outOfBoundsCount > 0; var floating = boardHasFloatingTiles(board); return { nullCount: nullCount, unknownCount: unknownCount, duplicateIdCount: duplicateIdCount, coordMismatchCount: coordMismatchCount, outOfBoundsCount: outOfBoundsCount, floating: floating, fatal: fatal, broken: fatal || nullCount > 0 || floating, }; } function makeTile(api, type, counter, level, r, c) { var tileType = isKnownType(type) ? type : randType(api, level); return stampTilePosition({ type: tileType, special: null, id: counter, explosive: false }, r, c); } // --------------- Board Generation (no pre-existing matches) --------------- function generateBoard(api, startCounter, level) { var counter = startCounter; var board = []; var lvl = level || 1; for (var i = 0; i < ROWS * COLS; i++) { var r = row(i), c = col(i); var attempts = 0; var tile; do { var type = biasedType(api, board, r, c, lvl); tile = makeTile(api, type, counter, lvl, r, c); attempts++; } while (attempts < 30 && wouldMatchAt(board, i, tile.type)); counter++; board.push(tile); } return { board: board, counter: counter }; } function wouldMatchAt(board, index, type) { var r = row(index), c = col(index); // Check horizontal left-2 if (c >= 2 && board[idx(r, c - 1)] && board[idx(r, c - 2)] && board[idx(r, c - 1)].type === type && board[idx(r, c - 2)].type === type) { return true; } // Check vertical up-2 if (r >= 2 && board[idx(r - 1, c)] && board[idx(r - 2, c)] && board[idx(r - 1, c)].type === type && board[idx(r - 2, c)].type === type) { return true; } return false; } // --------------- Match Detection --------------- // Check if two tiles are compatible for matching purposes. // Universal bombs are wildcards — they match any tile type. function tilesMatch(tileA, tileB) { if (!tileA || !tileB) return false; if (tileA.special === 'universalBomb' || tileB.special === 'universalBomb') return true; return tileA.type === tileB.type; } // Get the effective match type for a run of tiles. // If a universalBomb is in the run, use the first concrete type found. function getRunType(board, indices) { for (var i = 0; i < indices.length; i++) { var t = board[indices[i]]; if (t && t.special !== 'universalBomb') return t.type; } // All universal bombs — use the first tile's stored type return board[indices[0]] ? board[indices[0]].type : 'paw'; } function findMatches(board) { var matched = {}; var matchGroups = []; // Horizontal for (var r = 0; r < ROWS; r++) { var c = 0; while (c < COLS) { var startTile = board[idx(r, c)]; if (!startTile) { c++; continue; } var runIndices = [idx(r, c)]; var end = c + 1; while (end < COLS) { var nextTile = board[idx(r, end)]; if (!nextTile) break; // Check if this tile is compatible with the run // A universal bomb matches anything; otherwise types must match the run's concrete type var runType = getRunType(board, runIndices); var nextIsUB = nextTile.special === 'universalBomb'; var startIsUB = startTile.special === 'universalBomb' && runIndices.length === 1; if (nextIsUB || nextTile.type === runType || startIsUB) { runIndices.push(idx(r, end)); end++; } else { break; } } if (runIndices.length >= 3) { var groupType = getRunType(board, runIndices); var group = { direction: 'h', indices: runIndices, type: groupType }; for (var k = 0; k < runIndices.length; k++) { matched[runIndices[k]] = true; } matchGroups.push(group); } c = end; } } // Vertical for (var c2 = 0; c2 < COLS; c2++) { var r2 = 0; while (r2 < ROWS) { var startTile2 = board[idx(r2, c2)]; if (!startTile2) { r2++; continue; } var runIndices2 = [idx(r2, c2)]; var end2 = r2 + 1; while (end2 < ROWS) { var nextTile2 = board[idx(end2, c2)]; if (!nextTile2) break; var runType2 = getRunType(board, runIndices2); var nextIsUB2 = nextTile2.special === 'universalBomb'; var startIsUB2 = startTile2.special === 'universalBomb' && runIndices2.length === 1; if (nextIsUB2 || nextTile2.type === runType2 || startIsUB2) { runIndices2.push(idx(end2, c2)); end2++; } else { break; } } if (runIndices2.length >= 3) { var groupType2 = getRunType(board, runIndices2); var group2 = { direction: 'v', indices: runIndices2, type: groupType2 }; for (var k2 = 0; k2 < runIndices2.length; k2++) { matched[runIndices2[k2]] = true; } matchGroups.push(group2); } r2 = end2; } } return { matched: matched, matchGroups: matchGroups }; } // --------------- Special Tile Detection --------------- function determineSpecials(matchGroups, swapIdx, randomRef, cascadeStep) { // Returns array of { index, special, pawTier? } to create var specials = []; var indexInGroup = {}; // index -> list of groups containing it for (var g = 0; g < matchGroups.length; g++) { var group = matchGroups[g]; for (var i = 0; i < group.indices.length; i++) { var ii = group.indices[i]; if (!indexInGroup[ii]) indexInGroup[ii] = []; indexInGroup[ii].push(g); } } // Collect all unique indices in merged T/L shapes for counting var intersections = {}; var intersectionGroupSets = {}; // intersection idx -> set of group indices var keys = Object.keys(indexInGroup); for (var k = 0; k < keys.length; k++) { var idx2 = parseInt(keys[k]); if (indexInGroup[idx2].length >= 2) { var hasH = false, hasV = false; for (var gi = 0; gi < indexInGroup[idx2].length; gi++) { var grp = matchGroups[indexInGroup[idx2][gi]]; if (grp.direction === 'h') hasH = true; if (grp.direction === 'v') hasV = true; } if (hasH && hasV) { intersections[idx2] = true; intersectionGroupSets[idx2] = indexInGroup[idx2].slice(); } } } // Process intersections: count unique tiles in all connected groups var usedByIntersection = {}; // groups consumed by T/L processing var intersectionKeys = Object.keys(intersections); for (var ik = 0; ik < intersectionKeys.length; ik++) { var iIdx = parseInt(intersectionKeys[ik]); var connectedGroups = intersectionGroupSets[iIdx]; var allGroupsUsed = true; for (var cg = 0; cg < connectedGroups.length; cg++) { if (usedByIntersection[connectedGroups[cg]]) { allGroupsUsed = false; break; } } if (!allGroupsUsed) continue; // groups already consumed // Count unique tiles across all connected groups var mergedTiles = {}; for (var mg = 0; mg < connectedGroups.length; mg++) { var mGroup = matchGroups[connectedGroups[mg]]; for (var mi = 0; mi < mGroup.indices.length; mi++) { mergedTiles[mGroup.indices[mi]] = true; } usedByIntersection[connectedGroups[mg]] = true; } var mergedCount = Object.keys(mergedTiles).length; if (mergedCount >= 5) { // 5+ tiles across an intersecting T/L shape → powerful special // During cascades (step >= 2), create a pawBomb instead if (cascadeStep >= 2) { specials.push({ index: iIdx, special: 'pawBomb', pawTier: getPawBombTier(cascadeStep) }); } else { specials.push({ index: iIdx, special: 'colorBomb' }); } } } // Process remaining groups not consumed by intersections for (var g2 = 0; g2 < matchGroups.length; g2++) { if (usedByIntersection[g2]) continue; var grp2 = matchGroups[g2]; if (grp2.indices.length >= 5) { // 5+ in a straight line → colorBomb normally, pawBomb during cascades var pos = pickSpecialPos(grp2.indices, swapIdx); if (cascadeStep >= 2) { specials.push({ index: pos, special: 'pawBomb', pawTier: getPawBombTier(cascadeStep) }); } else { specials.push({ index: pos, special: 'colorBomb' }); } } else if (grp2.indices.length === 4) { var pos2 = pickSpecialPos(grp2.indices, swapIdx); if (cascadeStep >= 2) { // During cascades, 4-matches create pawBombs instead of lines specials.push({ index: pos2, special: 'pawBomb', pawTier: getPawBombTier(cascadeStep) }); } else { var spec = grp2.direction === 'h' ? 'lineH' : 'lineV'; specials.push({ index: pos2, special: spec }); } } } return specials; } function pickSpecialPos(indices, swapIdx) { if (swapIdx !== null && swapIdx !== undefined) { for (var i = 0; i < indices.length; i++) { if (indices[i] === swapIdx) return swapIdx; } } return indices[((indices.length / 2) | 0)]; } // --------------- Special Tile Activation --------------- function activateSpecials(board, matchedMap) { var extra = {}; var activated = []; var indices = Object.keys(matchedMap); for (var i = 0; i < indices.length; i++) { var ii = parseInt(indices[i]); var tile = board[ii]; if (!tile || !tile.special) continue; activated.push({ index: ii, special: tile.special, type: tile.type }); if (tile.special === 'lineH') { var r = row(ii); for (var c = 0; c < COLS; c++) extra[idx(r, c)] = true; } else if (tile.special === 'lineV') { var c2 = col(ii); for (var r2 = 0; r2 < ROWS; r2++) extra[idx(r2, c2)] = true; } else if (tile.special === 'universalBomb') { // Universal bomb: 3×3 blast var br = row(ii), bc = col(ii); for (var dr = -1; dr <= 1; dr++) { for (var dc = -1; dc <= 1; dc++) { var nr = br + dr, nc = bc + dc; if (nr >= 0 && nr < ROWS && nc >= 0 && nc < COLS) { extra[idx(nr, nc)] = true; } } } } else if (tile.special === 'colorBomb') { // Color bomb: 5×5 blast var cbr = row(ii), cbc = col(ii); for (var cdr = -2; cdr <= 2; cdr++) { for (var cdc = -2; cdc <= 2; cdc++) { var cnr = cbr + cdr, cnc = cbc + cdc; if (cnr >= 0 && cnr < ROWS && cnc >= 0 && cnc < COLS) { extra[idx(cnr, cnc)] = true; } } } } else if (tile.special === 'pawBomb') { var pbr = row(ii), pbc = col(ii); var pbTier = tile.pawTier || 1; var pbOffsets = getPawBombOffsets(pbTier); for (var pbo = 0; pbo < pbOffsets.length; pbo++) { var pbnr = pbr + pbOffsets[pbo][0], pbnc = pbc + pbOffsets[pbo][1]; if (pbnr >= 0 && pbnr < ROWS && pbnc >= 0 && pbnc < COLS) { extra[idx(pbnr, pbnc)] = true; } } } } // Check if any extra-cleared tiles are ALSO specials — chain them var extraKeys = Object.keys(extra); var chainedAny = true; var seen = {}; for (var si = 0; si < indices.length; si++) seen[indices[si]] = true; while (chainedAny) { chainedAny = false; for (var e = 0; e < extraKeys.length; e++) { var eIdx = parseInt(extraKeys[e]); if (seen[eIdx]) continue; seen[eIdx] = true; var eTile = board[eIdx]; if (!eTile || !eTile.special) continue; activated.push({ index: eIdx, special: eTile.special, type: eTile.type }); chainedAny = true; if (eTile.special === 'lineH') { var er = row(eIdx); for (var ec = 0; ec < COLS; ec++) { var eii = idx(er, ec); if (!extra[eii]) { extra[eii] = true; extraKeys.push('' + eii); } } } else if (eTile.special === 'lineV') { var ec2 = col(eIdx); for (var er2 = 0; er2 < ROWS; er2++) { var eii2 = idx(er2, ec2); if (!extra[eii2]) { extra[eii2] = true; extraKeys.push('' + eii2); } } } else if (eTile.special === 'universalBomb') { var ebr = row(eIdx), ebc = col(eIdx); for (var edr = -1; edr <= 1; edr++) { for (var edc = -1; edc <= 1; edc++) { var enr = ebr + edr, enc = ebc + edc; if (enr >= 0 && enr < ROWS && enc >= 0 && enc < COLS) { var eii3 = idx(enr, enc); if (!extra[eii3]) { extra[eii3] = true; extraKeys.push('' + eii3); } } } } } else if (eTile.special === 'colorBomb') { var ecbr = row(eIdx), ecbc = col(eIdx); for (var ecdr = -2; ecdr <= 2; ecdr++) { for (var ecdc = -2; ecdc <= 2; ecdc++) { var ecnr = ecbr + ecdr, ecnc = ecbc + ecdc; if (ecnr >= 0 && ecnr < ROWS && ecnc >= 0 && ecnc < COLS) { var eii4 = idx(ecnr, ecnc); if (!extra[eii4]) { extra[eii4] = true; extraKeys.push('' + eii4); } } } } } else if (eTile.special === 'pawBomb') { var epbr = row(eIdx), epbc = col(eIdx); var epbTier = eTile.pawTier || 1; var epbOffsets = getPawBombOffsets(epbTier); for (var epbo = 0; epbo < epbOffsets.length; epbo++) { var epbnr = epbr + epbOffsets[epbo][0], epbnc = epbc + epbOffsets[epbo][1]; if (epbnr >= 0 && epbnr < ROWS && epbnc >= 0 && epbnc < COLS) { var eii5 = idx(epbnr, epbnc); if (!extra[eii5]) { extra[eii5] = true; extraKeys.push('' + eii5); } } } } } } // Merge extra into matchedMap for (var ef = 0; ef < extraKeys.length; ef++) { matchedMap[extraKeys[ef]] = true; } return activated; } function expandClearMap(board, initialCleared) { var cleared = {}; var queue = []; var activated = []; var explosiveTiles = []; var activatedSpecials = {}; var detonatedExplosives = {}; var seedKeys = Object.keys(initialCleared || {}); for (var i = 0; i < seedKeys.length; i++) { var seedIdx = parseInt(seedKeys[i]); if (!cleared[seedIdx]) { cleared[seedIdx] = true; queue.push(seedIdx); } } for (var qi = 0; qi < queue.length; qi++) { var ii = queue[qi]; var tile = board[ii]; if (!tile) continue; if (tile.special && !activatedSpecials[ii]) { activatedSpecials[ii] = true; activated.push({ index: ii, special: tile.special, type: tile.type }); var specialCleared = {}; activateSingleSpecial(board, ii, specialCleared); var specialKeys = Object.keys(specialCleared); for (var sk = 0; sk < specialKeys.length; sk++) { var specialIdx = parseInt(specialKeys[sk]); if (!cleared[specialIdx]) { cleared[specialIdx] = true; queue.push(specialIdx); } } } if (tile.explosive && !tile.special && !detonatedExplosives[ii]) { detonatedExplosives[ii] = true; explosiveTiles.push({ row: row(ii), col: col(ii) }); var er = row(ii), ec = col(ii); for (var dr = -1; dr <= 1; dr++) { for (var dc = -1; dc <= 1; dc++) { var nr = er + dr, nc = ec + dc; if (nr >= 0 && nr < ROWS && nc >= 0 && nc < COLS) { var blastIdx = idx(nr, nc); if (!cleared[blastIdx]) { cleared[blastIdx] = true; queue.push(blastIdx); } } } } } } return { cleared: cleared, activated: activated, explosiveTiles: explosiveTiles }; } function collectActivatedSpecialTiles(activated, specialName) { var tiles = []; for (var i = 0; i < activated.length; i++) { if (activated[i].special === specialName) { tiles.push({ index: activated[i].index, type: activated[i].type }); } } return tiles; } function snapshotClearedTiles(board, indices) { var tiles = []; for (var i = 0; i < indices.length; i++) { var ii = indices[i]; var tile = board[ii]; if (!tile) continue; var snapshot = { index: ii, id: tile.id, type: tile.type, row: tile.row, col: tile.col, special: tile.special || null, explosive: !!tile.explosive, }; if (tile.golden === true) snapshot.golden = true; if (tile.bomb === true) snapshot.bomb = true; if (tile.pawTier !== undefined && tile.pawTier !== null) snapshot.pawTier = tile.pawTier; tiles.push(snapshot); } return tiles; } // --------------- Cascade Step Multiplier --------------- function getCascadeMultiplier(cascadeStep) { // Step 1 = x1.0, Step 2 = x1.5, Step 3 = x2.0, Step 4+ = +0.5 each, cap x4.0 if (cascadeStep <= 1) return 1.0; var mult = 1.0 + (cascadeStep - 1) * 0.5; if (mult > 4.0) mult = 4.0; return mult; } // --------------- Match Base Points --------------- function getMatchBasePoints(matchLen) { if (matchLen >= 5) return 350; if (matchLen === 4) return 220; return 100; // 3-match } // --------------- Combo Tier Helpers (kept for UI) --------------- function getTierFromMeter(meter) { if (meter >= 90) return 4; if (meter >= 75) return 3; if (meter >= 50) return 2; if (meter >= 25) return 1; return 0; } function getTierMultiplier(tier) { if (tier >= 4) return 5; if (tier >= 3) return 3; if (tier >= 2) return 2; if (tier >= 1) return 1.5; return 1; } // Combo meter feeds faster at early levels for more feel-good moments function comboMeterFeed(combo, level) { var base = 8; if (level <= 5) base = 14; else if (level <= 10) base = 11; return base * combo; } var TIER_SOUNDS = { 1: 'cdn/sfx-powerup-chime-ascending.mp3', 2: 'cdn/sfx-powerup-electric-buzz.mp3', 3: 'cdn/sfx-powerup-fire-ignite-roar.mp3', 4: 'cdn/sfx-powerup-fever-mode-siren.mp3', }; function getMatchFeedback(points, cascadeStep) { if (points >= 800) return { text: 'LEGENDARY!', tier: 'legendary' }; if (points >= 500) return { text: 'INCREDIBLE!', tier: 'incredible' }; if (points >= 300) return { text: 'AMAZING!', tier: 'amazing' }; if (cascadeStep >= 3) return { text: 'Cascade x' + cascadeStep + '!', tier: 'great' }; if (points >= 150) return { text: 'Sweet!', tier: 'great' }; return { text: 'Nice!', tier: 'good' }; } // --------------- Special + Special Combination --------------- function isSpecial(tile) { return tile && tile.special && tile.special !== null; } function isUniversalBomb(s) { return s === 'universalBomb'; } function isColorBomb(s) { return s === 'colorBomb'; } function isLine(s) { return s === 'lineH' || s === 'lineV'; } function isPawBomb(s) { return s === 'pawBomb'; } function isAnyBomb(s) { return s === 'universalBomb' || s === 'colorBomb' || s === 'pawBomb'; } // --------------- Paw Bomb Offset Patterns --------------- // Each tier defines [row_offset, col_offset] from center. // Shape: pad at center/bottom, toe beans pointing upward (negative row). var PAW_OFFSETS = {}; // Tier 1: 3×3 pad + 3 toes above = 12 cells PAW_OFFSETS[1] = [ // Pad (3×3 centered at 0,0 offset slightly down) [0,-1],[0,0],[0,1], [1,-1],[1,0],[1,1], [-1,-1],[-1,0],[-1,1], // 3 toe beans above [-2,-1],[-2,0],[-2,1] ]; // Tier 2: bigger pad + 4 toes reaching 2 cells = ~13 cells PAW_OFFSETS[2] = [ // Pad (3×3) [0,-1],[0,0],[0,1], [1,-1],[1,0],[1,1], [-1,-1],[-1,0],[-1,1], // 4 toe beans reaching up 2 [-2,-2],[-3,-2], [-2,-1],[-3,-1], [-2,1],[-3,1], [-2,2],[-3,2] ]; // Tier 3: 4×4 pad + 4 toes reaching 3 cells = ~20 cells PAW_OFFSETS[3] = [ // Pad (4×4 centered) [0,-1],[0,0],[0,1],[0,2], [1,-1],[1,0],[1,1],[1,2], [-1,-1],[-1,0],[-1,1],[-1,2], [2,-1],[2,0],[2,1],[2,2], // 4 toe beans reaching 3 up [-2,-2],[-3,-2],[-4,-2], [-2,0],[-3,0],[-4,0], [-2,1],[-3,1],[-4,1], [-2,3],[-3,3],[-4,3] ]; // Tier 4: 5×5 pad + 5 toes reaching to edges = ~30 cells PAW_OFFSETS[4] = [ // Pad (5×5) [-2,-2],[-2,-1],[-2,0],[-2,1],[-2,2], [-1,-2],[-1,-1],[-1,0],[-1,1],[-1,2], [0,-2],[0,-1],[0,0],[0,1],[0,2], [1,-2],[1,-1],[1,0],[1,1],[1,2], [2,-2],[2,-1],[2,0],[2,1],[2,2], // 5 toes reaching upward [-3,-3],[-4,-3],[-5,-3], [-3,-1],[-4,-1],[-5,-1], [-3,0],[-4,0],[-5,0], [-3,1],[-4,1],[-5,1], [-3,3],[-4,3],[-5,3] ]; // Tier 5: MEGA PAW — almost full board, paw shaped, only corners survive PAW_OFFSETS[5] = (function() { var offsets = []; for (var dr = -4; dr <= 4; dr++) { for (var dc = -4; dc <= 4; dc++) { // Skip far corners to keep the paw shape var dist = Math.abs(dr) + Math.abs(dc); if (dist > 6) continue; offsets.push([dr, dc]); } } // Add extended toe beans at top for (var tc = -3; tc <= 3; tc++) { offsets.push([-5, tc]); offsets.push([-6, tc]); } offsets.push([-7, -2]); offsets.push([-7, -1]); offsets.push([-7, 0]); offsets.push([-7, 1]); offsets.push([-7, 2]); return offsets; })(); function getPawBombOffsets(tier) { return PAW_OFFSETS[tier] || PAW_OFFSETS[1]; } function getPawBombTier(cascadeStep) { var tier = cascadeStep; if (tier < 1) tier = 1; if (tier > 5) tier = 5; return tier; } function handleSpecialSwap(board, a, b, api, sfxVol) { var tileA = board[a]; var tileB = board[b]; if (!tileA || !tileB) return null; var specA = tileA.special; var specB = tileB.special; // Both must be special for a special+special combo if (!specA || !specB) return null; var cleared = {}; var bonusScore = 0; // universalBomb + universalBomb → clear entire board if (isUniversalBomb(specA) && isUniversalBomb(specB)) { for (var i = 0; i < board.length; i++) { if (board[i]) cleared[i] = true; } bonusScore = 800; return { cleared: cleared, bonusScore: bonusScore, type: 'universalBomb+universalBomb' }; } // colorBomb + colorBomb → massive 7×7 blast if (isColorBomb(specA) && isColorBomb(specB)) { var megaPos = a; var mr = row(megaPos), mc = col(megaPos); for (var mdr = -3; mdr <= 3; mdr++) { for (var mdc = -3; mdc <= 3; mdc++) { var mnr = mr + mdr, mnc = mc + mdc; if (mnr >= 0 && mnr < ROWS && mnc >= 0 && mnc < COLS) { cleared[idx(mnr, mnc)] = true; } } } bonusScore = 700; return { cleared: cleared, bonusScore: bonusScore, type: 'colorBomb+colorBomb' }; } // universalBomb + colorBomb → clear all tiles of colorBomb's type + 3×3 around each if ((isUniversalBomb(specA) && isColorBomb(specB)) || (isColorBomb(specA) && isUniversalBomb(specB))) { var cbTile = isColorBomb(specA) ? tileA : tileB; var targetType = cbTile.type; var typeTargets = []; for (var ti = 0; ti < board.length; ti++) { if (board[ti] && board[ti].type === targetType) { typeTargets.push(ti); cleared[ti] = true; } } for (var tt = 0; tt < typeTargets.length; tt++) { var ttr = row(typeTargets[tt]), ttc = col(typeTargets[tt]); for (var tdr = -1; tdr <= 1; tdr++) { for (var tdc = -1; tdc <= 1; tdc++) { var tnr = ttr + tdr, tnc = ttc + tdc; if (tnr >= 0 && tnr < ROWS && tnc >= 0 && tnc < COLS) { cleared[idx(tnr, tnc)] = true; } } } } cleared[a] = true; cleared[b] = true; bonusScore = 600; return { cleared: cleared, bonusScore: bonusScore, type: 'universalBomb+colorBomb' }; } // universalBomb + line → cross clear (full row + full column) if ((isUniversalBomb(specA) && isLine(specB)) || (isLine(specA) && isUniversalBomb(specB))) { var crossR = row(a), crossC = col(a); for (var lc = 0; lc < COLS; lc++) cleared[idx(crossR, lc)] = true; for (var lr = 0; lr < ROWS; lr++) cleared[idx(lr, crossC)] = true; bonusScore = 400; return { cleared: cleared, bonusScore: bonusScore, type: 'universalBomb+line' }; } // colorBomb + line → clear 3 rows + 3 columns centered on trigger if ((isColorBomb(specA) && isLine(specB)) || (isLine(specA) && isColorBomb(specB))) { var centerR = row(a), centerC = col(a); for (var blr = centerR - 1; blr <= centerR + 1; blr++) { if (blr >= 0 && blr < ROWS) { for (var blc = 0; blc < COLS; blc++) { cleared[idx(blr, blc)] = true; } } } for (var blc2 = centerC - 1; blc2 <= centerC + 1; blc2++) { if (blc2 >= 0 && blc2 < COLS) { for (var blr2 = 0; blr2 < ROWS; blr2++) { cleared[idx(blr2, blc2)] = true; } } } bonusScore = 500; return { cleared: cleared, bonusScore: bonusScore, type: 'colorBomb+line' }; } // line + line → CROSS BOMB: clear row AND column of BOTH tile positions if (isLine(specA) && isLine(specB)) { var crossR2a = row(a), crossC2a = col(a); var crossR2b = row(b), crossC2b = col(b); // Full row + col from position A for (var lc2 = 0; lc2 < COLS; lc2++) cleared[idx(crossR2a, lc2)] = true; for (var lr2 = 0; lr2 < ROWS; lr2++) cleared[idx(lr2, crossC2a)] = true; // Full row + col from position B for (var lc3 = 0; lc3 < COLS; lc3++) cleared[idx(crossR2b, lc3)] = true; for (var lr3 = 0; lr3 < ROWS; lr3++) cleared[idx(lr3, crossC2b)] = true; bonusScore = 600; return { cleared: cleared, bonusScore: bonusScore, type: 'crossBomb' }; } // pawBomb + pawBomb → combine tiers (min 3, capped at 5), activate mega paw if (isPawBomb(specA) && isPawBomb(specB)) { var combinedTier = Math.min(5, Math.max(3, (tileA.pawTier || 1) + (tileB.pawTier || 1))); var ppCenter = a; var ppr = row(ppCenter), ppc = col(ppCenter); var ppOffsets = getPawBombOffsets(combinedTier); for (var ppi = 0; ppi < ppOffsets.length; ppi++) { var ppnr = ppr + ppOffsets[ppi][0], ppnc = ppc + ppOffsets[ppi][1]; if (ppnr >= 0 && ppnr < ROWS && ppnc >= 0 && ppnc < COLS) { cleared[idx(ppnr, ppnc)] = true; } } bonusScore = 600 + combinedTier * 150; return { cleared: cleared, bonusScore: bonusScore, type: 'pawBomb+pawBomb' }; } // pawBomb + universalBomb → pawBomb activates at tier+1, then 3×3 at center if ((isPawBomb(specA) && isUniversalBomb(specB)) || (isUniversalBomb(specA) && isPawBomb(specB))) { var pbTile = isPawBomb(specA) ? tileA : tileB; var puTier = Math.min(5, (pbTile.pawTier || 1) + 1); var puCenter = a; var pur = row(puCenter), puc = col(puCenter); var puOffsets = getPawBombOffsets(puTier); for (var pui = 0; pui < puOffsets.length; pui++) { var punr = pur + puOffsets[pui][0], punc = puc + puOffsets[pui][1]; if (punr >= 0 && punr < ROWS && punc >= 0 && punc < COLS) { cleared[idx(punr, punc)] = true; } } // Also add 3×3 from universalBomb for (var ubdr = -1; ubdr <= 1; ubdr++) { for (var ubdc = -1; ubdc <= 1; ubdc++) { var ubnr = pur + ubdr, ubnc = puc + ubdc; if (ubnr >= 0 && ubnr < ROWS && ubnc >= 0 && ubnc < COLS) { cleared[idx(ubnr, ubnc)] = true; } } } bonusScore = 400 + puTier * 50; return { cleared: cleared, bonusScore: bonusScore, type: 'pawBomb+universalBomb' }; } // pawBomb + colorBomb → pawBomb at tier+2, plus 5×5 at center if ((isPawBomb(specA) && isColorBomb(specB)) || (isColorBomb(specA) && isPawBomb(specB))) { var pcbTile = isPawBomb(specA) ? tileA : tileB; var pcTier = Math.min(5, (pcbTile.pawTier || 1) + 2); var pcCenter = a; var pcr = row(pcCenter), pcc = col(pcCenter); var pcOffsets = getPawBombOffsets(pcTier); for (var pci = 0; pci < pcOffsets.length; pci++) { var pcnr = pcr + pcOffsets[pci][0], pcnc = pcc + pcOffsets[pci][1]; if (pcnr >= 0 && pcnr < ROWS && pcnc >= 0 && pcnc < COLS) { cleared[idx(pcnr, pcnc)] = true; } } // Also add 5×5 from colorBomb for (var cbdr2 = -2; cbdr2 <= 2; cbdr2++) { for (var cbdc2 = -2; cbdc2 <= 2; cbdc2++) { var cbnr2 = pcr + cbdr2, cbnc2 = pcc + cbdc2; if (cbnr2 >= 0 && cbnr2 < ROWS && cbnc2 >= 0 && cbnc2 < COLS) { cleared[idx(cbnr2, cbnc2)] = true; } } } bonusScore = 600 + pcTier * 50; return { cleared: cleared, bonusScore: bonusScore, type: 'pawBomb+colorBomb' }; } // pawBomb + line → paw blast + full row/col cross if ((isPawBomb(specA) && isLine(specB)) || (isLine(specA) && isPawBomb(specB))) { var plTile = isPawBomb(specA) ? tileA : tileB; var plTier = Math.min(5, (plTile.pawTier || 1) + 1); var plCenter = a; var plr = row(plCenter), plc = col(plCenter); var plOffsets = getPawBombOffsets(plTier); for (var pli = 0; pli < plOffsets.length; pli++) { var plnr = plr + plOffsets[pli][0], plnc = plc + plOffsets[pli][1]; if (plnr >= 0 && plnr < ROWS && plnc >= 0 && plnc < COLS) { cleared[idx(plnr, plnc)] = true; } } // Full row + column cross for (var plc2 = 0; plc2 < COLS; plc2++) cleared[idx(plr, plc2)] = true; for (var plr2 = 0; plr2 < ROWS; plr2++) cleared[idx(plr2, plc)] = true; bonusScore = 450; return { cleared: cleared, bonusScore: bonusScore, type: 'pawBomb+line' }; } return null; } // Helper: activate a single special's effect into a cleared map function activateSingleSpecial(board, ii, cleared) { var tile = board[ii]; if (!tile || !tile.special) return; if (tile.special === 'lineH') { var r = row(ii); for (var c = 0; c < COLS; c++) cleared[idx(r, c)] = true; } else if (tile.special === 'lineV') { var c2 = col(ii); for (var r2 = 0; r2 < ROWS; r2++) cleared[idx(r2, c2)] = true; } else if (tile.special === 'universalBomb') { var br = row(ii), bc = col(ii); for (var dr = -1; dr <= 1; dr++) { for (var dc = -1; dc <= 1; dc++) { var nr = br + dr, nc = bc + dc; if (nr >= 0 && nr < ROWS && nc >= 0 && nc < COLS) { cleared[idx(nr, nc)] = true; } } } } else if (tile.special === 'colorBomb') { var cbr = row(ii), cbc = col(ii); for (var cdr = -2; cdr <= 2; cdr++) { for (var cdc = -2; cdc <= 2; cdc++) { var cnr = cbr + cdr, cnc = cbc + cdc; if (cnr >= 0 && cnr < ROWS && cnc >= 0 && cnc < COLS) { cleared[idx(cnr, cnc)] = true; } } } } else if (tile.special === 'pawBomb') { var pbr = row(ii), pbc = col(ii); var tier = tile.pawTier || 1; var offsets = getPawBombOffsets(tier); for (var po = 0; po < offsets.length; po++) { var pnr = pbr + offsets[po][0], pnc = pbc + offsets[po][1]; if (pnr >= 0 && pnr < ROWS && pnc >= 0 && pnc < COLS) { cleared[idx(pnr, pnc)] = true; } } } } // No more activateRainbow — universal bombs participate in normal match detection as wildcards // --------------- Gravity & Refill --------------- function applyGravity(board) { var fell = false; var fallenTiles = []; // track {id, fromRow, fromCol, toRow, toCol} var droppedByColumn = []; for (var c = 0; c < COLS; c++) { var writeRow = ROWS - 1; var droppedCount = 0; for (var r = ROWS - 1; r >= 0; r--) { var current = board[idx(r, c)]; if (current != null) { if (r !== writeRow) { board[idx(writeRow, c)] = current; board[idx(r, c)] = null; stampTilePosition(board[idx(writeRow, c)], writeRow, c); fallenTiles.push({ id: board[idx(writeRow, c)].id, fromRow: r, fromCol: c, toRow: writeRow, toCol: c }); fell = true; droppedCount++; } else { stampTilePosition(current, r, c); } writeRow--; } } droppedByColumn[c] = droppedCount; for (var clearRow = writeRow; clearRow >= 0; clearRow--) { board[idx(clearRow, c)] = null; } } return { fell: fell, fallenTiles: fallenTiles, droppedByColumn: droppedByColumn }; } function refillBoard(api, board, counter, level) { var lvl = level || 1; var newTiles = []; // track {id, row, col} for newly spawned tiles for (var c = 0; c < COLS; c++) { // Count empty spaces at the top of this column (after gravity, all nulls are at top) var emptyCount = 0; for (var r = 0; r < ROWS; r++) { if (board[idx(r, c)] == null) { emptyCount++; } else { break; // Once we hit a non-null, all below are filled (gravity already ran) } } // Collect types that were just sitting below the gap — avoid spawning these var avoidTypes = {}; if (emptyCount < ROWS) { var belowTile = board[idx(emptyCount, c)]; if (belowTile) avoidTypes[belowTile.type] = true; } // Fill from top: row 0 to emptyCount-1 for (var r2 = 0; r2 < emptyCount; r2++) { var attempts = 0; var type; do { type = biasedType(api, board, r2, c, lvl); attempts++; } while (attempts < 20 && (wouldMatchAtFull(board, r2, c, type) || (attempts < 12 && avoidTypes[type]))); board[idx(r2, c)] = makeTile(api, type, counter, lvl, r2, c); // Track this new type so the next tile in this column also avoids it avoidTypes[type] = true; newTiles.push({ id: counter, row: r2, col: c, spawnRow: -(emptyCount - r2) }); counter++; } } return { counter: counter, newTiles: newTiles }; } function boardHasEmptyCells(board) { for (var i = 0; i < board.length; i++) { if (board[i] == null) return true; } return false; } function boardHasFloatingTiles(board) { for (var c = 0; c < COLS; c++) { var sawEmptyBelow = false; for (var r = ROWS - 1; r >= 0; r--) { var tile = board[idx(r, c)]; if (tile == null) { sawEmptyBelow = true; } else if (sawEmptyBelow) { return true; } } } return false; } function boardNeedsSettle(board) { return boardHasEmptyCells(board) || boardHasFloatingTiles(board); } function repairBoardSnapshot(api, board, counter, level) { var lvl = level || 1; var nextCounter = counter || 1; var src = Array.isArray(board) ? board : []; var repaired = []; var seenIds = {}; for (var i = 0; i < ROWS * COLS; i++) { var cell = src[i]; if (!cell || !isKnownType(cell.type)) { repaired[i] = null; continue; } var tileId = cell.id; if (tileId === undefined || tileId === null || seenIds[tileId]) { tileId = nextCounter; nextCounter++; } seenIds[tileId] = true; var repairedTile = { type: cell.type, special: cell.special || null, id: tileId, explosive: !!cell.explosive, }; if (cell.golden === true) repairedTile.golden = true; if (cell.bomb === true) repairedTile.bomb = true; if (cell.pawTier !== undefined && cell.pawTier !== null) repairedTile.pawTier = cell.pawTier; repaired[i] = stampTilePosition(repairedTile, row(i), col(i)); } var settlePass = 0; while (settlePass < ROWS * 2 && boardNeedsSettle(repaired)) { applyGravity(repaired); var refillResult = refillBoard(api, repaired, nextCounter, lvl); nextCounter = refillResult.counter; syncBoardCoordinates(repaired); settlePass++; } syncBoardCoordinates(repaired); var shufflePass = 0; while (shufflePass < 8 && (Object.keys(findMatches(repaired).matched).length > 0 || !hasValidMoves(repaired))) { reshuffleBoard(api, repaired, lvl); syncBoardCoordinates(repaired); shufflePass++; } var analysis = analyzeBoard(repaired); if (analysis.broken || Object.keys(findMatches(repaired).matched).length > 0 || !hasValidMoves(repaired)) { var fresh = generateBoard(api, nextCounter, lvl); repaired = fresh.board; nextCounter = fresh.counter; syncBoardCoordinates(repaired); } return { board: repaired, counter: nextCounter }; } function recoverBoard(api, s) { var repaired = repairBoardSnapshot(api, s.board, s.tileIdCounter || 1, s.level || 1); api.patchState({ board: repaired.board, tileIdCounter: repaired.counter, selected: null, animating: false, combo: 0, streakCount: 0, cascadeStep: 0, cascadeMultiplier: 1, lastClearedIndices: [], lastClearedTiles: [], lastClearedTiles: [], lastInvalidSwap: null, lastFallenTiles: [], lastNewTiles: [], lastExplosiveTiles: [], lastUniversalBombTiles: [], lastColorBombTiles: [], lastPawBombTiles: [], lastMatchFeedback: null, bonusCascadeTriggered: false, reshuffled: false, resolveStartedAt: 0, resolvePhaseCount: 0, }); } function advanceResolveGuard(api, s) { var now = api.getWallClockTimestamp(); var startedAt = s.resolveStartedAt || now; var phaseCount = (s.resolvePhaseCount || 0) + 1; var analysis = analyzeBoard(cloneBoard(s.board)); if (analysis.fatal || (s.cascadeStep || 0) > MAX_CASCADE_DEPTH || phaseCount > MAX_RESOLVE_PHASES || (now - startedAt) > MAX_RESOLVE_MS) { recoverBoard(api, s); return false; } api.patchState({ resolveStartedAt: startedAt, resolvePhaseCount: phaseCount }); return true; } function wouldMatchAtFull(board, r, c, type) { // Check horizontal if (c >= 2) { var left1 = board[idx(r, c - 1)]; var left2 = board[idx(r, c - 2)]; if (left1 && left2 && left1.type === type && left2.type === type) return true; } // Check vertical if (r >= 2) { var up1 = board[idx(r - 1, c)]; var up2 = board[idx(r - 2, c)]; if (up1 && up2 && up1.type === type && up2.type === type) return true; } // Also check right and down for refills filling in between existing tiles if (c <= COLS - 3) { var right1 = board[idx(r, c + 1)]; var right2 = board[idx(r, c + 2)]; if (right1 && right2 && right1.type === type && right2.type === type) return true; } if (r <= ROWS - 3) { var down1 = board[idx(r + 1, c)]; var down2 = board[idx(r + 2, c)]; if (down1 && down2 && down1.type === type && down2.type === type) return true; } // Middle of horizontal if (c >= 1 && c <= COLS - 2) { var lft = board[idx(r, c - 1)]; var rgt = board[idx(r, c + 1)]; if (lft && rgt && lft.type === type && rgt.type === type) return true; } // Middle of vertical if (r >= 1 && r <= ROWS - 2) { var up = board[idx(r - 1, c)]; var dn = board[idx(r + 1, c)]; if (up && dn && up.type === type && dn.type === type) return true; } return false; } // --------------- Dead Board Detection --------------- function hasValidMoves(board) { for (var i = 0; i < board.length; i++) { if (!board[i]) continue; var r = row(i), c = col(i); // Try swap right if (c < COLS - 1) { var j = idx(r, c + 1); if (board[j]) { // Two specials can always be swapped if (board[i].special && board[j].special) return true; swapInPlace(board, i, j); var m = findMatches(board); swapInPlace(board, i, j); if (Object.keys(m.matched).length > 0) return true; } } // Try swap down if (r < ROWS - 1) { var j2 = idx(r + 1, c); if (board[j2]) { if (board[i].special && board[j2].special) return true; swapInPlace(board, i, j2); var m2 = findMatches(board); swapInPlace(board, i, j2); if (Object.keys(m2.matched).length > 0) return true; } } } return false; } function swapInPlace(board, a, b) { var tmp = board[a]; board[a] = board[b]; board[b] = tmp; if (board[a]) stampTilePosition(board[a], row(a), col(a)); if (board[b]) stampTilePosition(board[b], row(b), col(b)); } function reshuffleBoard(api, board, level) { // Collect indices of normal (non-special) tiles var normalIndices = []; for (var i = 0; i < board.length; i++) { if (board[i] && !board[i].special) normalIndices.push(i); } // Fisher-Yates shuffle only the normal tiles (specials stay in place) var normalTiles = []; for (var ni = 0; ni < normalIndices.length; ni++) { normalTiles.push(board[normalIndices[ni]]); } for (var fi = normalTiles.length - 1; fi > 0; fi--) { var fj = (api.random() * (fi + 1)) | 0; var tmp = normalTiles[fi]; normalTiles[fi] = normalTiles[fj]; normalTiles[fj] = tmp; } for (var pi = 0; pi < normalIndices.length; pi++) { board[normalIndices[pi]] = normalTiles[pi]; } // If still no valid moves or has auto-matches, regenerate normal tile types var tries = 0; while (tries < 10 && (!hasValidMoves(board) || Object.keys(findMatches(board).matched).length > 0)) { for (var k = 0; k < board.length; k++) { if (board[k] && !board[k].special) { board[k].type = randType(api, level); } } tries++; } return syncBoardCoordinates(board); } // --------------- Scoring Helpers --------------- function calcTargetScore(level) { // Gentle ramp: early easy, mid requires specials, late requires cascade planning if (level <= 3) return 300 + (level * 150); // 450, 600, 750 if (level <= 7) return 750 + ((level - 3) * 250); // 1000, 1250, 1500, 1750 if (level <= 15) return 1750 + ((level - 7) * 350); // 2100..4550 return 4550 + ((level - 15) * 500); // steep climb } function calcMoves(level) { // Generous early (30-35), tapering gradually (min ~18-20) if (level <= 3) return 35; if (level <= 7) return 32; if (level <= 12) return 28; if (level <= 20) return 24; return Math.max(18, 24 - ((level - 20) | 0)); } // --------------- Swap Validation --------------- function wouldSwapMatch(board, a, b) { // Check if swapping a and b creates any match swapInPlace(board, a, b); var result = findMatches(board); swapInPlace(board, a, b); return Object.keys(result.matched).length > 0; } // ============================================================ // BEHAVIOR HOOKS // ============================================================ export function onSpawn(api) { var s = api.getState(); var needBoard = !s.board || s.board.length !== ROWS * COLS; var counter = s.tileIdCounter ?? 1; var boardData; var spawnLevel = s.level ?? 1; var board = null; if (needBoard) { boardData = generateBoard(api, counter, spawnLevel); board = boardData.board; counter = boardData.counter; } else { board = cloneBoard(s.board); } var repairedBoard = repairBoardSnapshot(api, board, counter, spawnLevel); counter = repairedBoard.counter; api.patchState({ screen: s.screen ?? 'title', board: repairedBoard.board, rows: ROWS, cols: COLS, selected: s.selected ?? null, score: s.score ?? 0, level: s.level ?? 1, movesLeft: s.movesLeft ?? calcMoves(1), targetScore: s.targetScore ?? calcTargetScore(1), combo: s.combo ?? 0, bestCombo: s.bestCombo ?? 0, topMultiplier: s.topMultiplier ?? 1, longestStreak: s.longestStreak ?? 0, allTimeBest: s.allTimeBest ?? 0, mode: s.mode ?? 'classic', animating: s.animating ?? false, lastClearedIndices: s.lastClearedIndices ?? [], lastClearedTiles: s.lastClearedTiles ?? [], lastInvalidSwap: s.lastInvalidSwap ?? null, reshuffled: s.reshuffled ?? false, streakCount: s.streakCount ?? 0, tileIdCounter: counter, musicVolume: s.musicVolume ?? 0.5, sfxVolume: s.sfxVolume ?? 0.5, leaderboard: s.leaderboard ?? [], // Combo meter system comboMeter: s.comboMeter ?? 0, comboTier: s.comboTier ?? 0, comboTierChanged: s.comboTierChanged ?? false, comboMeterPeak: s.comboMeterPeak ?? 0, lastMatchFeedback: s.lastMatchFeedback ?? null, // Cascade step system cascadeStep: s.cascadeStep ?? 0, cascadeMultiplier: s.cascadeMultiplier ?? 1, bestCascade: s.bestCascade ?? 0, // Music shuffle system musicTrackIndex: s.musicTrackIndex ?? -1, musicShuffleTimer: s.musicShuffleTimer ?? 0, // Auto-advance timer autoAdvanceTimer: s.autoAdvanceTimer ?? 0, autoAdvanceCountdown: s.autoAdvanceCountdown ?? 0, // Bonus cascade system bonusCascadeTriggered: s.bonusCascadeTriggered ?? false, // Gravity animation data lastFallenTiles: s.lastFallenTiles ?? [], lastNewTiles: s.lastNewTiles ?? [], lastExplosiveTiles: s.lastExplosiveTiles ?? [], lastUniversalBombTiles: s.lastUniversalBombTiles ?? [], lastColorBombTiles: s.lastColorBombTiles ?? [], lastPawBombTiles: s.lastPawBombTiles ?? [], resolveStartedAt: s.resolveStartedAt ?? 0, resolvePhaseCount: s.resolvePhaseCount ?? 0, }); // Start title music api.musicShift('cdn/music-instrumental-cozy-cafe-lofi-chill.mp3', { volume: 0.25 }); } // --------------- Combo Meter Decay --------------- export function update(dt, api) { var s = api.getState(); // --- Music shuffle timer (while playing / levelComplete) --- if (s.screen === 'playing' || s.screen === 'levelComplete') { var shuffleTimer = s.musicShuffleTimer || 0; shuffleTimer -= dt; if (shuffleTimer <= 0) { // Pick a different track var currentIdx = s.musicTrackIndex ?? -1; var newIdx; var attempts = 0; do { newIdx = (api.random() * ARCADE_TRACKS.length) | 0; attempts++; } while (newIdx === currentIdx && attempts < 10); var musicVol = s.musicVolume ?? 0.5; api.musicShift(ARCADE_TRACKS[newIdx], { volume: musicVol * 0.6, fade: 2 }); api.patchState({ musicTrackIndex: newIdx, musicShuffleTimer: MUSIC_SHUFFLE_INTERVAL }); } else { api.patchState({ musicShuffleTimer: shuffleTimer }); } } // --- Auto-advance on level complete --- if (s.screen === 'levelComplete') { var timer = s.autoAdvanceTimer || 0; if (timer > 0) { timer -= dt; if (timer <= 0) { timer = 0; // Auto-advance to next level api.patchState({ autoAdvanceTimer: 0, autoAdvanceCountdown: 0 }); var freshState = api.getState(); if (freshState.screen === 'levelComplete') { handleNextLevel(api, freshState); } return; } api.patchState({ autoAdvanceTimer: timer, autoAdvanceCountdown: Math.ceil(timer) }); } return; } // --- Combo meter decay (while playing) --- if (s.screen !== 'playing') return; if (s.comboMeter <= 0) return; var newMeter = s.comboMeter - 2 * dt; if (newMeter < 0) newMeter = 0; var oldTier = s.comboTier || 0; var newTier = getTierFromMeter(newMeter); var patch = { comboMeter: newMeter }; if (newTier !== oldTier) { patch.comboTier = newTier; } api.patchState(patch); } export function onInput(input, api) { var s = api.getState(); // --------------- setVolume --------------- if (input.actions.setVolume && input.actionData && input.actionData.setVolume) { var vd = input.actionData.setVolume; if (vd.type === 'music') { api.patchState({ musicVolume: vd.value }); } else if (vd.type === 'sfx') { api.patchState({ sfxVolume: vd.value }); } return; } // Lock board input for the full resolution sequence. if (s.animating) return; // --------------- selectTile --------------- if (input.actions.selectTile && input.actionData && input.actionData.selectTile) { handleSelectTile(api, s, input.actionData.selectTile); return; } // --------------- startGame --------------- if (input.actions.startGame && input.actionData && input.actionData.startGame) { handleStartGame(api, s, input.actionData.startGame); return; } // --------------- goToScreen --------------- if (input.actions.goToScreen && input.actionData && input.actionData.goToScreen) { var scr = input.actionData.goToScreen.screen; api.patchState({ screen: scr, autoAdvanceTimer: 0, autoAdvanceCountdown: 0 }); if (scr === 'title') { api.musicShift('cdn/music-instrumental-cozy-cafe-lofi-chill.mp3', { volume: 0.25, fade: 1 }); api.patchState({ musicTrackIndex: -1, musicShuffleTimer: 0 }); } return; } // --------------- restartLevel --------------- if (input.actions.restartLevel) { handleRestartLevel(api, s); return; } // --------------- nextLevel --------------- if (input.actions.nextLevel) { handleNextLevel(api, s); return; } } // --------------- Action Handlers --------------- function handleStartGame(api, s, data) { var level = 1; var counter = s.tileIdCounter || 1; var boardData = generateBoard(api, counter, level); api.patchState({ screen: 'playing', board: boardData.board, tileIdCounter: boardData.counter, selected: null, score: 0, level: level, movesLeft: calcMoves(level), targetScore: calcTargetScore(level), combo: 0, bestCombo: 0, topMultiplier: 1, longestStreak: 0, streakCount: 0, animating: false, lastClearedIndices: [], lastClearedTiles: [], lastExplosiveTiles: [], lastUniversalBombTiles: [], lastColorBombTiles: [], lastPawBombTiles: [], lastFallenTiles: [], lastNewTiles: [], lastInvalidSwap: null, reshuffled: false, mode: data.mode || 'classic', comboMeter: 0, comboTier: 0, comboTierChanged: false, comboMeterPeak: 0, lastMatchFeedback: null, bonusCascadeTriggered: false, cascadeStep: 0, cascadeMultiplier: 1, bestCascade: 0, }); // Pick a random arcade track var trackIdx = (api.random() * ARCADE_TRACKS.length) | 0; var musicVol = s.musicVolume ?? 0.5; api.musicShift(ARCADE_TRACKS[trackIdx], { volume: musicVol * 0.6, fade: 1 }); api.patchState({ musicTrackIndex: trackIdx, musicShuffleTimer: MUSIC_SHUFFLE_INTERVAL }); } function handleRestartLevel(api, s) { var level = s.level || 1; var counter = s.tileIdCounter || 1; var boardData = generateBoard(api, counter, level); api.patchState({ screen: 'playing', board: boardData.board, tileIdCounter: boardData.counter, selected: null, score: 0, movesLeft: calcMoves(level), targetScore: calcTargetScore(level), combo: 0, streakCount: 0, animating: false, lastClearedIndices: [], lastClearedTiles: [], lastExplosiveTiles: [], lastUniversalBombTiles: [], lastColorBombTiles: [], lastPawBombTiles: [], lastFallenTiles: [], lastNewTiles: [], lastInvalidSwap: null, reshuffled: false, comboMeter: 0, comboTier: 0, comboTierChanged: false, comboMeterPeak: 0, lastMatchFeedback: null, bonusCascadeTriggered: false, cascadeStep: 0, cascadeMultiplier: 1, }); // Pick a random arcade track (or keep current if already playing) var trackIdx = s.musicTrackIndex; if (trackIdx === undefined || trackIdx < 0) { trackIdx = (api.random() * ARCADE_TRACKS.length) | 0; } var musicVol = s.musicVolume ?? 0.5; api.musicShift(ARCADE_TRACKS[trackIdx], { volume: musicVol * 0.6, fade: 1 }); api.patchState({ musicTrackIndex: trackIdx, musicShuffleTimer: MUSIC_SHUFFLE_INTERVAL }); } function handleNextLevel(api, s) { // Guard: only advance from levelComplete screen (prevents double-fire) if (s.screen !== 'levelComplete') return; var level = (s.level || 1) + 1; // BOARD PERSISTENCE: keep existing board and specials, only reset score/moves/target api.patchState({ screen: 'playing', selected: null, score: 0, level: level, movesLeft: calcMoves(level), targetScore: calcTargetScore(level), combo: 0, streakCount: 0, animating: false, lastClearedIndices: [], lastClearedTiles: [], lastExplosiveTiles: [], lastUniversalBombTiles: [], lastColorBombTiles: [], lastPawBombTiles: [], lastFallenTiles: [], lastNewTiles: [], lastInvalidSwap: null, reshuffled: false, comboMeter: 0, comboTier: 0, comboTierChanged: false, comboMeterPeak: 0, lastMatchFeedback: null, bonusCascadeTriggered: false, autoAdvanceTimer: 0, autoAdvanceCountdown: 0, cascadeStep: 0, cascadeMultiplier: 1, }); } function handleSelectTile(api, s, data) { if (s.screen !== 'playing' || s.animating) return; var index = data.index; if (index < 0 || index >= ROWS * COLS) return; if (!s.board || !s.board[index]) return; var sfxVol = s.sfxVolume || 0.5; // First selection if (s.selected === null || s.selected === undefined) { api.patchState({ selected: index }); api.playSound('cdn/sfx-ui-click-soft-pop.mp3', { volume: sfxVol * 0.6 }); return; } // Same tile — deselect if (s.selected === index) { api.patchState({ selected: null }); return; } // Not adjacent — reselect if (!isAdjacent(s.selected, index)) { api.patchState({ selected: index }); api.playSound('cdn/sfx-ui-click-soft-pop.mp3', { volume: sfxVol * 0.6 }); return; } // Adjacent — attempt swap var board = cloneBoard(s.board); var a = s.selected; var b = index; // Check for universalBomb swap — validate it creates a match first var hasUniversalBomb = (board[a].special === 'universalBomb' || board[b].special === 'universalBomb'); // Check for special + special swap (always valid) var bothSpecial = isSpecial(board[a]) && isSpecial(board[b]); // For universalBomb + normal tile: must still create a valid match // (universalBomb acts as wildcard in findMatches, so this usually succeeds) if (!bothSpecial && !wouldSwapMatch(board, a, b)) { // Invalid swap — still costs a move var failedMoves = (s.movesLeft || 1) - 1; api.patchState({ selected: null, lastInvalidSwap: { a: a, b: b }, movesLeft: failedMoves }); api.playSound('cdn/sfx-ui-error-buzz-soft.mp3', { volume: sfxVol * 0.5 }); api.runInSeconds(0.35, function() { api.patchState({ lastInvalidSwap: null }); }); // Check if out of moves after failed swap if (failedMoves <= 0) { var failScore = s.score || 0; var failLevel = s.level || 1; var failAllTimeBest = s.allTimeBest || 0; if (failScore > failAllTimeBest) failAllTimeBest = failScore; var failLeaderboard = s.leaderboard ? s.leaderboard.slice() : []; failLeaderboard.push({ level: failLevel, score: failScore }); failLeaderboard.sort(function(x, y) { return y.score - x.score; }); if (failLeaderboard.length > 10) failLeaderboard = failLeaderboard.slice(0, 10); api.patchState({ animating: false, lastClearedIndices: [], lastClearedTiles: [], screen: 'gameOver', allTimeBest: failAllTimeBest, leaderboard: failLeaderboard, }); api.playSound('cdn/sfx-game-over-sad-trombone.mp3', { volume: sfxVol * 0.8 }); } return; } // Valid swap — execute api.playSound('cdn/sfx-puzzle-tile-swap-whoosh.mp3', { volume: sfxVol * 0.6 }); // Do the swap swapInPlace(board, a, b); var movesLeft = (s.movesLeft || 1) - 1; api.patchState({ board: board, selected: null, movesLeft: movesLeft, animating: true, combo: 0, streakCount: 0, bonusCascadeTriggered: false, cascadeStep: 0, cascadeMultiplier: 1, resolveStartedAt: api.getWallClockTimestamp(), resolvePhaseCount: 0, }); // Start cascade after brief pause api.runInSeconds(0.05, function() { startCascade(api, a, b, hasUniversalBomb, bothSpecial); }); } // --------------- Cascade System --------------- function startCascade(api, swapA, swapB, wasUniversalBomb, wasBothSpecial) { var s = api.getState(); if (!advanceResolveGuard(api, s)) return; s = api.getState(); var board = cloneBoard(s.board); var counter = s.tileIdCounter || 1; var score = s.score || 0; var combo = s.combo || 0; var bestCombo = s.bestCombo || 0; var topMultiplier = s.topMultiplier || 1; var longestStreak = s.longestStreak || 0; var streakCount = s.streakCount || 0; var sfxVol = s.sfxVolume || 0.5; var comboMeter = s.comboMeter || 0; var comboTier = s.comboTier || 0; var comboMeterPeak = s.comboMeterPeak || 0; var cascadeLevel = s.level || 1; var cascadeStep = 1; // First step of a new player move var cascadeMult = getCascadeMultiplier(cascadeStep); var bestCascade = s.bestCascade || 0; // Handle special + special swap first if (wasBothSpecial) { var specialResult = handleSpecialSwap(board, swapA, swapB, api, sfxVol); if (specialResult) { var expanded = expandClearMap(board, specialResult.cleared); var sKeys = Object.keys(expanded.cleared); var clearedIndices = []; for (var si = 0; si < sKeys.length; si++) { clearedIndices.push(parseInt(sKeys[si])); } var clearedTiles = snapshotClearedTiles(board, clearedIndices); var ubTiles = collectActivatedSpecialTiles(expanded.activated, 'universalBomb'); var cbTiles = collectActivatedSpecialTiles(expanded.activated, 'colorBomb'); var pbTiles = collectActivatedSpecialTiles(expanded.activated, 'pawBomb'); var explosiveTiles = expanded.explosiveTiles; // Score per cleared tile + bonus, apply cascade multiplier var stepPoints = clearedIndices.length * 10 + specialResult.bonusScore; for (var ai = 0; ai < expanded.activated.length; ai++) { var act = expanded.activated[ai]; if (act.special === 'universalBomb') stepPoints += 150; else if (act.special === 'colorBomb') stepPoints += 300; else if (act.special === 'lineH' || act.special === 'lineV') stepPoints += 150; else if (act.special === 'pawBomb') stepPoints += 200; } if (explosiveTiles.length > 0) { stepPoints += explosiveTiles.length * 150; } stepPoints = Math.round(stepPoints * cascadeMult); score += stepPoints; // Feed combo meter combo = 1; comboMeter += comboMeterFeed(combo, cascadeLevel); if (comboMeter > 100) comboMeter = 100; if (comboMeter > comboMeterPeak) comboMeterPeak = comboMeter; var newTier = getTierFromMeter(comboMeter); var tierChanged = newTier !== comboTier; if (tierChanged && newTier > comboTier && TIER_SOUNDS[newTier]) { api.playSound(TIER_SOUNDS[newTier], { volume: sfxVol * 0.8 }); } // Clear tiles for (var ci2 = 0; ci2 < clearedIndices.length; ci2++) { board[clearedIndices[ci2]] = null; } // Sound for the combo type if (specialResult.type === 'universalBomb+universalBomb') { api.playSound('cdn/sfx-magic-sparkle-cascade.mp3', { volume: sfxVol * 1.0 }); } else if (specialResult.type === 'colorBomb+colorBomb') { api.playSound('cdn/sfx-explosion-cartoon-boom.mp3', { volume: sfxVol * 0.9 }); } else if (specialResult.type === 'pawBomb+pawBomb') { api.playSound('cdn/sfx-explosion-cartoon-boom.mp3', { volume: sfxVol * 1.0 }); api.playSound('cdn/sfx-magic-sparkle-cascade.mp3', { volume: sfxVol * 0.7 }); } else if (specialResult.type === 'crossBomb') { api.playSound('cdn/sfx-laser-sweep-whoosh.mp3', { volume: sfxVol * 1.0 }); } else { api.playSound('cdn/sfx-laser-sweep-whoosh.mp3', { volume: sfxVol * 0.8 }); } if (explosiveTiles.length > 0) { api.playSound('cdn/sfx-explosion-cartoon-boom.mp3', { volume: sfxVol * 0.9 }); } streakCount++; if (cascadeStep > bestCascade) bestCascade = cascadeStep; // Match feedback var feedback = getMatchFeedback(stepPoints, cascadeStep); api.patchState({ board: board, score: score, combo: combo, streakCount: streakCount, lastClearedIndices: clearedIndices, lastClearedTiles: clearedTiles, lastExplosiveTiles: explosiveTiles, lastUniversalBombTiles: ubTiles, lastColorBombTiles: cbTiles, lastPawBombTiles: pbTiles, comboMeter: comboMeter, comboTier: newTier, comboTierChanged: tierChanged, comboMeterPeak: comboMeterPeak, lastMatchFeedback: feedback, cascadeStep: cascadeStep, cascadeMultiplier: cascadeMult, bestCascade: bestCascade, }); if (tierChanged) { api.runInSeconds(0.5, function() { api.patchState({ comboTierChanged: false }); }); } api.runInSeconds(1.0, function() { api.patchState({ lastMatchFeedback: null }); }); // Gravity first, then top spawn, then rescan. api.runInSeconds(0.3, function() { doCascadeGravity(api); }); return; } } // Normal match detection (universalBomb participates as wildcard through findMatches) resolveCascadeStep(api, swapA, swapB); } function resolveCascadeStep(api, swapA, swapB) { var s = api.getState(); if (!advanceResolveGuard(api, s)) return; s = api.getState(); var board = cloneBoard(s.board); var counter = s.tileIdCounter || 1; var score = s.score || 0; var combo = (s.combo || 0) + 1; var bestCombo = s.bestCombo || 0; var topMultiplier = s.topMultiplier || 1; var longestStreak = s.longestStreak || 0; var streakCount = (s.streakCount || 0) + 1; var sfxVol = s.sfxVolume || 0.5; var comboMeter = s.comboMeter || 0; var comboTier = s.comboTier || 0; var comboMeterPeak = s.comboMeterPeak || 0; var resolveLevel = s.level || 1; var cascadeStep = (s.cascadeStep || 0) + 1; var cascadeMult = getCascadeMultiplier(cascadeStep); var bestCascade = s.bestCascade || 0; var result = findMatches(board); var matchedKeys = Object.keys(result.matched); if (matchedKeys.length === 0) { // No more matches — cascade done finishCascade(api); return; } // Determine special tiles to create (pass random ref for universalBomb chance) var specials = determineSpecials(result.matchGroups, swapA, function() { return api.random(); }, cascadeStep); // Expand clears recursively so specials/explosives always feed the same gravity loop. var expanded = expandClearMap(board, result.matched); result.matched = expanded.cleared; var activated = expanded.activated; var explosiveTiles = expanded.explosiveTiles; // Play sounds if (cascadeStep === 1) { api.playSound('cdn/sfx-puzzle-match-chime-sparkle.mp3', { volume: sfxVol * 0.7 }); } else { // Rising pitch for cascades var pitch = 1.0 + (cascadeStep - 1) * 0.15; if (pitch > 2.0) pitch = 2.0; api.playSound('cdn/sfx-puzzle-combo-rising-chime.mp3', { volume: sfxVol * 0.8, pitch: pitch }); } // --- New scoring: base points per match group by length --- var stepPoints = 0; for (var mg = 0; mg < result.matchGroups.length; mg++) { var grp = result.matchGroups[mg]; stepPoints += getMatchBasePoints(grp.indices.length); } // Bonus for activated specials for (var ai = 0; ai < activated.length; ai++) { var act = activated[ai]; if (act.special === 'universalBomb') { api.playSound('cdn/sfx-explosion-cartoon-boom.mp3', { volume: sfxVol * 0.7 }); stepPoints += 150; // moderate bonus } else if (act.special === 'colorBomb') { api.playSound('cdn/sfx-explosion-cartoon-boom.mp3', { volume: sfxVol * 0.9 }); stepPoints += 300; // big bonus } else if (act.special === 'lineH' || act.special === 'lineV') { api.playSound('cdn/sfx-laser-sweep-whoosh.mp3', { volume: sfxVol * 0.7 }); stepPoints += 150; } else if (act.special === 'pawBomb') { api.playSound('cdn/sfx-explosion-cartoon-boom.mp3', { volume: sfxVol * 0.9 }); var pawTier = board[act.index] ? (board[act.index].pawTier || 1) : 1; stepPoints += 200 + pawTier * 100; } } // Bonus for explosive tiles if (explosiveTiles.length > 0) { api.playSound('cdn/sfx-explosion-cartoon-boom.mp3', { volume: sfxVol * 0.9 }); stepPoints += explosiveTiles.length * 150; } // Apply cascade multiplier to ALL points in this step stepPoints = Math.round(stepPoints * cascadeMult); score += stepPoints; // Special-creating matches keep one existing tile on the board and transform it. // That survivor can still fall with gravity afterward, instead of a brand-new tile // appearing in-place mid-column before the refill step. var specialSurvivors = {}; for (var ss = 0; ss < specials.length; ss++) { var survivorIndex = specials[ss].index; if (board[survivorIndex]) { specialSurvivors[survivorIndex] = specials[ss].special; } } // Collect all cleared indices, excluding the special survivor slots. var allCleared = Object.keys(result.matched); var clearedIndices = []; for (var ci = 0; ci < allCleared.length; ci++) { var clearedIdx = parseInt(allCleared[ci]); if (specialSurvivors[clearedIdx]) continue; clearedIndices.push(clearedIdx); } var clearedTiles = snapshotClearedTiles(board, clearedIndices); // Clear matched tiles. for (var mi = 0; mi < clearedIndices.length; mi++) { board[clearedIndices[mi]] = null; } // Transform the surviving matched tile into the earned special. for (var si = 0; si < specials.length; si++) { var sp = specials[si]; var survivor = board[sp.index]; if (!survivor) continue; // Find the type for this special from the group it belongs to. var spType = survivor.type || (result.matchGroups.length > 0 ? result.matchGroups[0].type : 'paw'); for (var sg = 0; sg < result.matchGroups.length; sg++) { var foundGroupType = false; for (var sgi = 0; sgi < result.matchGroups[sg].indices.length; sgi++) { if (result.matchGroups[sg].indices[sgi] === sp.index) { spType = result.matchGroups[sg].type; foundGroupType = true; break; } } if (foundGroupType) break; } survivor.type = spType; survivor.special = sp.special; survivor.explosive = false; // specials are never explosive // For pawBomb, store the tier if (sp.special === 'pawBomb') { survivor.pawTier = sp.pawTier || 1; } else { survivor.pawTier = undefined; } // For universalBomb, clear the type — it's typeless/neutral if (sp.special === 'universalBomb') { survivor.type = spType; // keep a type for internal use but UI will show neutral } score += 50; // special creation bonus api.playSound('cdn/sfx-reward-powerup-bright.mp3', { volume: sfxVol * 0.6 }); } // Track which cleared tiles were bombs for UI animation var ubTiles = collectActivatedSpecialTiles(activated, 'universalBomb'); var cbTiles = collectActivatedSpecialTiles(activated, 'colorBomb'); var pbTiles2 = collectActivatedSpecialTiles(activated, 'pawBomb'); // Feed combo meter: level-scaled per cascade step comboMeter += comboMeterFeed(combo, resolveLevel); if (comboMeter > 100) comboMeter = 100; if (comboMeter > comboMeterPeak) comboMeterPeak = comboMeter; var oldTier = comboTier; var newTier = getTierFromMeter(comboMeter); var tierChanged = newTier !== oldTier; // Play tier-up sound if (tierChanged && newTier > oldTier && TIER_SOUNDS[newTier]) { api.playSound(TIER_SOUNDS[newTier], { volume: sfxVol * 0.8 }); } // Update best combo and multiplier tracking if (combo > bestCombo) bestCombo = combo; if (combo > topMultiplier) topMultiplier = combo; if (streakCount > longestStreak) longestStreak = streakCount; if (cascadeStep > bestCascade) bestCascade = cascadeStep; // Match feedback var feedback = getMatchFeedback(stepPoints, cascadeStep); api.patchState({ board: board, tileIdCounter: counter, score: score, combo: combo, bestCombo: bestCombo, topMultiplier: topMultiplier, longestStreak: longestStreak, streakCount: streakCount, lastClearedIndices: clearedIndices, lastClearedTiles: clearedTiles, lastExplosiveTiles: explosiveTiles, lastUniversalBombTiles: ubTiles, lastColorBombTiles: cbTiles, lastPawBombTiles: pbTiles2, comboMeter: comboMeter, comboTier: newTier, comboTierChanged: tierChanged, comboMeterPeak: comboMeterPeak, lastMatchFeedback: feedback, cascadeStep: cascadeStep, cascadeMultiplier: cascadeMult, bestCascade: bestCascade, }); // Clear tier changed flag after a brief moment if (tierChanged) { api.runInSeconds(0.5, function() { api.patchState({ comboTierChanged: false }); }); } // Clear feedback after 1 second api.runInSeconds(1.0, function() { api.patchState({ lastMatchFeedback: null }); }); // After clear visual pause, apply gravity api.runInSeconds(0.3, function() { doCascadeGravity(api); }); } function doCascadeGravity(api) { var s = api.getState(); if (!advanceResolveGuard(api, s)) return; s = api.getState(); var board = cloneBoard(s.board); var gravityResult = applyGravity(board); for (var c = 0; c < COLS; c++) { var droppedCount = 0; if (gravityResult.droppedByColumn && gravityResult.droppedByColumn[c]) { droppedCount = gravityResult.droppedByColumn[c]; } api.log('GRAVITY: column ' + c + ' dropped ' + droppedCount + ' tiles'); } api.patchState({ board: board, lastClearedIndices: [], lastClearedTiles: [], lastExplosiveTiles: [], lastUniversalBombTiles: [], lastColorBombTiles: [], lastPawBombTiles: [], lastFallenTiles: gravityResult.fallenTiles, lastNewTiles: [], }); // Hand off directly into top-row refill so the cascade can't stall between timers. doCascadeSpawn(api); } function doCascadeSpawn(api) { var s = api.getState(); if (!advanceResolveGuard(api, s)) return; s = api.getState(); var board = cloneBoard(s.board); var counter = s.tileIdCounter || 1; var level = s.level || 1; var refillResult = refillBoard(api, board, counter, level); counter = refillResult.counter; api.patchState({ board: board, tileIdCounter: counter, lastNewTiles: refillResult.newTiles, }); if (boardNeedsSettle(board)) { doCascadeGravity(api); return; } // After top-row spawn settles, scan again for the next cascade step. api.runInSeconds(0.15, function() { resolveCascadeStep(api, null, null); }); } function finishCascade(api) { var s = api.getState(); if (!advanceResolveGuard(api, s)) return; s = api.getState(); var board = cloneBoard(s.board); var score = s.score || 0; var level = s.level || 1; var movesLeft = s.movesLeft || 0; var targetScore = s.targetScore || calcTargetScore(level); var allTimeBest = s.allTimeBest || 0; var leaderboard = s.leaderboard ? s.leaderboard.slice() : []; var sfxVol = s.sfxVolume || 0.5; // Never unlock input on an unstable board. if (boardNeedsSettle(board)) { api.runInSeconds(0.05, function() { doCascadeGravity(api); }); return; } // Resolution stays deterministic once the board settles. // Check win condition if (score >= targetScore) { if (score > allTimeBest) allTimeBest = score; // Update leaderboard leaderboard.push({ level: level, score: score }); leaderboard.sort(function(a, b) { return b.score - a.score; }); if (leaderboard.length > 10) leaderboard = leaderboard.slice(0, 10); api.patchState({ animating: false, lastClearedIndices: [], lastClearedTiles: [], screen: 'levelComplete', allTimeBest: allTimeBest, leaderboard: leaderboard, autoAdvanceTimer: 10.0, autoAdvanceCountdown: 10, }); api.playSound('cdn/sfx-victory-fanfare-short.mp3', { volume: sfxVol * 0.9 }); return; } // Check lose condition if (movesLeft <= 0) { if (score > allTimeBest) allTimeBest = score; leaderboard.push({ level: level, score: score }); leaderboard.sort(function(a, b) { return b.score - a.score; }); if (leaderboard.length > 10) leaderboard = leaderboard.slice(0, 10); api.patchState({ animating: false, lastClearedIndices: [], lastClearedTiles: [], screen: 'gameOver', allTimeBest: allTimeBest, leaderboard: leaderboard, }); api.playSound('cdn/sfx-game-over-sad-trombone.mp3', { volume: sfxVol * 0.8 }); return; } // Check for dead board if (!hasValidMoves(board)) { reshuffleBoard(api, board, level); api.patchState({ board: board, animating: false, lastClearedIndices: [], lastClearedTiles: [], reshuffled: true, }); api.runInSeconds(1.2, function() { api.patchState({ reshuffled: false }); }); return; } // Normal end of cascade api.patchState({ animating: false, lastClearedIndices: [], lastClearedTiles: [], }); } // --------------- Utility --------------- function cloneBoard(board) { var src = Array.isArray(board) ? board : []; var result = []; for (var i = 0; i < ROWS * COLS; i++) { var cell = src[i]; if (!cell || cell.type === undefined || cell.type === null) { result.push(null); } else { var cloned = { type: cell.type, special: cell.special || null, id: cell.id, row: cell.row, col: cell.col, explosive: !!cell.explosive, }; if (cell.golden === true) cloned.golden = true; if (cell.bomb === true) cloned.bomb = true; if (cell.pawTier !== undefined && cell.pawTier !== null) cloned.pawTier = cell.pawTier; result.push(cloned); } } return result; }