/**** 
* Plugins
****/ 
var tween = LK.import("@upit/tween.v1");
var storage = LK.import("@upit/storage.v1", {
	level: 1,
	score: 0,
	highScore: 0
});

/**** 
* Classes
****/ 
var Candy = Container.expand(function (type, row, col) {
	var self = Container.call(this);
	self.type = type || 'redCandy';
	self.row = row || 0;
	self.col = col || 0;
	self.isSpecial = false; // Flag indicating if this candy is special (e.g., striped, wrapped)
	// Visual representation
	var visual = self.attachAsset(self.type, {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 1
	});
	// Selection overlay (hidden by default)
	var overlay = self.attachAsset('selectedOverlay', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0,
		visible: false // Start invisible
	});
	// Marker for special candies (optional, initially hidden)
	var specialMarker = null;
	self.setSpecial = function (special) {
		self.isSpecial = special;
		// Add visual distinction for special candies if needed
		if (special) {
			if (!specialMarker) {
				// Example: Add a marker instead of scaling/pulsing the base visual
				specialMarker = self.attachAsset('specialMarkerCandy', {
					anchorX: 0.5,
					anchorY: 0.5,
					alpha: 1 // Make it visible
				});
			}
			// Optional: Pulse animation for special marker
			tween.stop(specialMarker); // Stop previous tweens on marker
			specialMarker.alpha = 0.6;
			tween(specialMarker, {
				alpha: 1.0
			}, {
				duration: 800,
				easing: tween.easeInOut,
				yoyo: true,
				// Go back and forth
				loop: true // Repeat indefinitely
			});
		} else {
			if (specialMarker) {
				tween.stop(specialMarker); // Stop animation
				specialMarker.destroy();
				specialMarker = null;
			}
		}
	};
	self.select = function () {
		overlay.visible = true;
		tween.stop(overlay, {
			alpha: true
		}); // Stop previous animation
		tween(overlay, {
			alpha: 0.4
		}, {
			duration: 150
		});
	};
	self.deselect = function () {
		tween.stop(overlay, {
			alpha: true
		}); // Stop previous animation
		tween(overlay, {
			alpha: 0
		}, {
			duration: 150,
			onFinish: function onFinish() {
				overlay.visible = false; // Hide after fade out
			}
		});
	};
	self.moveTo = function (newRow, newCol, animate, delay, onComplete) {
		self.row = newRow;
		self.col = newCol;
		var newX = CELL_SIZE * self.col + CELL_SIZE / 2;
		var newY = CELL_SIZE * self.row + CELL_SIZE / 2;
		if (animate) {
			tween.stop(self, {
				x: true,
				y: true
			}); // Stop previous movement
			tween(self, {
				x: newX,
				y: newY
			}, {
				duration: 300,
				// Consistent duration
				delay: delay || 0,
				easing: tween.easeOutQuad,
				// Smooth easing
				onFinish: onComplete
			});
		} else {
			tween.stop(self, {
				x: true,
				y: true
			}); // Ensure any running tween is stopped
			self.x = newX;
			self.y = newY;
			if (onComplete) {
				onComplete();
			}
		}
	};
	// Pop animation - Returns the tween instance
	self.pop = function (delay, onComplete) {
		tween.stop(self, {
			alpha: true,
			scaleX: true,
			scaleY: true
		}); // Stop other tweens
		return tween(self, {
			alpha: 0,
			scaleX: 0.1,
			// Shrink down 
			scaleY: 0.1
		}, {
			duration: 250,
			delay: delay || 0,
			easing: tween.easeInQuad,
			// Ease in for disappearance 
			onFinish: function onFinish() {
				// Note: Actual destruction and removal from arrays happen elsewhere 
				if (onComplete) {
					onComplete();
				}
			}
		});
	};
	// Override destroy to clean up marker tween
	var baseDestroy = self.destroy;
	self.destroy = function () {
		if (specialMarker) {
			tween.stop(specialMarker);
		}
		baseDestroy.call(self); // Call original destroy
	};
	self.down = function (x, y, obj) {
		// Delegate to the main game click handler
		if (game && typeof game.handleCandyClick === 'function' && !isSwapping && !isDropping) {
			game.handleCandyClick(self);
		}
	};
	return self;
});
var GameBoard = Container.expand(function (rows, cols) {
	var self = Container.call(this);
	self.rows = rows || 8;
	self.cols = cols || 8;
	// Background board
	var boardVisual = self.attachAsset('gameBoard', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	boardVisual.width = CELL_SIZE * self.cols; // Match width to grid
	boardVisual.height = CELL_SIZE * self.rows; // Match height to grid
	// Cell backgrounds
	self.cells = [];
	for (var row = 0; row < self.rows; row++) {
		self.cells[row] = []; // Initialize row array
		for (var col = 0; col < self.cols; col++) {
			var cell = self.attachAsset('cellBackground', {
				anchorX: 0.5,
				anchorY: 0.5,
				x: col * CELL_SIZE + CELL_SIZE / 2,
				y: row * CELL_SIZE + CELL_SIZE / 2
			});
			self.cells[row][col] = cell; // Store cell reference if needed later
		}
	}
	return self;
});

/**** 
* Initialize Game
****/ 
var game = new LK.Game({
	backgroundColor: 0x5D94FB // A pleasant blue
});

/**** 
* Game Code
****/ 
function executeDoubleStripedEffect(centerCandy) {
	isProcessing = true;
	var targetRow = centerCandy.row;
	var targetCol = centerCandy.col;
	var candiesToDestroy = [];
	// Scan Row
	for (var c = 0; c < BOARD_SIZE; c++) {
		var _board$targetRow;
		var candy = (_board$targetRow = board[targetRow]) === null || _board$targetRow === void 0 ? void 0 : _board$targetRow[c];
		if (candy && candiesToDestroy.indexOf(candy) === -1) {
			candiesToDestroy.push(candy);
			board[targetRow][c] = null;
		}
	}
	// Scan Column
	for (var r = 0; r < BOARD_SIZE; r++) {
		var _board$r;
		var candy = (_board$r = board[r]) === null || _board$r === void 0 ? void 0 : _board$r[targetCol];
		if (candy && candiesToDestroy.indexOf(candy) === -1) {
			candiesToDestroy.push(candy);
			board[r][targetCol] = null;
		}
	}
	// Play sound and update score
	LK.getSound('special').play();
	score += candiesToDestroy.length * 20;
	updateUI();
	// Prepare animations
	var actions = [];
	candiesToDestroy.forEach(function (candy) {
		var delay = (Math.abs(candy.row - targetRow) + Math.abs(candy.col - targetCol)) * 35;
		actions.push({
			then: function then(resolve) {
				return candy.pop(delay, resolve);
			}
		});
	});
	// Wait for animations to complete
	handleCompletion(actions, function () {
		candiesToDestroy.forEach(function (c) {
			return c.destroy();
		});
		resolveDropsAndFills();
	});
}
function executeColorBombEffect(bombCandy, targetType) {
	isProcessing = true; // Lock the board
	// Find all candies of the targetType
	var candiesToDestroyByBomb = [];
	candies.forEach(function (c) {
		if (c.type === targetType && !c.isSpecial) {
			candiesToDestroyByBomb.push(c);
		}
	});
	// Include the bombCandy itself
	candiesToDestroyByBomb.push(bombCandy);
	// Update board model
	candiesToDestroyByBomb.forEach(function (candy) {
		board[candy.row][candy.col] = null;
	});
	// Prepare animations
	var popPromises = [];
	candiesToDestroyByBomb.forEach(function (candy, index) {
		popPromises.push({
			then: function then(resolve) {
				candy.pop(index * 30, function () {
					candy.destroy();
					resolve();
				});
			}
		});
	});
	// Play sound and update score
	LK.getSound('special').play();
	score += candiesToDestroyByBomb.length * 10;
	updateUI();
	// Wait for animations to complete
	(function (promises, callback) {
		var remaining = promises.length;
		if (remaining === 0) {
			callback();
		}
		promises.forEach(function (promise) {
			promise.then(function () {
				remaining--;
				if (remaining === 0) {
					callback();
				}
			});
		});
	})(popPromises, function () {
		// Cleanup and proceed to drop/fill
		candiesToDestroyByBomb.forEach(function (candy) {
			var index = candies.indexOf(candy);
			if (index > -1) {
				candies.splice(index, 1);
			}
		});
		resolveDropsAndFills();
	});
}
function activateSpecialCandy(candy) {
	switch (candy.type) {
		case 'colorBomb':
			// Clear all candies of the color it was swapped with
			var targetType = candy.swappedWithType; // Assume swappedWithType is set during swap
			candies.forEach(function (c) {
				if (c.type === targetType) {
					popPromises.push({
						then: function then(resolve) {
							c.pop(0, function () {
								c.destroy();
								resolve();
							});
						}
					});
				}
			});
			break;
		case 'stripedH':
			// Clear entire row
			for (var col = 0; col < BOARD_SIZE; col++) {
				var rowCandy = board[candy.row][col];
				if (rowCandy) {
					popPromises.push({
						then: function then(resolve) {
							rowCandy.pop(col * 50, function () {
								// Add delay based on column index
								rowCandy.destroy();
								resolve();
							});
						}
					});
				}
			}
			break;
		case 'stripedV':
			// Clear entire column
			for (var row = 0; row < BOARD_SIZE; row++) {
				var colCandy = board[row][candy.col];
				if (colCandy) {
					colCandy.pop(row * 50, function () {
						// Add delay based on row index
						colCandy.destroy();
					});
				}
			}
			break;
		default:
			break;
	}
}
// Sound for special candy creation/activation
// Keep as is for selection
// Example: Could be a different shape/texture
// Renamed specialCandy shape slightly for clarity
// Assets definition looks good, assuming LK.init.shape/sound works as expected.
// Constants
var BOARD_SIZE = 8;
var CELL_SIZE = 120; // Increase size of each cell for better visibility
var CANDY_TYPES = ['redCandy', 'yellowCandy', 'greenCandy', 'blueCandy', 'purpleCandy', 'orangeCandy'];
var NUM_CANDY_TYPES = CANDY_TYPES.length;
// Game state variables
var board; // 2D array holding Candy objects or null
var candies = []; // Flat list of all active Candy objects on the board
var selectedCandy = null;
var isSwapping = false; // True during the swap animation
var isProcessing = false; // General flag for when board is resolving (matches, drops, fills)
var isDropping = false; // Flag to indicate if candies are currently dropping
var moves = 0;
var score = 0;
var targetScore = 0;
var level = storage.level || 1;
var highScore = storage.highScore || 0;
// Game elements
var gameBoardContainer; // Holds the visual board and candies
var scoreTxt, movesTxt, levelTxt;
// --- Core Game Logic Functions ---
function setupGame() {
	// Create and center the game board container
	var background = LK.getAsset('gameBoard', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: (2048 - CELL_SIZE * BOARD_SIZE) / 2 + 200,
		y: (2732 - CELL_SIZE * BOARD_SIZE) / 2 + 200
	});
	game.addChild(background);
	gameBoardContainer = new GameBoard(BOARD_SIZE, BOARD_SIZE);
	// Center the board (assuming 2048x2732 is the stage size)
	gameBoardContainer.x = (2048 - gameBoardContainer.width) / 2 + 200; // Shift right by 200 pixels
	gameBoardContainer.y = (2732 - gameBoardContainer.height) / 2 + 200; // Shift down by 200 pixels
	game.addChild(gameBoardContainer);
	// Setup UI elements
	scoreTxt = new Text2('Score: 0', {
		size: 70,
		fill: 0xFFFFFF,
		align: 'right'
	});
	scoreTxt.anchor.set(1, 0); // Anchor top-right
	LK.gui.topRight.addChild(scoreTxt);
	scoreTxt.x = -20; // Add some padding from the edge
	movesTxt = new Text2('Moves: 0', {
		size: 70,
		fill: 0xFFFFFF,
		align: 'left'
	});
	movesTxt.anchor.set(0, 0); // Anchor top-left
	LK.gui.topLeft.addChild(movesTxt);
	movesTxt.x = 20; // Add some padding from the edge
	levelTxt = new Text2('Level: 1', {
		size: 70,
		fill: 0xFFFFFF
	});
	levelTxt.anchor.set(0.5, 0); // Anchor top-center
	LK.gui.top.addChild(levelTxt);
	// Initialize the first level
	initializeLevel(level);
	// Start background music
	LK.playMusic('bgmusic', {
		loop: true,
		fade: {
			start: 0,
			end: 0.5,
			duration: 1000
		}
	});
	// Attach global click listener (if Candy.down isn't sufficient)
	// game.down = handleGameClick; // Use this if clicking empty cells should deselect
}
function initializeLevel(levelNum) {
	level = levelNum;
	score = 0;
	moves = 20 + (level - 1) * 2; // Example: Increase moves per level
	targetScore = 1000 * level; // Example: Increase target score per level
	// Add additional objectives like clearing jellies or bringing ingredients down
	var objectives = {
		clearJellies: Math.floor(level / 2),
		bringIngredients: Math.floor(level / 3)
	};
	selectedCandy = null;
	isSwapping = false;
	isProcessing = false;
	updateUI();
	initializeBoard();
}
function initializeBoard() {
	// Clear existing candies visually and from arrays
	for (var i = 0; i < candies.length; i++) {
		candies[i].destroy();
	}
	candies = [];
	board = [];
	// Create the board array and fill with candies
	for (var row = 0; row < BOARD_SIZE; row++) {
		board[row] = [];
		for (var col = 0; col < BOARD_SIZE; col++) {
			board[row][col] = null; // Ensure initialized to null
			// Generate candy ensuring no initial matches
			var attempts = 0;
			do {
				var type = getRandomCandyType();
				// Temporarily place to check for matches
				var tempCandy = {
					type: type
				}; // Lightweight check
				board[row][col] = tempCandy;
				attempts++;
				if (attempts > 50) {
					// Safety break for rare impossible scenarios
					console.warn("Struggling to place initial candy without match at", row, col);
					break;
				}
			} while (checkMatchAt(row, col));
			// If check passed or safety break, create the real candy
			var candy = new Candy(type, row, col);
			candy.moveTo(row, col, false); // Place instantly
			gameBoardContainer.addChild(candy);
			board[row][col] = candy; // Place real candy in board
			candies.push(candy);
		}
	}
	// Final check: Ensure there are possible moves
	if (!hasPossibleMoves()) {
		console.log("No initial moves, reshuffling...");
		// Use LK.setTimeout to allow the initial draw frame to happen first
		LK.setTimeout(reshuffleBoard, 100);
	}
}
// Helper to check for matches *only* at a specific new candy's location
function checkMatchAt(row, col) {
	var candy = board[row][col];
	if (!candy) {
		return false;
	}
	var type = candy.type;
	// Check Horizontal
	var count = 1;
	if (col > 0 && board[row][col - 1] && board[row][col - 1].type === type) {
		count++;
	}
	if (col > 1 && board[row][col - 2] && board[row][col - 2].type === type) {
		count++;
	}
	if (count >= 3) {
		return true;
	}
	// Check Vertical
	count = 1;
	if (row > 0 && board[row - 1][col] && board[row - 1][col].type === type) {
		count++;
	}
	if (row > 1 && board[row - 2][col] && board[row - 2][col].type === type) {
		count++;
	}
	if (count >= 3) {
		return true;
	}
	return false;
}
function getRandomCandyType() {
	var typesAvailable = Math.min(NUM_CANDY_TYPES, 3 + Math.floor(level / 3)); // Slower difficulty ramp
	return CANDY_TYPES[Math.floor(Math.random() * typesAvailable)];
}
function updateUI() {
	scoreTxt.setText('Score: ' + score);
	movesTxt.setText('Moves: ' + moves);
	levelTxt.setText('Level: ' + level);
}
// Renamed from handleCandyClick to be clearer
game.handleCandyClick = function (candy) {
	if (isProcessing || isSwapping || isDropping) {
		return;
	} // Ignore clicks during processing or animations
	if (selectedCandy === null) {
		selectedCandy = candy;
		// Highlight the cell background
		gameBoardContainer.cells[candy.row][candy.col].tint = 0xffff00; // Highlight with yellow
	} else {
		// Second selection
		if (selectedCandy === candy) {
			// Deselect if same candy clicked
			// Revert cell background tint
			gameBoardContainer.cells[selectedCandy.row][selectedCandy.col].tint = 0x704f3d; // Original color
			gameBoardContainer.cells[selectedCandy.row][selectedCandy.col].tint = 0x704f3d; // Revert tint
			selectedCandy = null;
		} else {
			// Check if candies are adjacent
			var rowDiff = Math.abs(selectedCandy.row - candy.row);
			var colDiff = Math.abs(selectedCandy.col - candy.col);
			if (rowDiff === 1 && colDiff === 0 || rowDiff === 0 && colDiff === 1) {
				// Adjacent: Initiate swap
				selectedCandy.deselect(); // Deselect the first one visually
				swapCandies(selectedCandy, candy);
				selectedCandy = null; // Clear selection after initiating swap
			} else {
				// Not adjacent: Change selection to the new candy
				// Revert previous selection's cell background tint
				gameBoardContainer.cells[selectedCandy.row][selectedCandy.col].tint = 0x704f3d; // Original color
				selectedCandy = candy;
				// Highlight new selection's cell background
				gameBoardContainer.cells[candy.row][candy.col].tint = 0xffff00; // Highlight with yellow
				LK.getSound('invalid').play(); // Sound for invalid selection change
			}
		}
	}
};
function swapCandies(candy1, candy2) {
	if (isSwapping || isProcessing) {
		return;
	} // Prevent overlapping swaps
	isSwapping = true;
	// Store original positions for potential revert
	var candy1Row = candy1.row;
	var candy1Col = candy1.col;
	var candy2Row = candy2.row;
	var candy2Col = candy2.col;
	// Track the type of candy a color bomb is swapped with
	if (candy1.type === 'colorBomb') {
		candy1.swappedWithType = candy2.type;
	} else if (candy2.type === 'colorBomb') {
		candy2.swappedWithType = candy1.type;
	}
	// Update board model immediately
	board[candy1Row][candy1Col] = candy2;
	board[candy2Row][candy2Col] = candy1;
	// Update candy objects' internal row/col
	candy1.row = candy2Row;
	candy1.col = candy2Col;
	candy2.row = candy1Row;
	candy2.col = candy1Col;
	// Animate the swap visually
	LK.getSound('swap').play();
	var tween1 = candy1.moveTo(candy2Row, candy2Col, true);
	var tween2 = candy2.moveTo(candy1Row, candy1Col, true);
	// After animation finishes (wait for the longer of the two, though they should be same duration)
	// Using a small timeout is simpler than tracking both tweens
	LK.setTimeout(function () {
		// Check if the swap resulted in a match
		var matchFound = checkMatchAt(candy1.row, candy1.col) || checkMatchAt(candy2.row, candy2.col) || findMatches().length > 0; // More robust check
		// Check for color bomb swap
		if (candy1.type === 'colorBomb' && !candy2.isSpecial) {
			executeColorBombEffect(candy1, candy2.type);
			isSwapping = false;
			return;
		} else if (candy2.type === 'colorBomb' && !candy1.isSpecial) {
			executeColorBombEffect(candy2, candy1.type);
			isSwapping = false;
			return;
		}
		if (matchFound) {
			// Valid swap, deduct move and process matches
			moves--;
			updateUI();
			isSwapping = false; // Allow processing now
			processBoard(); // Start the match -> drop -> fill cycle
			// Check game state later, after processing finishes
		} else if ((candy1.type === 'stripedH' || candy1.type === 'stripedV') && (candy2.type === 'stripedH' || candy2.type === 'stripedV')) {
			executeDoubleStripedEffect(candy1);
			isSwapping = false;
			return;
		} else {
			// Invalid swap, animate back
			LK.getSound('invalid').play();
			// Update board model back
			board[candy1Row][candy1Col] = candy1;
			board[candy2Row][candy2Col] = candy2;
			// Update candy objects' internal row/col back
			candy1.row = candy1Row;
			candy1.col = candy1Col;
			candy2.row = candy2Row;
			candy2.col = candy2Col;
			// Animate back
			candy1.moveTo(candy1Row, candy1Col, true);
			candy2.moveTo(candy2Row, candy2Col, true);
			// After swap back animation finishes
			LK.setTimeout(function () {
				isSwapping = false; // Ready for next input
				gameBoardContainer.cells[candy1.row][candy1.col].tint = 0x704f3d; // Revert tint
				gameBoardContainer.cells[candy2.row][candy2.col].tint = 0x704f3d; // Revert tint
				selectedCandy = null;
			}, 310); // Slightly longer than moveTo duration
		}
	}, 310); // Wait for swap animation to mostly complete
}
// Main processing loop trigger
function processBoard() {
	if (isProcessing) {
		return;
	} // Avoid re-entry
	isProcessing = true;
	handleMatches();
}
// Step 1: Find and handle matches
function handleMatches() {
	var matches = findMatches();
	if (matches.length > 0) {
		LK.getSound('match').play();
		var pointsEarned = 0;
		var specialCandiesToCreate = []; // Store {row, col, type} for special creation
		// Mark candies for removal and calculate score/special
		var candiesToRemove = [];
		matches.forEach(function (match) {
			var matchSize = match.length;
			var pointsPerCandy = 10 * matchSize; // Bonus for longer matches
			// Decide if a special candy should be created from this match
			var createSpecial = null; // { type: 'stripedH', row: r, col: c } etc.
			if (matchSize >= 5) {
				// 5-in-a-row -> Color Bomb (example)
				createSpecial = {
					type: 'colorBomb',
					row: match.row,
					col: match.col + (match.horizontal ? Math.floor(matchSize / 2) : 0)
				};
				if (!match.horizontal) {
					createSpecial.col = match.col;
				}
				if (!match.horizontal) {
					createSpecial.row = match.row + Math.floor(matchSize / 2);
				}
			} else if (matchSize === 4) {
				// 4-in-a-row -> Striped (example)
				createSpecial = {
					type: match.horizontal ? 'stripedV' : 'stripedH',
					row: match.row,
					col: match.col + (match.horizontal ? Math.floor(matchSize / 2) : 0)
				};
				if (!match.horizontal) {
					createSpecial.col = match.col;
				}
				if (!match.horizontal) {
					createSpecial.row = match.row + Math.floor(matchSize / 2);
				}
			} // Add logic for L/T shapes for Wrapped candies if needed
			var specialCreated = false;
			for (var j = 0; j < matchSize; j++) {
				var row = match.horizontal ? match.row : match.row + j;
				var col = match.horizontal ? match.col + j : match.col;
				var candy = board[row][col];
				if (candy && candiesToRemove.indexOf(candy) === -1) {
					if (candy.isSpecial) {
						popPromises.push({
							then: function then(resolve) {
								setTimeout(function () {
									activateSpecialCandy(candy);
									resolve();
								}, 300); // Delay special candy activation to allow normal match processing
							}
						});
					}
					// Ensure not already marked
					candiesToRemove.push(candy);
					pointsEarned += pointsPerCandy * (candy.isSpecial ? 2 : 1); // More points for popping special candies
					// If this is the spot for special creation, mark it
					if (createSpecial && row === createSpecial.row && col === createSpecial.col) {
						specialCandiesToCreate.push(createSpecial);
						specialCreated = true;
					}
				}
			}
			// If special should be created but wasn't assigned to a specific candy (e.g., user swipe location matters), handle here
			// if (createSpecial && !specialCreated) { ... }
		});
		score += pointsEarned;
		updateUI();
		// Animate removal
		var popPromises = [];
		candiesToRemove.forEach(function (candy, index) {
			// Remove from board model immediately
			if (board[candy.row][candy.col] === candy) {
				board[candy.row][candy.col] = null;
			}
			// Animate pop
			popPromises.push({
				then: function then(resolve) {
					candy.pop(index * 30, resolve); // Pass resolve directly to pop as onComplete
				}
			});
			// Remove from the master list
			var listIndex = candies.indexOf(candy);
			if (listIndex > -1) {
				candies.splice(listIndex, 1);
			}
		});
		// After all pops are visually done, proceed to drop/fill
		(function (promises, callback) {
			var remaining = promises.length;
			if (remaining === 0) {
				callback();
			}
			promises.forEach(function (promise) {
				promise.then(function () {
					remaining--;
					if (remaining === 0) {
						callback();
					}
				});
			});
		})(popPromises, function () {
			candiesToRemove.forEach(function (candy) {
				return candy.destroy();
			}); // Final cleanup
			// Now create the special candies *before* dropping
			specialCandiesToCreate.forEach(function (spec) {
				var newType = spec.type; // Use the specified special type
				// In a real game, 'spec.type' would determine the *kind* of special candy
				// For now, we just make it visually 'special'
				var specialCandy = new Candy(spec.type, spec.row, spec.col);
				specialCandy.setSpecial(true); // Make it special
				specialCandy.moveTo(spec.row, spec.col, false); // Place instantly
				gameBoardContainer.addChild(specialCandy);
				board[spec.row][spec.col] = specialCandy;
				candies.push(specialCandy);
				LK.getSound('special').play();
			});
			handleDrops(); // Proceed to next step
		});
	} else {
		// No matches found, board is stable
		isProcessing = false;
		selectedCandy = null; // Clear selection
		// Check for possible moves ONLY if the board is stable
		if (!hasPossibleMoves()) {
			reshuffleBoard(); // This will set isProcessing again briefly
		} else {
			checkGameState(); // Check win/loss only when stable and moves exist
		}
	}
}
// Step 2: Handle candies dropping down
function handleDrops() {
	var dropsOccurred = false;
	var dropPromises = [];
	for (var col = 0; col < BOARD_SIZE; col++) {
		var emptyRow = BOARD_SIZE - 1; // Start checking from bottom
		// Find the lowest empty spot
		for (var row = BOARD_SIZE - 1; row >= 0; row--) {
			if (board[row][col] === null) {
				emptyRow = row; // Found the lowest empty row in this column
				break; // No need to check further up for the initial empty spot
			}
		}
		// Now check candies above this empty spot
		for (var row = BOARD_SIZE - 1; row >= 0; row--) {
			if (board[row][col] !== null) {
				// Check if there's a gap below this candy
				var targetRow = row;
				while (targetRow + 1 < BOARD_SIZE && board[targetRow + 1][col] === null) {
					targetRow++;
				}
				if (targetRow !== row) {
					// Move in model
					var candy = board[row][col];
					board[targetRow][col] = candy;
					board[row][col] = null;
					// Animate move
					var dropTween = candy.moveTo(targetRow, col, true, 0); // Drop animation
					dropPromises.push({
						then: function then(resolve) {
							if (dropTween && dropTween.vars) {
								dropTween.vars.onFinish = resolve;
							} else {
								resolve(); // Resolve immediately if dropTween or vars is undefined
							}
						}
					});
					dropsOccurred = true;
				}
			}
		}
	}
	if (dropsOccurred) {
		(function (promises, callback) {
			var remaining = promises.length;
			if (remaining === 0) {
				callback();
			}
			promises.forEach(function (promise) {
				promise.then(function () {
					remaining--;
					if (remaining === 0) {
						callback();
					}
				});
			});
		})(dropPromises, handleFills); // Wait for drops, then fill 
	} else {
		handleFills(); // No drops, proceed directly to filling
	}
}
// Step 3: Fill empty spaces from the top
function handleFills() {
	var fillsOccurred = false;
	var fillPromises = [];
	for (var col = 0; col < BOARD_SIZE; col++) {
		var fillRow = -1; // Start generating candies above the board
		for (var row = BOARD_SIZE - 1; row >= 0; row--) {
			if (board[row][col] === null) {
				// Found an empty spot
				var type = getRandomCandyType();
				var candy = new Candy(type, fillRow, col); // Create above the board
				candy.moveTo(fillRow, col, false); // Place instantly above
				gameBoardContainer.addChild(candy);
				board[row][col] = candy; // Assign to target cell in model
				candies.push(candy);
				// Animate move into place
				var delay = (-fillRow - 1) * 50; // Stagger based on how high it starts
				var fillTween = candy.moveTo(row, col, true, delay);
				fillPromises.push({
					then: function then(resolve) {
						if (fillTween && fillTween.vars) {
							fillTween.vars.onFinish = resolve;
						} else {
							resolve(); // Resolve immediately if fillTween or vars is undefined
						}
					}
				});
				fillsOccurred = true;
				fillRow--; // Next candy starts even higher
			}
		}
	}
	if (fillsOccurred) {
		if (typeof Promise !== 'undefined' && Promise.all) {
			Promise.all(fillPromises).then(handleMatches); // Wait for fills, then check for new matches (cascade)
		} else {
			console.error("Promise is not supported in this environment.");
			handleMatches(); // Fallback to directly calling handleMatches
		}
	} else {
		// No fills needed, implies no matches occurred in the previous step either. Board is stable.
		handleMatches(); // Final check (will find no matches and trigger end processing)
	}
}
function findMatches() {
	var matches = [];
	var checked = []; // Keep track of candies already part of a found match
	function markChecked(candy) {
		if (candy && checked.indexOf(candy) === -1) {
			checked.push(candy);
		}
	}
	// Check horizontal matches
	for (var row = 0; row < BOARD_SIZE; row++) {
		for (var col = 0; col < BOARD_SIZE - 2; col++) {
			var candy1 = board[row][col];
			if (!candy1 || checked.indexOf(candy1) > -1) {
				continue;
			} // Skip nulls or already checked
			var candy2 = board[row][col + 1];
			var candy3 = board[row][col + 2];
			if (candy2 && candy3 && candy1.type === candy2.type && candy1.type === candy3.type) {
				// Found a horizontal match of at least 3
				var currentMatch = [candy1, candy2, candy3];
				var matchLength = 3;
				// Check for longer match
				for (var k = col + 3; k < BOARD_SIZE; k++) {
					var nextCandy = board[row][k];
					if (nextCandy && nextCandy.type === candy1.type) {
						currentMatch.push(nextCandy);
						matchLength++;
					} else {
						break; // End of match
					}
				}
				// Store match details
				matches.push({
					candies: currentMatch,
					// Store the actual candy objects
					row: row,
					col: col,
					length: matchLength,
					horizontal: true
				});
				// Mark all candies in this match as checked
				currentMatch.forEach(markChecked);
				col += matchLength - 1; // Skip checked candies in the outer loop
			}
		}
	}
	// Check vertical matches
	for (var col = 0; col < BOARD_SIZE; col++) {
		for (var row = 0; row < BOARD_SIZE - 2; row++) {
			var candy1 = board[row][col];
			// Skip nulls or candies already part of a horizontal match
			if (!candy1 || checked.indexOf(candy1) > -1) {
				continue;
			}
			var candy2 = board[row + 1][col];
			var candy3 = board[row + 2][col];
			if (candy2 && candy3 && candy1.type === candy2.type && candy1.type === candy3.type) {
				// Found a vertical match of at least 3
				var currentMatch = [candy1, candy2, candy3];
				var matchLength = 3;
				// Check for longer match
				for (var k = row + 3; k < BOARD_SIZE; k++) {
					var nextCandy = board[k][col];
					if (nextCandy && nextCandy.type === candy1.type) {
						// Avoid adding if already part of a horizontal match found earlier
						if (checked.indexOf(nextCandy) === -1) {
							currentMatch.push(nextCandy);
						} else {
							// If it was part of a horizontal match, just increase length but don't re-add
						}
						matchLength++;
					} else {
						break; // End of match
					}
				}
				// Store match details
				matches.push({
					candies: currentMatch,
					// Store the actual candy objects
					row: row,
					col: col,
					length: matchLength,
					horizontal: false
				});
				// Mark all candies in this match as checked
				currentMatch.forEach(markChecked);
				row += matchLength - 1; // Skip checked candies in the outer loop
			}
		}
	}
	return matches;
}
function hasPossibleMoves() {
	// Check horizontal swaps that could create a match
	for (var row = 0; row < BOARD_SIZE; row++) {
		for (var col = 0; col < BOARD_SIZE - 1; col++) {
			if (canSwapCreateMatch(row, col, row, col + 1)) {
				return true;
			}
		}
	}
	// Check vertical swaps that could create a match
	for (var row = 0; row < BOARD_SIZE - 1; row++) {
		for (var col = 0; col < BOARD_SIZE; col++) {
			if (canSwapCreateMatch(row, col, row + 1, col)) {
				return true;
			}
		}
	}
	return false; // No possible moves found
}
// Helper function for hasPossibleMoves
function canSwapCreateMatch(r1, c1, r2, c2) {
	var candy1 = board[r1][c1];
	var candy2 = board[r2][c2];
	if (!candy1 || !candy2) {
		return false;
	} // Cannot swap with empty space
	// Temporarily swap types in the model (don't need full object swap)
	board[r1][c1] = candy2;
	board[r2][c2] = candy1;
	// Check if this swap creates a match around either position
	var createsMatch = checkMatchAt(r1, c1) || checkMatchAt(r2, c2) || findMatches().length > 0; // Simplified check
	// Swap back
	board[r1][c1] = candy1;
	board[r2][c2] = candy2;
	return createsMatch;
}
function reshuffleBoard() {
	if (isProcessing) {
		// Don't reshuffle if already processing
		LK.setTimeout(reshuffleBoard, 500); // Try again later
		return;
	}
	isProcessing = true; // Block input during reshuffle
	// Display reshuffling message
	var reshuffleTxt = new Text2('Reshuffling...', {
		size: 100,
		fill: 0xFFFFFF
	});
	reshuffleTxt.anchor.set(0.5, 0.5);
	LK.gui.center.addChild(reshuffleTxt);
	// 1. Collect all current candy types and special status
	var currentCandiesInfo = [];
	candies.forEach(function (candy) {
		currentCandiesInfo.push({
			type: candy.type,
			isSpecial: candy.isSpecial // Retain special status during reshuffle
		});
		candy.destroy(); // Remove old visuals immediately
	});
	candies = []; // Clear the list
	board = []; // Clear the board model
	// 2. Shuffle the collected info
	for (var i = currentCandiesInfo.length - 1; i > 0; i--) {
		var j = Math.floor(Math.random() * (i + 1));
		var _ref = [currentCandiesInfo[j], currentCandiesInfo[i]];
		currentCandiesInfo[i] = _ref[0];
		currentCandiesInfo[j] = _ref[1];
	}
	// 3. Rebuild the board ensuring no initial matches AND possible moves
	var attempts = 0;
	do {
		attempts++;
		if (attempts > 10) {
			// Safety break if it struggles too much
			console.error("Failed to reshuffle into a valid state after 10 attempts.");
			// Could force a simple known-good layout here or reset level
			isProcessing = false; // Unlock
			reshuffleTxt.destroy();
			// Maybe show a "No more moves" game over?
			checkGameState(true); // Force check, likely leading to game over if moves are 0
			return;
		}
		// Clear board for re-attempt
		candies.forEach(function (c) {
			return c.destroy();
		});
		candies = [];
		board = [];
		var infoIndex = 0;
		for (var row = 0; row < BOARD_SIZE; row++) {
			board[row] = [];
			for (var col = 0; col < BOARD_SIZE; col++) {
				var info = currentCandiesInfo[infoIndex++];
				board[row][col] = null; // Temp null for checkMatchAt
				// Ensure no immediate matches with shuffled type
				var placeAttempts = 0;
				do {
					var currentInfo = info; // Use the shuffled info
					board[row][col] = {
						type: currentInfo.type,
						isSpecial: currentInfo.isSpecial
					}; // Temp place
					placeAttempts++;
					if (placeAttempts > currentCandiesInfo.length) {
						// Avoid infinite loop if types are very limited
						// Swap with a later random type if stuck
						var swapIdx = infoIndex + Math.floor(Math.random() * (currentCandiesInfo.length - infoIndex));
						if (swapIdx < currentCandiesInfo.length) {
							var _ref2 = [currentCandiesInfo[swapIdx], currentCandiesInfo[infoIndex - 1]];
							currentCandiesInfo[infoIndex - 1] = _ref2[0];
							currentCandiesInfo[swapIdx] = _ref2[1];
							info = currentCandiesInfo[infoIndex - 1]; // Get the newly swapped info
						}
						board[row][col] = {
							type: info.type,
							isSpecial: info.isSpecial
						}; // Try again with swapped
						break; // Exit do-while for this cell after swap
					}
				} while (checkMatchAt(row, col)); // Check if placing this type creates a match
				// Create the actual candy
				var candy = new Candy(board[row][col].type, row, col);
				candy.setSpecial(board[row][col].isSpecial);
				candy.alpha = 0; // Start invisible
				candy.moveTo(row, col, false);
				gameBoardContainer.addChild(candy);
				board[row][col] = candy; // Replace temp object with real candy
				candies.push(candy);
				// Animate fade-in
				tween(candy, {
					alpha: 1
				}, {
					duration: 300,
					delay: (row + col) * 20
				});
			}
		}
		// Loop condition: Keep reshuffling if the new board has no possible moves
	} while (!hasPossibleMoves() && attempts < 10);
	// Reshuffle successful
	LK.setTimeout(function () {
		reshuffleTxt.destroy();
		isProcessing = false; // Unlock the board
	}, 500); // Keep message visible briefly
}
function checkGameState() {
	var forceCheck = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
	// Don't check state while the board is actively processing, unless forced (e.g., reshuffle failed)
	if (isProcessing && !forceCheck) {
		return;
	}
	// Check Win Condition
	if (score >= targetScore) {
		console.log("Level " + level + " Complete!");
		isProcessing = true; // Prevent further input
		// Update storage
		level++;
		storage.level = level;
		if (score > highScore) {
			highScore = score;
			storage.highScore = highScore;
		}
		storage.score = score; // Save current score too, maybe for win screen display
		LK.setTimeout(function () {
			LK.showYouWin({
				level: level - 1,
				score: score,
				highScore: highScore
			});
		}, 1000); // Delay for effect
	}
	// Check Lose Condition
	else if (moves <= 0) {
		console.log("Game Over - Out of Moves!");
		isProcessing = true; // Prevent further input
		// Update high score if needed
		if (score > highScore) {
			highScore = score;
			storage.highScore = highScore;
		}
		storage.score = score; // Save final score
		LK.setTimeout(function () {
			LK.showGameOver({
				level: level,
				score: score,
				highScore: highScore
			});
		}, 1000); // Delay for effect
	}
	// Note: The "no possible moves" scenario is now handled by reshuffleBoard,
	// but if reshuffling fails repeatedly, it might also lead to a game over state here.
}
// --- Game Start ---
setupGame();

