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

/**** 
* Classes
****/ 
//Library for using the camera (the background becomes the user's camera video feed) and the microphone. It can access face coordinates for interactive play, as well detect microphone volume / voice interactions
//var facekit = LK.import('@upit/facekit.v1');
//Classes can only be defined here. You cannot create inline classes in the games code.
var Tile = Container.expand(function (assetId, row, col, layer) {
	var self = Container.call(this);
	self.assetId = assetId;
	self.row = row;
	self.col = col;
	self.layer = layer || 0;
	self.isMatched = false;
	self.isCovered = false;
	// Check if it's a shape asset and adjust rendering
	var isShapeAsset = shapeAssets.indexOf(assetId) !== -1;
	if (isShapeAsset) {
		var tileGraphics = self.attachAsset(assetId, {
			anchorX: 0.5,
			anchorY: 0.5
		});
	} else {
		var tileGraphics = self.attachAsset(assetId, {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 2,
			scaleY: 3
		});
	}
	self.down = function (x, y, obj) {
		if (!self.isMatched && !self.isCovered) {
			tileSelected(self);
		}
	};
	self.destroy = function () {
		self.isMatched = true;
		// tween the tile out or fade it
		tween(self, {
			alpha: 0,
			scaleX: 0,
			scaleY: 0
		}, {
			duration: 300,
			onFinish: function onFinish() {
				// Remove from game scene
				self.parent.removeChild(self);
				// Remove from tiles array
				var index = tiles.indexOf(self);
				if (index > -1) {
					tiles.splice(index, 1);
				}
				// Uncover tiles below this one
				updateCoveredTiles();
				// Check for level completion
				if (tiles.length === 0) {
					isTransitioningLevel = true; // Set flag to prevent game over
					LK.clearInterval(levelTimer);
					// Show level complete message
					var levelCompleteText = new Text2('Level ' + currentLevel + ' Complete!', {
						size: 120,
						fill: 0xFFD700
					});
					levelCompleteText.anchor.set(0.5, 0.5);
					levelCompleteText.x = gameWidth / 2;
					levelCompleteText.y = gameHeight / 2 - 100;
					game.addChild(levelCompleteText);
					// Calculate score bonus for completing level
					var timeBonus = timeRemaining * 5;
					var levelBonus = currentLevel * 100;
					var totalBonus = timeBonus + levelBonus;
					LK.setScore(LK.getScore() + totalBonus);
					scoreTxt.setText('Score: ' + LK.getScore());
					// Show bonus info
					var bonusInfoText = new Text2('Time Bonus: ' + timeBonus + '\nLevel Bonus: ' + levelBonus, {
						size: 60,
						fill: 0xFFFFFF
					});
					bonusInfoText.anchor.set(0.5, 0.5);
					bonusInfoText.x = gameWidth / 2;
					bonusInfoText.y = gameHeight / 2 + 50;
					game.addChild(bonusInfoText);
					if (currentLevel < maxLevel) {
						// Show next level info
						var nextLevelText = new Text2('Next: Level ' + (currentLevel + 1), {
							size: 80,
							fill: 0xFFFFFF
						});
						nextLevelText.anchor.set(0.5, 0.5);
						nextLevelText.x = gameWidth / 2;
						nextLevelText.y = gameHeight / 2 + 150;
						game.addChild(nextLevelText);
						// Increment level
						currentLevel++;
						// Start next level after delay
						LK.setTimeout(function () {
							levelCompleteText.parent.removeChild(levelCompleteText);
							bonusInfoText.parent.removeChild(bonusInfoText);
							nextLevelText.parent.removeChild(nextLevelText);
							startLevel();
						}, 3000);
					} else {
						// Completed all 10 levels - start over at level 1 with score intact
						var continueText = new Text2('Amazing! Starting new game cycle...', {
							size: 80,
							fill: 0xFFD700
						});
						continueText.anchor.set(0.5, 0.5);
						continueText.x = gameWidth / 2;
						continueText.y = gameHeight / 2 + 200;
						game.addChild(continueText);
						LK.setTimeout(function () {
							levelCompleteText.parent.removeChild(levelCompleteText);
							bonusInfoText.parent.removeChild(bonusInfoText);
							continueText.parent.removeChild(continueText);
							currentLevel = 1; // Reset to level 1
							startLevel(); // Continue playing
						}, 3000);
					}
				} else if (tiles.length > 0 && !isTransitioningLevel) {
					// Check if there are any valid matches left
					LK.setTimeout(function () {
						// Double-check tiles still exist and we're not transitioning
						if (tiles.length > 0 && !isTransitioningLevel && !hasAvailableMatches()) {
							// No moves available - restart level
							isTransitioningLevel = true;
							LK.clearInterval(levelTimer);
							// Show no moves message
							var noMovesText = new Text2('No Moves Left!', {
								size: 120,
								fill: 0xFF6B6B
							});
							noMovesText.anchor.set(0.5, 0.5);
							noMovesText.x = gameWidth / 2;
							noMovesText.y = gameHeight / 2 - 100;
							game.addChild(noMovesText);
							var restartText = new Text2('Restarting Level...', {
								size: 80,
								fill: 0xFFFFFF
							});
							restartText.anchor.set(0.5, 0.5);
							restartText.x = gameWidth / 2;
							restartText.y = gameHeight / 2 + 50;
							game.addChild(restartText);
							// Restart level after delay
							LK.setTimeout(function () {
								noMovesText.parent.removeChild(noMovesText);
								restartText.parent.removeChild(restartText);
								startLevel();
							}, 2000);
						}
					}, 100);
				}
			}
		});
	};
	return self; //You must return self if you want other classes to be able to inherit from this class
});

