/**** 
* Plugins
****/ 
var tween = LK.import("@upit/tween.v1");

/**** 
* Classes
****/ 
// BingoCell: Represents a single cell on the bingo card
var BingoCell = Container.expand(function () {
	var self = Container.call(this);
	// Properties
	self.number = 0;
	self.marked = false;
	// Create cell background
	var cellBg = self.attachAsset('bingoCellBg', {
		width: cellSize,
		height: cellSize,
		color: 0xffffff,
		shape: 'box',
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Number text
	var numberText = new Text2('', {
		size: Math.floor(cellSize * 0.45),
		fill: 0x222222
	});
	numberText.anchor.set(0.5, 0.5);
	self.addChild(numberText);
	// Mark overlay (hidden by default)
	var markOverlay = self.attachAsset('bingoMark', {
		width: cellSize * 0.7,
		height: cellSize * 0.7,
		color: 0x4caf50,
		shape: 'ellipse',
		anchorX: 0.5,
		anchorY: 0.5
	});
	markOverlay.alpha = 0;
	self.markOverlay = markOverlay;
	// Set number and update text
	self.setNumber = function (num) {
		self.number = num;
		numberText.setText(num > 0 ? num : '');
	};
	// Mark/unmark cell
	self.setMarked = function (val) {
		self.marked = val;
		if (val) {
			tween(markOverlay, {
				alpha: 0.7
			}, {
				duration: 200,
				easing: tween.easeOut
			});
			numberText.setText(self.number);
			numberText.setStyle({
				fill: 0xFFFFFF
			});
		} else {
			tween(markOverlay, {
				alpha: 0
			}, {
				duration: 200,
				easing: tween.easeOut
			});
			numberText.setStyle({
				fill: 0x222222
			});
		}
	};
	// Touch event
	self.down = function (x, y, obj) {
		// Play click sound on any cell tap
		LK.getSound('Click').play();
		if (self.marked) return;
		if (game.state !== 'playing') return;
		var p = self.playerIndex !== undefined ? self.playerIndex : 0;
		if (self.number === game.currentNumber && p === currentPlayer) {
			self.setMarked(true);
			LK.effects.flashObject(self, 0x4caf50, 200);
			// Streak logic
			if (typeof streak !== "undefined") {
				streak[p]++;
				streakText[p].setText("Streak: " + streak[p]);
				if (streak[p] > 1) {
					// Bonus: add 1s per streak above 1
					timeLeft[p] += 1000;
					tween(streakText[p], {
						scaleX: 1.3,
						scaleY: 1.3
					}, {
						duration: 100,
						yoyo: true,
						repeat: 1,
						easing: tween.easeOut
					});
				}
			}
			game.checkWin();
		} else {
			if (typeof streak !== "undefined") {
				streak[p] = 0;
				streakText[p].setText("");
			}
			LK.effects.flashObject(self, 0xff0000, 200);
		}
	};
	return self;
});
// CalledNumberBall: Shows a called number as a round ball
var CalledNumberBall = Container.expand(function () {
	var self = Container.call(this);
	// Ball background
	var ball = self.attachAsset('bingoBall', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Number text
	var numberText = new Text2('', {
		size: 60,
		fill: 0x222222
	});
	numberText.anchor.set(0.5, 0.5);
	numberText.x = 0;
	numberText.y = 0;
	self.addChild(numberText);
	self.setNumber = function (num) {
		numberText.setText(num);
	};
	return self;
});

/**** 
* Initialize Game
****/ 
var game = new LK.Game({
	backgroundColor: 0x1a237e
});

/**** 
* Game Code
****/ 
// Win highlight overlay (gold ellipse for winning line)
// Free space overlay (distinct color for center cell)
// Hint button background (green box, used for hint power-up)
// Mark overlay (beige box, used for marking cells)
// Bingo cell background (cyan box)
// Bingo ball (yellow ellipse)
// --- Functions ---
// --- Hint Power-Up Button ---
var hintButton = new Container();
var hintBg = hintButton.attachAsset('bingoCellBg', {
	width: 180,
	height: 90,
	color: 0x4caf50,
	anchorX: 0.5,
	anchorY: 0.5
});
var hintText = new Text2('Hint', {
	size: 48,
	fill: 0xffffff
});
hintText.anchor.set(0.5, 0.5);
hintButton.addChild(hintText);
hintButton.x = 2048 - 200;
hintButton.y = 320;
hintButton.scale.set(1, 1);
hintButton.interactive = true;
hintButton.visible = true;
game.addChild(hintButton);
// --- Reveal Row Power-Up Button ---
var revealRowButton = new Container();
var revealRowBg = revealRowButton.attachAsset('bingoCellBg', {
	width: 220,
	height: 90,
	color: 0x1976d2,
	anchorX: 0.5,
	anchorY: 0.5
});
var revealRowText = new Text2('Reveal Row', {
	size: 44,
	fill: 0xffffff
});
revealRowText.anchor.set(0.5, 0.5);
revealRowButton.addChild(revealRowText);
revealRowButton.x = 2048 - 200;
revealRowButton.y = 440;
revealRowButton.scale.set(1, 1);
revealRowButton.interactive = true;
revealRowButton.visible = true;
game.addChild(revealRowButton);
// --- Freeze Timer Power-Up Button ---
var freezeTimerButton = new Container();
var freezeTimerBg = freezeTimerButton.attachAsset('bingoCellBg', {
	width: 220,
	height: 90,
	color: 0x00bcd4,
	anchorX: 0.5,
	anchorY: 0.5
});
var freezeTimerText = new Text2('Freeze Timer', {
	size: 44,
	fill: 0xffffff
});
freezeTimerText.anchor.set(0.5, 0.5);
freezeTimerButton.addChild(freezeTimerText);
freezeTimerButton.x = 2048 - 200;
freezeTimerButton.y = 560;
freezeTimerButton.scale.set(1, 1);
freezeTimerButton.interactive = true;
freezeTimerButton.visible = true;
game.addChild(freezeTimerButton);
// Hint button logic
hintButton.down = function (x, y, obj) {
	if (!hintAvailable || hintUsed || game.state !== 'playing') return;
	var found = false;
	for (var i = 0; i < bingoCells.length; i++) {
		var cell = bingoCells[i];
		if (cell.number === game.currentNumber && !cell.marked) {
			// Animate a highlight pulse
			tween(cell.scale, {
				x: 1.3,
				y: 1.3
			}, {
				duration: 180,
				yoyo: true,
				repeat: 1,
				easing: tween.easeOut
			});
			tween(cell, {
				alpha: 0.5
			}, {
				duration: 100,
				yoyo: true,
				repeat: 1,
				easing: tween.easeOut
			});
			found = true;
		}
	}
	if (found) {
		hintUsed = true;
		hintAvailable = false;
		hintButton.visible = false;
	}
};
// Reveal Row button logic
revealRowButton.down = function (x, y, obj) {
	if (!revealRowAvailable || revealRowUsed || game.state !== 'playing') return;
	// Find a row with at least one unmarked cell (excluding the free space row if already all marked)
	var rowToReveal = -1;
	for (var row = 0; row < gridSize; row++) {
		var hasUnmarked = false;
		for (var col = 0; col < gridSize; col++) {
			var idx = col * gridSize + row;
			if (!bingoCells[idx].marked) {
				hasUnmarked = true;
			}
		}
		if (hasUnmarked) {
			rowToReveal = row;
			break;
		}
	}
	if (rowToReveal !== -1) {
		for (var col = 0; col < gridSize; col++) {
			var idx = col * gridSize + rowToReveal;
			if (!bingoCells[idx].marked) {
				bingoCells[idx].setMarked(true);
				tween(bingoCells[idx], {
					alpha: 0.5
				}, {
					duration: 100,
					yoyo: true,
					repeat: 1,
					easing: tween.easeOut
				});
			}
		}
		revealRowUsed = true;
		revealRowAvailable = false;
		revealRowButton.visible = false;
		// Check for win after revealing
		game.checkWin();
	}
};
// Freeze Timer button logic
freezeTimerButton.down = function (x, y, obj) {
	if (!freezeTimerAvailable || freezeTimerUsed || game.state !== 'playing' || freezeTimerActive) return;
	freezeTimerUsed = true;
	freezeTimerAvailable = false;
	freezeTimerButton.visible = false;
	freezeTimerActive = true;
	// Visually indicate freeze (e.g. flash timerText blue)
	tween(timerText, {
		tint: 0x00bcd4
	}, {
		duration: 200,
		yoyo: true,
		repeat: 1,
		easing: tween.easeOut
	});
	// Pause timer decrement
	if (timerInterval) LK.clearInterval(timerInterval);
	// Show "Timer Frozen!" text
	streakText.setText("Timer Frozen!");
	// Set timeout to resume timer after freeze duration
	freezeTimerTimeout = LK.setTimeout(function () {
		freezeTimerActive = false;
		streakText.setText(streak > 0 ? "Streak: " + streak : "");
		// Resume timer
		if (!gameOver) {
			timerInterval = LK.setInterval(function () {
				timeLeft -= 100;
				if (timeLeft < 0) timeLeft = 0;
				updateTimerText();
				if (timeLeft <= 0 && !gameOver) {
					endGame(false);
				}
			}, 100);
		}
	}, freezeTimerDuration);
};
var hintAvailable = true;
var hintUsed = false;
var revealRowAvailable = true;
var revealRowUsed = false;
var freezeTimerAvailable = true;
var freezeTimerUsed = false;
var freezeTimerActive = false;
var freezeTimerDuration = 5000; // ms
var freezeTimerTimeout = null;
var gridSize = 5; // 5x5 bingo
// Adjust cellSize and card positions for two-player mode to fit both cards on screen
var cellSize = 180; // px, reduced to fit two cards side by side
var cardPadding = 30;
var cardWidth = gridSize * cellSize;
var cardHeight = gridSize * cellSize;
var cardStartX = 2048 / 4 - cardWidth / 2; // Player 1 card center at 1/4 width, Player 2 at 3/4 width
var cardStartY = 500; // Lowered to fit both cards and UI
var callIntervalStart = 5000; // ms (5 seconds initial call speed)
var callIntervalMin = 1200; // ms (slower minimum speed)
var callIntervalStep = 60; // ms, decrease per call (slower speedup)
var gameDuration = 180000; // ms (3 min)
var numbersRange = 75; // 1-75
// --- State ---
// Two player support
var playerCount = 2;
var currentPlayer = 0; // 0 or 1
var bingoCells = [[], []]; // bingoCells[0] for player 1, bingoCells[1] for player 2
var calledNumbers = [];
var availableNumbers = [];
var callTimer = null;
var timeLeft = [gameDuration, gameDuration]; // Separate timers for each player
var timerInterval = [null, null];
var cardNumbers = [[], []];
var gameOver = false;
var playerNames = ["Player 1", "Player 2"];
var winText = [null, null]; // Per player
var streak = [0, 0];
var streakText = [null, null];
var timerText = [null, null];
var hintAvailable = [true, true];
var hintUsed = [false, false];
var revealRowAvailable = [true, true];
var revealRowUsed = [false, false];
var freezeTimerAvailable = [true, true];
var freezeTimerUsed = [false, false];
var freezeTimerActive = [false, false];
var freezeTimerTimeout = [null, null];
// --- UI Elements ---
// Container for called number balls
var calledBallsContainer = new Container();
calledBallsContainer.x = 2048 / 2;
calledBallsContainer.y = 2732 - 120;
game.addChild(calledBallsContainer);
// Show the latest called numbers as balls (max 6)
function updateCalledBallsUI() {
	// Remove old balls
	while (calledBallsContainer.children.length > 0) {
		calledBallsContainer.removeChild(calledBallsContainer.children[0]);
	}
	var maxBalls = 6;
	var startIdx = Math.max(0, calledNumbers.length - maxBalls);
	var ballsToShow = calledNumbers.slice(startIdx);
	var spacing = 130;
	var totalWidth = (ballsToShow.length - 1) * spacing;
	for (var i = 0; i < ballsToShow.length; i++) {
		var ball = new CalledNumberBall();
		ball.setNumber(ballsToShow[i]);
		ball.x = -totalWidth / 2 + i * spacing;
		ball.y = 0;
		// Animate in the newest ball
		if (i === ballsToShow.length - 1) {
			ball.scale.x = 0.1;
			ball.scale.y = 0.1;
			tween(ball.scale, {
				x: 1,
				y: 1
			}, {
				duration: 180,
				easing: tween.easeOut
			});
		}
		calledBallsContainer.addChild(ball);
	}
}
var numberCallText = new Text2('', {
	size: 180,
	fill: 0xFFD600
});
numberCallText.anchor.set(0.5, 0.5);
numberCallText.x = 2048 / 2;
numberCallText.y = 2732 - 300;
game.addChild(numberCallText);
var streak = 0;
var streakText = new Text2('', {
	size: 80,
	fill: 0x00e676
});
streakText.anchor.set(0.5, 0);
streakText.x = 2048 / 2;
streakText.y = 320;
game.addChild(streakText);
var timerText = new Text2('', {
	size: 90,
	fill: 0xFFFFFF
});
timerText.anchor.set(0.5, 0);
LK.gui.top.addChild(timerText);
var winText = new Text2('', {
	size: 120,
	fill: 0x4CAF50
});
winText.anchor.set(0.5, 0.5);
winText.x = 2048 / 2;
winText.y = 2732 / 2;
winText.visible = false;
game.addChild(winText);
// --- Functions ---
// Generate a random bingo card (5x5, center is free)
function generateCardNumbers() {
	var nums = [];
	var used = [];
	for (var col = 0; col < gridSize; col++) {
		var colNums = [];
		var min = col * 15 + 1;
		var max = min + 14;
		for (var row = 0; row < gridSize; row++) {
			if (col === 2 && row === 2) {
				colNums.push(0); // Free space
				continue;
			}
			var n;
			do {
				n = min + Math.floor(Math.random() * (max - min + 1));
			} while (used.indexOf(n) !== -1);
			used.push(n);
			colNums.push(n);
		}
		nums.push(colNums);
	}
	return nums;
}
// Create bingo card UI for both players
function createBingoCards() {
	for (var p = 0; p < playerCount; p++) {
		bingoCells[p] = [];
		cardNumbers[p] = generateCardNumbers();
		// Center cards at 1/4 and 3/4 of the screen width
		var cardCenterX = p === 0 ? 2048 / 4 : 2048 * 3 / 4;
		var offsetX = cardCenterX - cardWidth / 2;
		for (var col = 0; col < gridSize; col++) {
			for (var row = 0; row < gridSize; row++) {
				var cell = new BingoCell();
				var x = offsetX + col * cellSize + cellSize / 2;
				var y = cardStartY + row * cellSize + cellSize / 2;
				cell.x = x;
				cell.y = y;
				var num = cardNumbers[p][col][row];
				cell.setNumber(num);
				if (col === 2 && row === 2) {
					cell.setMarked(true); // Free space
				}
				cell.playerIndex = p;
				game.addChild(cell);
				bingoCells[p].push(cell);
			}
		}
	}
}
// Start a new game for two players
function startGame() {
	game.state = 'playing';
	gameOver = false;
	calledNumbers = [];
	availableNumbers = [];
	for (var i = 1; i <= numbersRange; i++) availableNumbers.push(i);
	createBingoCards();
	numberCallText.setText('');
	// Per player UI and state
	for (var p = 0; p < playerCount; p++) {
		if (!winText[p]) {
			winText[p] = new Text2('', {
				size: 120,
				fill: 0x4CAF50
			});
			winText[p].anchor.set(0.5, 0.5);
			winText[p].x = p === 0 ? 2048 / 4 : 2048 * 3 / 4;
			winText[p].y = 2732 / 2;
			winText[p].visible = false;
			game.addChild(winText[p]);
		}
		if (!streakText[p]) {
			streakText[p] = new Text2('', {
				size: 80,
				fill: 0x00e676
			});
			streakText[p].anchor.set(0.5, 0);
			streakText[p].x = p === 0 ? 2048 / 4 : 2048 * 3 / 4;
			streakText[p].y = 320;
			game.addChild(streakText[p]);
		}
		if (!timerText[p]) {
			timerText[p] = new Text2('', {
				size: 90,
				fill: 0xFFFFFF
			});
			timerText[p].anchor.set(0.5, 0);
			LK.gui.top.addChild(timerText[p]);
		}
		winText[p].visible = false;
		streak[p] = 0;
		streakText[p].setText('');
		hintAvailable[p] = true;
		hintUsed[p] = false;
		revealRowAvailable[p] = true;
		revealRowUsed[p] = false;
		freezeTimerAvailable[p] = true;
		freezeTimerUsed[p] = false;
		freezeTimerActive[p] = false;
		if (freezeTimerTimeout[p]) {
			LK.clearTimeout(freezeTimerTimeout[p]);
			freezeTimerTimeout[p] = null;
		}
		timeLeft[p] = gameDuration;
		updateTimerTextForPlayer(p);
		if (timerInterval[p]) LK.clearInterval(timerInterval[p]);
		timerInterval[p] = LK.setInterval(function (playerIdx) {
			return function () {
				if (!freezeTimerActive[playerIdx]) {
					timeLeft[playerIdx] -= 100;
					if (timeLeft[playerIdx] < 0) timeLeft[playerIdx] = 0;
					updateTimerTextForPlayer(playerIdx);
					if (timeLeft[playerIdx] <= 0 && !gameOver) {
						endGame(false, playerIdx);
					}
				}
			};
		}(p), 100);
	}
	updateCalledBallsUI();
	currentPlayer = 0;
	nextNumberCall(callIntervalStart);
}
// Call the next number
game.currentNumber = null;
function nextNumberCall(interval) {
	if (gameOver) return;
	if (availableNumbers.length === 0) {
		endGame(false);
		return;
	}
	var idx = Math.floor(Math.random() * availableNumbers.length);
	var num = availableNumbers[idx];
	availableNumbers.splice(idx, 1);
	calledNumbers.push(num);
	game.currentNumber = num;
	numberCallText.setText(num);
	LK.effects.flashObject(numberCallText, 0xffd600, 300);
	// Update called balls UI
	updateCalledBallsUI();
	// Pulse the matching cell(s) on the card
	for (var i = 0; i < bingoCells.length; i++) {
		if (bingoCells[i].number === num && !bingoCells[i].marked) {
			tween(bingoCells[i].scale, {
				x: 1.2,
				y: 1.2
			}, {
				duration: 120,
				yoyo: true,
				repeat: 1,
				easing: tween.easeOut
			});
		}
	}
	// --- Opponent AI: Let opponent (player 2) mark cell if number matches and based on their points ---
	// Only run if two players
	if (playerCount === 2 && !gameOver) {
		// Assume player 1 is 0, player 2 is 1
		var opponentIdx = 1;
		// Count how many cells opponent has marked (score)
		var opponentScore = 0;
		for (var i = 0; i < bingoCells[opponentIdx].length; i++) {
			if (bingoCells[opponentIdx][i].marked) opponentScore++;
		}
		// Find the cell with the current number for opponent
		for (var i = 0; i < bingoCells[opponentIdx].length; i++) {
			var cell = bingoCells[opponentIdx][i];
			if (cell.number === num && !cell.marked) {
				// Simple AI: The more points, the faster the opponent marks
				// e.g. mark instantly if score >= 10, else random delay up to 1s
				var aiDelay = 0;
				if (opponentScore < 5) aiDelay = 600 + Math.random() * 400;else if (opponentScore < 10) aiDelay = 300 + Math.random() * 300;else aiDelay = 0;
				(function (cell, aiDelay) {
					LK.setTimeout(function () {
						if (!cell.marked && !gameOver) {
							cell.setMarked(true);
							// Flash for feedback
							LK.effects.flashObject(cell, 0x1976d2, 180);
							// Update streak for opponent
							streak[opponentIdx]++;
							streakText[opponentIdx].setText("Streak: " + streak[opponentIdx]);
							// Check win for opponent
							var prevPlayer = currentPlayer;
							currentPlayer = opponentIdx;
							game.checkWin();
							currentPlayer = prevPlayer;
						}
					}, aiDelay);
				})(cell, aiDelay);
			}
		}
	}
	// Speed up calls as game progresses
	var nextInterval = Math.max(callIntervalMin, interval - callIntervalStep);
	if (callTimer) LK.clearTimeout(callTimer);
	callTimer = LK.setTimeout(function () {
		nextNumberCall(nextInterval);
	}, nextInterval);
}
// Update timer UI for a specific player
function updateTimerTextForPlayer(p) {
	var sec = Math.ceil(timeLeft[p] / 1000);
	timerText[p].setText(playerNames[p] + " Time: " + sec + "s");
}
// Check for win (row, col, diag) for the current player
game.checkWin = function () {
	var p = currentPlayer;
	// Build marked grid
	var marked = [];
	for (var col = 0; col < gridSize; col++) {
		marked[col] = [];
		for (var row = 0; row < gridSize; row++) {
			var idx = col * gridSize + row;
			marked[col][row] = bingoCells[p][idx].marked;
		}
	}
	// Check rows
	for (var row = 0; row < gridSize; row++) {
		var win = true;
		for (var col = 0; col < gridSize; col++) {
			if (!marked[col][row]) win = false;
		}
		if (win) return endGame(true, p);
	}
	// Check cols
	for (var col = 0; col < gridSize; col++) {
		var win = true;
		for (var row = 0; row < gridSize; row++) {
			if (!marked[col][row]) win = false;
		}
		if (win) return endGame(true, p);
	}
	// Check diag TL-BR
	var win = true;
	for (var i = 0; i < gridSize; i++) {
		if (!marked[i][i]) win = false;
	}
	if (win) return endGame(true, p);
	// Check diag TR-BL
	win = true;
	for (var i = 0; i < gridSize; i++) {
		if (!marked[gridSize - 1 - i][i]) win = false;
	}
	if (win) return endGame(true, p);
};
// End game: win or lose for a specific player
function endGame(won, playerIdx) {
	gameOver = true;
	game.state = 'ended';
	if (callTimer) LK.clearTimeout(callTimer);
	for (var p = 0; p < playerCount; p++) {
		if (timerInterval[p]) LK.clearInterval(timerInterval[p]);
		if (freezeTimerTimeout[p]) {
			LK.clearTimeout(freezeTimerTimeout[p]);
			freezeTimerTimeout[p] = null;
		}
	}
	if (won) {
		// Helper to highlight a line
		var highlightLine = function highlightLine(indices) {
			for (var i = 0; i < indices.length; i++) {
				var idx = indices[i];
				var cell = bingoCells[playerIdx][idx];
				tween(cell.markOverlay, {
					alpha: 1
				}, {
					duration: 300,
					easing: tween.easeOut
				});
				cell.markOverlay.color = 0xffd600;
			}
		};
		winText[playerIdx].setText("BINGO!\nYou Win!");
		winText[playerIdx].setStyle({
			fill: 0x4CAF50
		});
		LK.effects.flashScreen(0x4caf50, 1000);
		// Highlight the winning line(s)
		// Rebuild marked grid
		var marked = [];
		for (var col = 0; col < gridSize; col++) {
			marked[col] = [];
			for (var row = 0; row < gridSize; row++) {
				var idx = col * gridSize + row;
				marked[col][row] = bingoCells[playerIdx][idx].marked;
			}
		}
		for (var row = 0; row < gridSize; row++) {
			var win = true;
			var indices = [];
			for (var col = 0; col < gridSize; col++) {
				if (!marked[col][row]) win = false;
				indices.push(col * gridSize + row);
			}
			if (win) highlightLine(indices);
		}
		for (var col = 0; col < gridSize; col++) {
			var win = true;
			var indices = [];
			for (var row = 0; row < gridSize; row++) {
				if (!marked[col][row]) win = false;
				indices.push(col * gridSize + row);
			}
			if (win) highlightLine(indices);
		}
		var win = true;
		var indices = [];
		for (var i = 0; i < gridSize; i++) {
			if (!marked[i][i]) win = false;
			indices.push(i * gridSize + i);
		}
		if (win) highlightLine(indices);
		win = true;
		indices = [];
		for (var i = 0; i < gridSize; i++) {
			if (!marked[gridSize - 1 - i][i]) win = false;
			indices.push((gridSize - 1 - i) * gridSize + i);
		}
		if (win) highlightLine(indices);
		LK.showYouWin();
	} else {
		winText[playerIdx].setText("Time's Up!\nGame Over");
		winText[playerIdx].setStyle({
			fill: 0xFF1744
		});
		LK.effects.flashScreen(0xff1744, 1000);
		LK.showGameOver();
	}
	winText[playerIdx].visible = true;
	revealRowButton.visible = false;
	freezeTimerButton.visible = false;
}
// --- Input: Restart on game over/win ---
game.down = function (x, y, obj) {
	if (game.state === 'ended') {
		// Wait for LK to reset game
	}
};
// --- Start ---
startGame();

===================================================================
--- original.js
+++ change.js
@@ -339,9 +339,9 @@
 var cardWidth = gridSize * cellSize;
 var cardHeight = gridSize * cellSize;
 var cardStartX = 2048 / 4 - cardWidth / 2; // Player 1 card center at 1/4 width, Player 2 at 3/4 width
 var cardStartY = 500; // Lowered to fit both cards and UI
-var callIntervalStart = 3500; // ms (slower initial call speed)
+var callIntervalStart = 5000; // ms (5 seconds initial call speed)
 var callIntervalMin = 1200; // ms (slower minimum speed)
 var callIntervalStep = 60; // ms, decrease per call (slower speedup)
 var gameDuration = 180000; // ms (3 min)
 var numbersRange = 75; // 1-75