===================================================================
--- original.js
+++ change.js
@@ -199,8 +199,53 @@
 
 /**** 
 * Game Code
 ****/ 
+function executeDoubleStripedEffect(centerCandy) {
+	isProcessing = true;
+	var targetRow = centerCandy.row;
+	var targetCol = centerCandy.col;
+	var candiesToDestroy = [];
+	// Scan Row
+	for (var c = 0; c < BOARD_SIZE; c++) {
+		var _board$targetRow;
+		var candy = (_board$targetRow = board[targetRow]) === null || _board$targetRow === void 0 ? void 0 : _board$targetRow[c];
+		if (candy && candiesToDestroy.indexOf(candy) === -1) {
+			candiesToDestroy.push(candy);
+			board[targetRow][c] = null;
+		}
+	}
+	// Scan Column
+	for (var r = 0; r < BOARD_SIZE; r++) {
+		var _board$r;
+		var candy = (_board$r = board[r]) === null || _board$r === void 0 ? void 0 : _board$r[targetCol];
+		if (candy && candiesToDestroy.indexOf(candy) === -1) {
+			candiesToDestroy.push(candy);
+			board[r][targetCol] = null;
+		}
+	}
+	// Play sound and update score
+	LK.getSound('special').play();
+	score += candiesToDestroy.length * 20;
+	updateUI();
+	// Prepare animations
+	var actions = [];
+	candiesToDestroy.forEach(function (candy) {
+		var delay = (Math.abs(candy.row - targetRow) + Math.abs(candy.col - targetCol)) * 35;
+		actions.push({
+			then: function then(resolve) {
+				return candy.pop(delay, resolve);
+			}
+		});
+	});
+	// Wait for animations to complete
+	handleCompletion(actions, function () {
+		candiesToDestroy.forEach(function (c) {
+			return c.destroy();
+		});
+		resolveDropsAndFills();
+	});
+}
 function executeColorBombEffect(bombCandy, targetType) {
 	isProcessing = true; // Lock the board
 	// Find all candies of the targetType
 	var candiesToDestroyByBomb = [];
@@ -570,8 +615,12 @@
 			updateUI();
 			isSwapping = false; // Allow processing now
 			processBoard(); // Start the match -> drop -> fill cycle
 			// Check game state later, after processing finishes
+		} else if ((candy1.type === 'stripedH' || candy1.type === 'stripedV') && (candy2.type === 'stripedH' || candy2.type === 'stripedV')) {
+			executeDoubleStripedEffect(candy1);
+			isSwapping = false;
+			return;
 		} else {
 			// Invalid swap, animate back
 			LK.getSound('invalid').play();
 			// Update board model back