/**** 
* Initialize Game
****/ 
var game = new LK.Game({
	backgroundColor: 0xd1a400 // Init game with a steelblue background
});

/**** 
* Game Code
****/ 
// Declare shape assets array globally so it's accessible in Tile class
//Storage library which should be used for persistent game data
//Minimalistic tween library which should be used for animations over time, including tinting / colouring an object, scaling, rotating, or changing any game object property.
//Only include the plugins you need to create the game.
//We have access to the following plugins. (Note that the variable names used are mandetory for each plugin)
// Initialize assets used in this game. Scale them according to what is needed for the game.
// or via static code analysis based on their usage in the code.
// Assets are automatically created and loaded either dynamically during gameplay
/*
Supported Types:
1. Shape:
- Simple geometric figures with these properties:
* width: (required) pixel width of the shape.
* height: (required) pixel height of the shape.
* color: (required) color of the shape.
* shape: (required) type of shape. Valid options: 'box', 'ellipse'.
2. Image:
- Imported images with these properties:
* width: (required) pixel resolution width.
* height: (required) pixel resolution height.
* id: (required) identifier for the image.
* flipX: (optional) horizontal flip. Valid values: 0 (no flip), 1 (flip).
* flipY: (optional) vertical flip. Valid values: 0 (no flip), 1 (flip).
* orientation: (optional) rotation in multiples of 90 degrees, clockwise. Valid values:
- 0: No rotation.
- 1: Rotate 90 degrees.
- 2: Rotate 180 degrees.
- 3: Rotate 270 degrees.
Note: Width and height remain unchanged upon flipping.
3. Sound:
- Sound effects with these properties:
* id: (required) identifier for the sound.
* volume: (optional) custom volume. Valid values are a float from 0 to 1.
4. Music:
- In contract to sound effects, only one music can be played at a time
- Music is using the same API to initilize just like sound.
- Music loops by default
- Music with these config options:
* id: (required) identifier for the sound.
* volume: (optional) custom volume. Valid values are a float from 0 to 1.
* start: (optional) a float from 0 to 1 used for cropping and indicates the start of the cropping
* end: (optional) a float from 0 to 1 used for cropping and indicates the end of the cropping
*/
// Global variables
var shapeAssets = ['circle_tile'];
var selectedTile = null;
var tiles = [];
var scoreTxt;
var highScoreTxt;
var gameBoard; // Container for tiles
var currentLevel = 1;
var maxLevel = 10; // 10 levels total
var levelTimer;
var timeRemaining;
var timerText;
var levelText;
var consecutiveMatches = 0; // Track consecutive successful matches
var bonusText; // Display bonus multiplier
var isTransitioningLevel = false; // Flag to prevent game over during level transitions
// Game dimensions
var gameWidth = 2048;
var gameHeight = 2732;
// Tile dimensions and spacing
var tileWidth = 200;
var tileHeight = 300;
var tileSpacing = 20;
// Game board dimensions
var boardCols = 8;
var boardRows = 6;
var boardLayers = 2; // Two layers of tiles
var boardWidth = boardCols * (tileWidth + tileSpacing) - tileSpacing;
var boardHeight = boardRows * (tileHeight + tileSpacing) - tileSpacing;
// Available nature-themed assets
var availableAssets = ['potato', 'tomato', 'carrot', 'flower', 'tree', 'apple', 'corn', 'mushroom', 'pumpkin', 'sunflower', 'broccoli', 'strawberry'];
// Shape assets array already declared above
// Level configurations for different shapes
var levelConfigs = {
	1: {
		shape: 'rectangle',
		cols: 6,
		rows: 4,
		layers: 2
	},
	2: {
		shape: 'rectangle',
		cols: 8,
		rows: 6,
		layers: 2
	},
	3: {
		shape: 'triangle',
		cols: 8,
		rows: 5,
		layers: 2
	},
	4: {
		shape: 'circle',
		cols: 6,
		rows: 6,
		layers: 2
	},
	5: {
		shape: 'rectangle',
		cols: 9,
		rows: 6,
		layers: 3
	},
	6: {
		shape: 'triangle',
		cols: 9,
		rows: 6,
		layers: 3
	},
	7: {
		shape: 'circle',
		cols: 8,
		rows: 8,
		layers: 3
	},
	8: {
		shape: 'rectangle',
		cols: 10,
		rows: 7,
		layers: 3
	},
	9: {
		shape: 'triangle',
		cols: 9,
		rows: 7,
		layers: 4
	},
	10: {
		shape: 'circle',
		cols: 9,
		rows: 7,
		layers: 4
	}
};
// Function to get random asset based on level
function getRandomAssetForLevel(level) {
	// All levels use nature assets
	return availableAssets[Math.floor(Math.random() * availableAssets.length)];
}
// Function to get time limit for current level
function getTimeLimitForLevel(level) {
	if (level <= 3) {
		return 300; // 5 minutes
	} else if (level <= 6) {
		return 180; // 3 minutes
	} else {
		return 120; // 2 minutes
	}
}
// Intro screen container
var introContainer;
// Function to generate the game board layout
function generateBoardLayout(rows, cols, layers) {
	var config = levelConfigs[currentLevel];
	var shape = config.shape;
	var layout = [];
	// Generate shape-specific layouts
	for (var layer = 0; layer < layers; layer++) {
		layout[layer] = [];
		var validPositions = [];
		// Get valid positions based on shape
		for (var r = 0; r < rows; r++) {
			layout[layer][r] = [];
			for (var c = 0; c < cols; c++) {
				var isValid = false;
				if (shape === 'rectangle') {
					isValid = true;
				} else if (shape === 'triangle') {
					// Pyramid shape - start with 1-2 tiles at top, increase by 1-2 per row
					var tilesInRow = Math.min(cols, 2 + r * 2);
					var startCol = Math.floor((cols - tilesInRow) / 2);
					isValid = c >= startCol && c < startCol + tilesInRow;
				} else if (shape === 'circle') {
					// Circle shape - use distance from center
					var centerX = (cols - 1) / 2;
					var centerY = (rows - 1) / 2;
					var radiusX = cols / 2 - 0.5;
					var radiusY = rows / 2 - 0.5;
					var dx = (c - centerX) / radiusX;
					var dy = (r - centerY) / radiusY;
					isValid = dx * dx + dy * dy <= 1;
				}
				if (isValid) {
					validPositions.push({
						r: r,
						c: c
					});
					layout[layer][r][c] = null;
				} else {
					layout[layer][r][c] = null;
				}
			}
		}
		// Ensure even number of valid positions
		if (validPositions.length % 2 !== 0) {
			validPositions.pop();
		}
		// Create pairs of tiles
		var allTiles = [];
		for (var i = 0; i < validPositions.length / 2; i++) {
			var randomAssetId = getRandomAssetForLevel(currentLevel);
			allTiles.push(randomAssetId);
			allTiles.push(randomAssetId);
		}
		// Shuffle the tiles
		for (var i = allTiles.length - 1; i > 0; i--) {
			var j = Math.floor(Math.random() * (i + 1));
			var temp = allTiles[i];
			allTiles[i] = allTiles[j];
			allTiles[j] = temp;
		}
		// Place tiles in valid positions
		for (var i = 0; i < validPositions.length; i++) {
			var pos = validPositions[i];
			layout[layer][pos.r][pos.c] = allTiles[i];
		}
	}
	return layout;
}
// Function to create and position tiles
function createBoard(layout) {
	gameBoard = new Container();
	game.addChild(gameBoard);
	// Calculate actual board dimensions based on level config
	var config = levelConfigs[currentLevel];
	var actualBoardWidth = config.cols * (tileWidth + tileSpacing) - tileSpacing;
	var actualBoardHeight = config.rows * (tileHeight + tileSpacing) - tileSpacing;
	// Center the board on the screen
	gameBoard.x = (gameWidth - actualBoardWidth) / 2;
	gameBoard.y = (gameHeight - actualBoardHeight) / 2 + 100; // Adjust vertical position to avoid top menu
	// Create tiles for each layer
	for (var layer = 0; layer < layout.length; layer++) {
		var layerOffset = layer * 30; // Offset each layer for visual depth
		for (var r = 0; r < layout[layer].length; r++) {
			for (var c = 0; c < layout[layer][r].length; c++) {
				var assetId = layout[layer][r][c];
				if (assetId) {
					var tile = new Tile(assetId, r, c, layer);
					tile.x = c * (tileWidth + tileSpacing) + tileWidth / 2 + layerOffset;
					tile.y = r * (tileHeight + tileSpacing) + tileHeight / 2 - layerOffset;
					gameBoard.addChild(tile);
					tiles.push(tile);
				}
			}
		}
	}
	// Sort tiles by layer so upper layers are drawn on top
	tiles.sort(function (a, b) {
		return a.layer - b.layer;
	});
	// Update which tiles are covered
	updateCoveredTiles();
}
// Function to update which tiles are covered by tiles above them
function updateCoveredTiles() {
	// Reset all tiles to uncovered
	for (var i = 0; i < tiles.length; i++) {
		tiles[i].isCovered = false;
		tiles[i].alpha = 1;
	}
	// Check each tile to see if it's covered
	for (var i = 0; i < tiles.length; i++) {
		var tile = tiles[i];
		// Check if any tile above this one overlaps it
		for (var j = 0; j < tiles.length; j++) {
			var otherTile = tiles[j];
			if (otherTile.layer > tile.layer && !otherTile.isMatched) {
				// Check if tiles overlap (considering the offset)
				var layerDiff = otherTile.layer - tile.layer;
				var offsetX = layerDiff * 30;
				var offsetY = layerDiff * 30;
				var overlapX = Math.abs(tile.x - offsetX - otherTile.x) < tileWidth;
				var overlapY = Math.abs(tile.y + offsetY - otherTile.y) < tileHeight;
				if (overlapX && overlapY) {
					tile.isCovered = true;
					tile.alpha = 0.5; // Make covered tiles semi-transparent
					break;
				}
			}
		}
	}
}
// Function to handle tile selection and matching
function tileSelected(tile) {
	if (selectedTile === null) {
		selectedTile = tile;
		// Highlight the selected tile (optional)
		// tween(selectedTile, { tint: 0xffff00 }, { duration: 100 });
	} else if (selectedTile === tile) {
		// Deselect the same tile
		// tween(selectedTile, { tint: 0xffffff }, { duration: 100 });
		selectedTile = null;
	} else {
		// Check for a match
		if (selectedTile.assetId === tile.assetId) {
			// Match found
			LK.getSound('match_sound').play();
			consecutiveMatches++; // Increment consecutive matches
			var baseScore = 10;
			var multiplier = consecutiveMatches; // 1x, 2x, 3x, etc.
			var scoreToAdd = baseScore * multiplier;
			LK.setScore(LK.getScore() + scoreToAdd);
			scoreTxt.setText('Score: ' + LK.getScore());
			// Show bonus multiplier if greater than 1
			if (multiplier > 1) {
				showBonusText(multiplier, scoreToAdd);
			}
			selectedTile.destroy();
			tile.destroy();
			selectedTile = null;
		} else {
			// No match - reset consecutive matches
			consecutiveMatches = 0;
			LK.getSound('no_match_sound').play();
			// Optionally indicate no match (e.g., flash tiles red)
			// tween(selectedTile, { tint: 0xff0000 }, { duration: 200, onFinish: function() { tween(selectedTile, { tint: 0xffffff }, { duration: 200 }); } });
			// tween(tile, { tint: 0xff0000 }, { duration: 200, onFinish: function() { tween(tile, { tint: 0xffffff }, { duration: 200 }); } });
			selectedTile = null;
		}
	}
}
// Initialize score and high score display (created but not shown until game starts)
scoreTxt = new Text2('Score: 0', {
	size: 80,
	fill: 0xFFFFFF
});
scoreTxt.anchor.set(0.5, 0);
scoreTxt.y = 20; // Position below the top menu area
highScoreTxt = new Text2('High Score: ' + storage.highScore, {
	size: 80,
	fill: 0xFFFFFF
});
highScoreTxt.anchor.set(0.5, 0);
highScoreTxt.y = 120; // Position below the score display
// Create intro container
introContainer = new Container();
game.addChild(introContainer);
// Add intro background
var introBg = introContainer.attachAsset('Introbackground', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: gameWidth / 2,
	y: gameHeight / 2
});
// Get the actual dimensions of the background asset
var bgWidth = introBg.width;
var bgHeight = introBg.height;
// Calculate scale to cover the entire screen
var scaleX = gameWidth / bgWidth;
var scaleY = gameHeight / bgHeight;
// Use the larger scale to ensure full coverage
var scale = Math.max(scaleX, scaleY);
// Apply the scale
introBg.scale.set(scale, scale);
// Start button with image asset
var startButton = introContainer.attachAsset('Startbutton', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: gameWidth / 2,
	y: gameHeight - 200 // 200px from bottom
});
// Smooth continuous blinking animation using tween
function animateStartButton() {
	tween(startButton, {
		alpha: 0.3
	}, {
		duration: 1000,
		easing: tween.easeInOut,
		onFinish: function onFinish() {
			tween(startButton, {
				alpha: 1
			}, {
				duration: 1000,
				easing: tween.easeInOut,
				onFinish: animateStartButton // Loop the animation
			});
		}
	});
}
animateStartButton();
// Handle tap on start button to begin the game
startButton.down = function (x, y, obj) {
	tween.stop(startButton); // Stop the blinking animation
	introContainer.parent.removeChild(introContainer);
	startGame();
};
// High score button beside start button from the left side by 600px
var highScoreButton = introContainer.attachAsset('Highscorebutton', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: gameWidth / 2 - 600,
	// 100px to the left of start button
	y: gameHeight - 200 // Same Y position as start button
});
// Handle tap on high score button
highScoreButton.down = function (x, y, obj) {
	// Create high score display overlay
	var highScoreOverlay = new Container();
	introContainer.addChild(highScoreOverlay);
	// Create a dark semi-transparent background for scores
	var bgOverlay = LK.getAsset('box', {
		width: gameWidth,
		height: gameHeight,
		color: 0x000000,
		shape: 'box',
		anchorX: 0.5,
		anchorY: 0.5,
		x: gameWidth / 2,
		y: gameHeight / 2,
		alpha: 0.8
	});
	highScoreOverlay.addChild(bgOverlay);
	// High score text
	var hsText = new Text2('Your High Score\n' + storage.highScore, {
		size: 120,
		fill: 0xFFFFFF
	});
	hsText.anchor.set(0.5, 0.5);
	hsText.x = gameWidth / 2;
	hsText.y = gameHeight / 2 - 300;
	highScoreOverlay.addChild(hsText);
	// Leaderboard title
	var leaderboardTitle = new Text2('Top Players', {
		size: 100,
		fill: 0xFFD700
	});
	leaderboardTitle.anchor.set(0.5, 0.5);
	leaderboardTitle.x = gameWidth / 2;
	leaderboardTitle.y = gameHeight / 2 - 100;
	highScoreOverlay.addChild(leaderboardTitle);
	// Create mock leaderboard data since LK.getLeaderboard() doesn't exist
	var leaderboard = [{
		name: 'Player 1',
		score: 1000
	}, {
		name: 'Player 2',
		score: 850
	}, {
		name: 'Player 3',
		score: 720
	}, {
		name: 'Player 4',
		score: 650
	}, {
		name: 'Player 5',
		score: 500
	}];
	var leaderboardY = gameHeight / 2 + 50;
	// Display top 5 players
	for (var i = 0; i < Math.min(5, leaderboard.length); i++) {
		var entry = leaderboard[i];
		var rankText = new Text2(i + 1 + '. ' + entry.name + ' - ' + entry.score, {
			size: 70,
			fill: 0xFFFFFF
		});
		rankText.anchor.set(0.5, 0.5);
		rankText.x = gameWidth / 2;
		rankText.y = leaderboardY + i * 80;
		highScoreOverlay.addChild(rankText);
	}
	// Close button
	var closeText = new Text2('Tap to Close', {
		size: 80,
		fill: 0xFFFF00
	});
	closeText.anchor.set(0.5, 0.5);
	closeText.x = gameWidth / 2;
	closeText.y = gameHeight / 2 + 500;
	highScoreOverlay.addChild(closeText);
	// Handle tap to close overlay
	highScoreOverlay.down = function (x, y, obj) {
		highScoreOverlay.parent.removeChild(highScoreOverlay);
	};
};
// Function to start the game
function startGame() {
	currentLevel = 1;
	LK.setScore(0);
	scoreTxt.setText('Score: 0');
	LK.gui.top.addChild(scoreTxt);
	// Add level display
	levelText = new Text2('Level: ' + currentLevel, {
		size: 80,
		fill: 0xFFFFFF
	});
	levelText.anchor.set(0.5, 0);
	levelText.y = 120;
	LK.gui.top.addChild(levelText);
	// Add timer display
	timerText = new Text2('Time: 5:00', {
		size: 80,
		fill: 0xFFFFFF
	});
	timerText.anchor.set(0.5, 0);
	timerText.y = 220;
	LK.gui.top.addChild(timerText);
	startLevel();
	LK.playMusic('bg_music');
}
// Function to start a new level
function startLevel() {
	// Clear any existing timer
	if (levelTimer) {
		LK.clearInterval(levelTimer);
	}
	// Clear existing board
	if (gameBoard) {
		gameBoard.destroy();
	}
	tiles = [];
	selectedTile = null;
	consecutiveMatches = 0; // Reset consecutive matches for new level
	isTransitioningLevel = false; // Reset transition flag
	// Update level text
	levelText.setText('Level: ' + currentLevel);
	// Set time limit for current level
	timeRemaining = getTimeLimitForLevel(currentLevel);
	updateTimerDisplay();
	// Create new board with level-specific configuration
	var config = levelConfigs[currentLevel];
	var boardLayout = generateBoardLayout(config.rows, config.cols, config.layers);
	createBoard(boardLayout);
	// Start timer
	levelTimer = LK.setInterval(function () {
		timeRemaining--;
		updateTimerDisplay();
		if (timeRemaining <= 0) {
			LK.clearInterval(levelTimer);
			isTransitioningLevel = true;
			// Show time up message
			var timeUpText = new Text2('Time Up!', {
				size: 120,
				fill: 0xFF6B6B
			});
			timeUpText.anchor.set(0.5, 0.5);
			timeUpText.x = gameWidth / 2;
			timeUpText.y = gameHeight / 2 - 100;
			game.addChild(timeUpText);
			var restartText = new Text2('Restarting Level...', {
				size: 80,
				fill: 0xFFFFFF
			});
			restartText.anchor.set(0.5, 0.5);
			restartText.x = gameWidth / 2;
			restartText.y = gameHeight / 2 + 50;
			game.addChild(restartText);
			// Restart level after delay
			LK.setTimeout(function () {
				timeUpText.parent.removeChild(timeUpText);
				restartText.parent.removeChild(restartText);
				startLevel();
			}, 2000);
		}
	}, 1000);
}
// Function to update timer display
function updateTimerDisplay() {
	var minutes = Math.floor(timeRemaining / 60);
	var seconds = timeRemaining % 60;
	var timeString = minutes + ':' + (seconds < 10 ? '0' : '') + seconds;
	timerText.setText('Time: ' + timeString);
}
// Function to show bonus multiplier text
function showBonusText(multiplier, points) {
	// Remove existing bonus text if any
	if (bonusText && bonusText.parent) {
		bonusText.parent.removeChild(bonusText);
	}
	// Create new bonus text
	bonusText = new Text2(multiplier + 'x COMBO! +' + points, {
		size: 120,
		fill: 0xFFD700 // Gold color
	});
	bonusText.anchor.set(0.5, 0.5);
	bonusText.x = gameWidth / 2;
	bonusText.y = gameHeight / 2;
	game.addChild(bonusText);
	// Animate the bonus text
	tween(bonusText, {
		y: gameHeight / 2 - 200,
		alpha: 0
	}, {
		duration: 1500,
		onFinish: function onFinish() {
			if (bonusText.parent) {
				bonusText.parent.removeChild(bonusText);
			}
		}
	});
}
// Function to check if any valid matches are available
function hasAvailableMatches() {
	// Create a map to track available tiles by assetId
	var availableTilesByAsset = {};
	// Group all uncovered and unmatched tiles by their assetId
	for (var i = 0; i < tiles.length; i++) {
		var tile = tiles[i];
		if (!tile.isMatched && !tile.isCovered) {
			if (!availableTilesByAsset[tile.assetId]) {
				availableTilesByAsset[tile.assetId] = [];
			}
			availableTilesByAsset[tile.assetId].push(tile);
		}
	}
	// Check if any asset has at least 2 available tiles (a pair)
	for (var assetId in availableTilesByAsset) {
		if (availableTilesByAsset[assetId].length >= 2) {
			return true;
		}
	}
	return false;
}
// Game update loop (currently not needed for this game's logic, but included for structure)
game.update = function () {
	// Update high score if current score is higher
	if (LK.getScore() > storage.highScore) {
		storage.highScore = LK.getScore();
	}
};