dataDir = rtrim($dataDir, '/'); if (!is_dir($this->dataDir) || !is_writable($this->dataDir)) { throw new Exception("Data directory is invalid or not writable: {$this->dataDir}"); } } /** * Saves data associated with a key. * * @param string $key The unique identifier for the data. * @param mixed $data The data to save (will be serialized). * @return bool True on success, false on failure. */ public function save(string $key, mixed $data): bool { $filePath = $this->getFilePath($key); $serializedData = serialize($data); return file_put_contents($filePath, $serializedData) !== false; } /** * Loads data associated with a key. * * @param string $key The unique identifier for the data. * @return mixed The unserialized data, or null if not found or error. */ public function load(string $key): mixed { $filePath = $this->getFilePath($key); if (!file_exists($filePath)) { return null; } $serializedData = file_get_contents($filePath); if ($serializedData === false) { return null; // Or log error } // Suppress unserialize errors for invalid data $data = @unserialize($serializedData); return ($data !== false) ? $data : null; } /** * Deletes data associated with a key. * * @param string $key The unique identifier for the data. * @return bool True on success or if file doesn't exist, false on failure. */ public function delete(string $key): bool { $filePath = $this->getFilePath($key); if (!file_exists($filePath)) { return true; } return unlink($filePath); } /** * Generates the full file path for a given key. * * @param string $key * @return string */ private function getFilePath(string $key): string { // Sanitize key to prevent directory traversal $safeKey = preg_replace('/[^A-Za-z0-9_\-]/', '_', $key); return $this->dataDir . '/' . $safeKey . '.data'; } } botToken = $botToken; $this->apiUrl = "https://api.telegram.org/bot{$this->botToken}/"; } /** * Sends a request to the Telegram API. * * @param string $method API method name (e.g., 'sendMessage'). * @param array $params Parameters for the method. * @return mixed Decoded JSON response or false on failure. */ public function sendRequest(string $method, array $params = []): mixed { $url = $this->apiUrl . $method; $options = [ 'http' => [ 'header' => "Content-type: application/x-www-form-urlencoded\r\n", 'method' => 'POST', 'content' => http_build_query($params), 'ignore_errors' => true // To get error response bodies ], 'ssl' => [ 'verify_peer' => false, // Consider true in production with proper cert setup 'verify_peer_name' => false, ] ]; $context = stream_context_create($options); $result = file_get_contents($url, false, $context); if ($result === false) { // Log error: "Failed to connect to Telegram API" return false; } $decoded = json_decode($result, true); if ($decoded === null || !$decoded['ok']) { // Log error: "Telegram API Error: " . ($decoded['description'] ?? 'Unknown error') error_log("Telegram API Error for method {$method}: " . ($decoded['description'] ?? $result)); return false; } return $decoded['result']; } /** * Sends a text message. * * @param int $chatId * @param string $text * @param array|null $replyMarkup Inline keyboard markup (optional). * @param string|null $parseMode (e.g., 'MarkdownV2', 'HTML') * @return mixed API response or false on failure. */ public function sendMessage(int $chatId, string $text, ?array $replyMarkup = null, ?string $parseMode = null): mixed { $params = [ 'chat_id' => $chatId, 'text' => $text, ]; if ($replyMarkup) { $params['reply_markup'] = json_encode($replyMarkup); } if ($parseMode) { $params['parse_mode'] = $parseMode; } return $this->sendRequest('sendMessage', $params); } /** * Edits an existing message text. * * @param int $chatId * @param int $messageId * @param string $text * @param array|null $replyMarkup Inline keyboard markup (optional). * @param string|null $parseMode (e.g., 'MarkdownV2', 'HTML') * @return mixed API response or false on failure. */ public function editMessageText(int $chatId, int $messageId, string $text, ?array $replyMarkup = null, ?string $parseMode = null): mixed { $params = [ 'chat_id' => $chatId, 'message_id' => $messageId, 'text' => $text, ]; if ($replyMarkup) { $params['reply_markup'] = json_encode($replyMarkup); } if ($parseMode) { $params['parse_mode'] = $parseMode; } return $this->sendRequest('editMessageText', $params); } /** * Answers a callback query (e.g., from an inline button press). * * @param string $callbackQueryId * @param string|null $text Text to show as notification (optional). * @param bool $showAlert If true, show an alert instead of notification (optional). * @return mixed API response or false on failure. */ public function answerCallbackQuery(string $callbackQueryId, ?string $text = null, bool $showAlert = false): mixed { $params = [ 'callback_query_id' => $callbackQueryId, ]; if ($text !== null) { $params['text'] = $text; } $params['show_alert'] = $showAlert; return $this->sendRequest('answerCallbackQuery', $params); } /** * Gets updates from Telegram using long polling. * NOTE: Webhooks are recommended for production. * * @param int $offset Identifier of the first update to be returned. * @param int $limit Limits the number of updates to be retrieved. * @param int $timeout Timeout in seconds for long polling. * @return mixed Array of Update objects or false on failure. */ public function getUpdates(int $offset = 0, int $limit = 100, int $timeout = 60): mixed { $params = [ 'offset' => $offset, 'limit' => $limit, 'timeout' => $timeout, 'allowed_updates' => json_encode(['message', 'callback_query']) // Only listen for messages and callbacks ]; return $this->sendRequest('getUpdates', $params); } /** * Sets a webhook for receiving updates. * * @param string $url HTTPS URL to send updates to. * @return mixed API response or false on failure. */ public function setWebhook(string $url): mixed { $params = ['url' => $url]; return $this->sendRequest('setWebhook', $params); } /** * Deletes the webhook. * * @return mixed API response or false on failure. */ public function deleteWebhook(): mixed { return $this->sendRequest('deleteWebhook'); } } = $width * $height) { throw new InvalidArgumentException("Mine count must be less than the total number of cells."); } $this->width = $width; $this->height = $height; $this->mineCount = $mineCount; $this->initializeBoards(); } private function initializeBoards(): void { $this->board = array_fill(0, $this->height, array_fill(0, $this->width, self::CELL_EMPTY)); $this->revealed = array_fill(0, $this->height, array_fill(0, $this->width, false)); $this->flags = array_fill(0, $this->height, array_fill(0, $this->width, false)); $this->minesPlaced = false; $this->gameOver = false; $this->won = false; $this->revealedCount = 0; $this->flagCount = 0; } /** * Places mines randomly, avoiding the first revealed cell. * Calculates adjacent mine counts. * * @param int $startX X-coordinate of the first revealed cell. * @param int $startY Y-coordinate of the first revealed cell. */ private function placeMines(int $startX, int $startY): void { if ($this->minesPlaced) { return; } $totalCells = $this->width * $this->height; $minesToPlace = $this->mineCount; while ($minesToPlace > 0) { $x = rand(0, $this->width - 1); $y = rand(0, $this->height - 1); // Don't place a mine on the first click or where one already exists if (($x === $startX && $y === $startY) || $this->board[$y][$x] === self::CELL_MINE) { continue; } $this->board[$y][$x] = self::CELL_MINE; $minesToPlace--; } // Calculate adjacent mine counts for ($y = 0; $y < $this->height; $y++) { for ($x = 0; $x < $this->width; $x++) { if ($this->board[$y][$x] !== self::CELL_MINE) { $this->board[$y][$x] = $this->countAdjacentMines($x, $y); } } } $this->minesPlaced = true; } /** * Counts mines adjacent to a given cell. * * @param int $x * @param int $y * @return int */ private function countAdjacentMines(int $x, int $y): int { $count = 0; for ($dy = -1; $dy <= 1; $dy++) { for ($dx = -1; $dx <= 1; $dx++) { if ($dx === 0 && $dy === 0) continue; $nx = $x + $dx; $ny = $y + $dy; if ($this->isValidCoordinate($nx, $ny) && $this->board[$ny][$nx] === self::CELL_MINE) { $count++; } } } return $count; } /** * Checks if coordinates are within the board boundaries. * * @param int $x * @param int $y * @return bool */ private function isValidCoordinate(int $x, int $y): bool { return $x >= 0 && $x < $this->width && $y >= 0 && $y < $this->height; } /** * Reveals a cell. Handles game logic (placing mines on first reveal, game over, win condition, flood fill). * * @param int $x * @param int $y * @return bool True if the game state changed significantly (e.g., game over, won). */ public function reveal(int $x, int $y): bool { if ($this->gameOver || !$this->isValidCoordinate($x, $y) || $this->revealed[$y][$x] || $this->flags[$y][$x]) { return false; // No change or invalid action } // Place mines on the first reveal, ensuring the first click isn't a mine if (!$this->minesPlaced) { $this->placeMines($x, $y); } // Hit a mine? if ($this->board[$y][$x] === self::CELL_MINE) { $this->gameOver = true; $this->won = false; $this->revealAllMines(); return true; // Game Over } $this->performReveal($x, $y); // Check for win condition if ($this->revealedCount === ($this->width * $this->height) - $this->mineCount) { $this->gameOver = true; $this->won = true; $this->flagAllMines(); // Automatically flag remaining mines on win return true; // Won } return true; // State changed } /** * Recursive part of the reveal logic (flood fill). */ private function performReveal(int $x, int $y): void { if (!$this->isValidCoordinate($x, $y) || $this->revealed[$y][$x] || $this->flags[$y][$x]) { return; } $this->revealed[$y][$x] = true; $this->revealedCount++; // If the revealed cell is empty (0 adjacent mines), reveal neighbors if ($this->board[$y][$x] === self::CELL_EMPTY) { for ($dy = -1; $dy <= 1; $dy++) { for ($dx = -1; $dx <= 1; $dx++) { if ($dx === 0 && $dy === 0) continue; $this->performReveal($x + $dx, $y + $dy); } } } } /** * Toggles a flag on a cell. * * @param int $x * @param int $y * @return bool True if the flag state was changed. */ public function toggleFlag(int $x, int $y): bool { if ($this->gameOver || !$this->isValidCoordinate($x, $y) || $this->revealed[$y][$x]) { return false; // Cannot flag revealed cells or in game over state } if ($this->flags[$y][$x]) { // Remove flag $this->flags[$y][$x] = false; $this->flagCount--; } else { // Add flag (optional: limit flag count to mine count) // if ($this->flagCount < $this->mineCount) { $this->flags[$y][$x] = true; $this->flagCount++; // } else { // return false; // Max flags reached // } } return true; } /** * Reveals all mine locations (used on game over). */ private function revealAllMines(): void { for ($y = 0; $y < $this->height; $y++) { for ($x = 0; $x < $this->width; $x++) { if ($this->board[$y][$x] === self::CELL_MINE && !$this->flags[$y][$x]) { $this->revealed[$y][$x] = true; // Reveal unflagged mines } // Optional: Mark incorrectly placed flags // if ($this->board[$y][$x] !== self::CELL_MINE && $this->flags[$y][$x]) { // // Mark this cell visually as a wrong flag // } } } } /** * Flags all remaining mine locations (used on win). */ private function flagAllMines(): void { $this->flagCount = 0; for ($y = 0; $y < $this->height; $y++) { for ($x = 0; $x < $this->width; $x++) { if ($this->board[$y][$x] === self::CELL_MINE) { $this->flags[$y][$x] = true; $this->flagCount++; } else { $this->flags[$y][$x] = false; // Remove any incorrect flags } } } } public function isGameOver(): bool { return $this->gameOver; } public function isWon(): bool { return $this->won; } public function getFlagCount(): int { return $this->flagCount; } /** * Generates an inline keyboard representation of the board for Telegram. * * @return array The inline keyboard structure. */ public function generateInlineKeyboard(): array { $keyboard = []; $showMines = $this->gameOver && !$this->won; // Show mines only if lost for ($y = 0; $y < $this->height; $y++) { $row = []; for ($x = 0; $x < $this->width; $x++) { $text = $this->getCellTextRepresentation($x, $y, $showMines); // Callback data format: action_x_y (e.g., r_3_4, f_1_0) // Use 'noop' for revealed/disabled cells if needed, or rely on game logic to ignore clicks $callback_data = $this->getCellCallbackData($x, $y); $row[] = ['text' => $text, 'callback_data' => $callback_data]; } $keyboard[] = $row; } // Add a row for flag toggle mode if desired, or other controls // Example: $keyboard[] = [['text' => 'Toggle Flag Mode', 'callback_data' => 'mode_flag']]; return ['inline_keyboard' => $keyboard]; } /** * Gets the text representation for a single cell. */ private function getCellTextRepresentation(int $x, int $y, bool $showMines): string { if ($this->flags[$y][$x]) { // If game is over and flag was wrong if ($this->gameOver && $this->board[$y][$x] !== self::CELL_MINE) { return '❌'; // Wrong flag } return '🚩'; // Flag } if (!$this->revealed[$y][$x]) { // If game is over and this was an unrevealed mine if ($showMines && $this->board[$y][$x] === self::CELL_MINE) { return '💣'; } return '⬜'; // Hidden cell } // Revealed cells switch ($this->board[$y][$x]) { case self::CELL_MINE: return '💥'; // Exploded mine (should only happen if reveal logic allows revealing mines directly on loss) case self::CELL_EMPTY: return ' '; // Empty revealed cell case 1: return '1️⃣'; case 2: return '2️⃣'; case 3: return '3️⃣'; case 4: return '4️⃣'; case 5: return '5️⃣'; case 6: return '6️⃣'; case 7: return '7️⃣'; case 8: return '8️⃣'; default: return '?'; // Should not happen } } /** * Gets the callback data for a cell button. */ private function getCellCallbackData(int $x, int $y): string { // If cell is revealed or game is over, it shouldn't be clickable // Send a 'noop' or similar, or rely on handler logic to ignore if ($this->gameOver || $this->revealed[$y][$x]) { return 'noop_' . $x . '_' . $y; // Or just 'noop' if coordinates aren't needed } // Default action is reveal. Consider adding a flag mode toggle. // For simplicity, let's use left-click = reveal, maybe long-press/right-click = flag (not directly possible with inline kb) // A common pattern is a separate "Flag Mode" button or using callback data prefix. // Let's use prefix: 'r' for reveal, 'f' for flag. We need a way to switch modes or use separate commands. // Simple approach: always send 'r_x_y'. User uses /flag command or a mode button. // Let's try a simpler callback: just the coordinates, and decide action based on context? Risky. // Let's stick to explicit actions in callback data. Assume default is reveal. // To flag, user might need to use a command like /flag x y, or we add a flag mode button. // For this example, let's assume primary click reveals. Flagging might need another mechanism. // Let's define callback as "action_x_y". We'll primarily handle 'r' (reveal). // We can add 'f' later if we implement a flag toggle button. // Let's make the callback data always 'r_x_y' for reveal // And maybe 'f_x_y' for flagging (if we add a flag mode button later) // For now, just reveal: return 'r_' . $x . '_' . $y; // Alternative: If we want flag toggle on click: // return $this->flags[$y][$x] ? 'f_' . $x . '_' . $y : 'r_' . $x . '_' . $y; // Click flagged = unflag, click unflagged = reveal? Confusing. // Let's use r_x_y for reveal, and require a separate mechanism/button for flagging. // return 'r_' . $x . '_' . $y; } /** * Generates a simple text representation of the board (for debugging or simple clients). * * @param bool $showMines Whether to reveal mine locations. * @return string */ public function renderBoardText(bool $showMines = false): string { $output = "Mines: {$this->mineCount} | Flags: {$this->flagCount}\n"; $output .= "\n"; // Use code block for fixed-width font // Add column headers $output .= ' '; for ($x = 0; $x < $this->width; $x++) { $output .= ' ' . chr(65 + $x); // A, B, C... } $output .= "\n"; for ($y = 0; $y < $this->height; $y++) { $output .= str_pad($y + 1, 2, ' ', STR_PAD_LEFT); // Row numbers for ($x = 0; $x < $this->width; $x++) { $output .= ' ' . $this->getCellTextRepresentation($x, $y, $showMines || ($this->gameOver && !$this->won)); } $output .= "\n"; } $output .= "\n"; return $output; } // __sleep and __wakeup are needed for serialization if you have resources (not needed here) public function __serialize(): array { return [ 'width' => $this->width, 'height' => $this->height, 'mineCount' => $this->mineCount, 'board' => $this->board, 'revealed' => $this->revealed, 'flags' => $this->flags, 'minesPlaced' => $this->minesPlaced, 'gameOver' => $this->gameOver, 'won' => $this->won, 'revealedCount' => $this->revealedCount, 'flagCount' => $this->flagCount, ]; } public function __unserialize(array $data): void { $this->width = $data['width']; $this->height = $data['height']; $this->mineCount = $data['mineCount']; $this->board = $data['board']; $this->revealed = $data['revealed']; $this->flags = $data['flags']; $this->minesPlaced = $data['minesPlaced']; $this->gameOver = $data['gameOver']; $this->won = $data['won']; $this->revealedCount = $data['revealedCount']; $this->flagCount = $data['flagCount']; } } storage = $storage; } /** * Gets the storage key for a user's game. */ private function getUserGameKey(int $userId): string { return self::GAME_KEY_PREFIX . $userId; } /** * Loads a game for a specific user. * * @param int $userId The Telegram user ID. * @return Minesweeper|null The game instance or null if not found. */ public function getGame(int $userId): ?Minesweeper { $game = $this->storage->load($this->getUserGameKey($userId)); return ($game instanceof Minesweeper) ? $game : null; } /** * Starts a new game for a user, replacing any existing game. * * @param int $userId * @param int $width * @param int $height * @param int $mines * @return Minesweeper The newly created game instance. */ public function startGame(int $userId, int $width, int $height, int $mines): Minesweeper { // Validate dimensions (optional, Minesweeper constructor does it too) $width = max(3, min(12, $width)); // Example constraints $height = max(3, min(12, $height)); $mines = max(1, min($width * $height - 1, $mines)); $game = new Minesweeper($width, $height, $mines); $this->saveGame($userId, $game); return $game; } /** * Saves the current state of a user's game. * * @param int $userId * @param Minesweeper $game * @return bool True on success, false on failure. */ public function saveGame(int $userId, Minesweeper $game): bool { return $this->storage->save($this->getUserGameKey($userId), $game); } /** * Deletes a user's game state. * * @param int $userId * @return bool True on success, false on failure. */ public function deleteGame(int $userId): bool { return $this->storage->delete($this->getUserGameKey($userId)); } } getMessage()); die("Bot initialization failed."); } // --- Update Handling --- // Choose one method: Webhook or Long Polling // ** Method 1: Webhook ** // (Recommended for production) // 1. Set the webhook URL once (e.g., via browser or another script): // https://api.telegram.org/botYOUR_BOT_TOKEN/setWebhook?url=YOUR_HTTPS_WEBHOOK_URL/bot.php // 2. Ensure YOUR_HTTPS_WEBHOOK_URL points to this script and is accessible via HTTPS. /* $update = json_decode(file_get_contents('php://input'), true); if (!$update) { // No update received (or invalid JSON) exit; } processUpdate($update, $telegram, $gameManager); */ // ** Method 2: Long Polling ** // (Simpler for development, less efficient) // Run this script periodically (e.g., via cron or keep-alive process) $offsetFile = $dataDir . '/update_offset.txt'; $offset = file_exists($offsetFile) ? (int)file_get_contents($offsetFile) : 0; echo "Starting long polling with offset: $offset\n"; // Log start while (true) { // Keep polling $updates = $telegram->getUpdates($offset, 100, 60); // 60-second timeout if ($updates === false) { error_log("Failed to get updates from Telegram."); sleep(10); // Wait before retrying on error continue; } if (!empty($updates)) { foreach ($updates as $update) { $currentOffset = $update['update_id'] + 1; echo "Processing update ID: " . $update['update_id'] . "\n"; // Log processing try { processUpdate($update, $telegram, $gameManager); $offset = $currentOffset; // Update offset only after successful processing file_put_contents($offsetFile, $offset); // Persist offset } catch (Exception $e) { error_log("Error processing update {$update['update_id']}: " . $e->getMessage() . "\n" . $e->getTraceAsString()); // Decide if you want to retry or skip the update // For now, we continue polling from the next offset to avoid getting stuck $offset = $currentOffset; file_put_contents($offsetFile, $offset); } } } else { echo "No updates received.\n"; // Log empty poll } // Optional: Add a small delay between polls if desired, though long polling timeout handles waiting // sleep(1); } // End while(true) for polling // --- Update Processing Logic --- /** * Processes a single update from Telegram. * * @param array $update The update data. * @param TelegramApi $telegram API wrapper instance. * @param GameManager $gameManager Game manager instance. */ function processUpdate(array $update, TelegramApi $telegram, GameManager $gameManager): void { $message = $update['message'] ?? null; $callbackQuery = $update['callback_query'] ?? null; $chatId = $message['chat']['id'] ?? $callbackQuery['message']['chat']['id'] ?? null; $userId = $message['from']['id'] ?? $callbackQuery['from']['id'] ?? null; if (!$chatId || !$userId) { error_log("Could not determine chat ID or user ID from update: " . json_encode($update)); return; } // Handle Callback Queries (Inline Button Presses) if ($callbackQuery) { handleCallbackQuery($callbackQuery, $telegram, $gameManager, $chatId, $userId); return; } // Handle Messages if ($message && isset($message['text'])) { handleMessage($message, $telegram, $gameManager, $chatId, $userId); return; } } /** * Handles incoming text messages. */ function handleMessage(array $message, TelegramApi $telegram, GameManager $gameManager, int $chatId, int $userId): void { $text = $message['text']; $parts = explode(' ', trim($text)); $command = strtolower(array_shift($parts)); switch ($command) { case '/start': case '/help': $helpText = "Welcome to Minesweeper Bot!\n\n"; $helpText .= "Commands:\n"; $helpText .= "/newgame [w h m] - Start a new game (e.g., /newgame 8 8 10). Defaults to 8x8 with 10 mines.\n"; $helpText .= "/board - Show your current game board.\n"; $helpText .= "/flag - Toggle a flag at coordinates (e.g., /flag 3 4). Use 1-based indexing.\n"; $helpText .= "/quit - Quit your current game.\n"; $helpText .= "/help - Show this help message.\n\n"; $helpText .= "Click on the squares to reveal them. Be careful not to hit a mine! 💣"; $telegram->sendMessage($chatId, $helpText); break; case '/newgame': $width = (int)($parts[0] ?? 8); $height = (int)($parts[1] ?? $parts[0] ?? 8); // Default height to width if only one arg $mines = (int)($parts[2] ?? $parts[1] ?? 10); // Default mines // Basic validation $width = max(3, min(12, $width)); $height = max(3, min(12, $height)); $mines = max(1, min($width * $height - 1, $mines)); try { $game = $gameManager->startGame($userId, $width, $height, $mines); $messageText = "New game started ({$width}x{$height}, {$mines} mines). Good luck!"; $replyMarkup = $game->generateInlineKeyboard(); $telegram->sendMessage($chatId, $messageText, $replyMarkup); } catch (Exception $e) { $telegram->sendMessage($chatId, "Error starting game: " . $e->getMessage()); error_log("Error in /newgame for user {$userId}: " . $e->getMessage()); } break; case '/board': $game = $gameManager->getGame($userId); if ($game) { $status = getGameStatusText($game); $replyMarkup = $game->generateInlineKeyboard(); $telegram->sendMessage($chatId, $status, $replyMarkup); } else { $telegram->sendMessage($chatId, "You don't have an active game. Start one with /newgame."); } break; case '/flag': if (count($parts) === 2 && ctype_digit($parts[0]) && ctype_digit($parts[1])) { // Input is 1-based, convert to 0-based for internal use $x = (int)$parts[0] - 1; $y = (int)$parts[1] - 1; $game = $gameManager->getGame($userId); if (!$game) { $telegram->sendMessage($chatId, "No active game found. Start with /newgame."); return; } if ($game->isGameOver()) { $telegram->sendMessage($chatId, "The game is over. Start a new one with /newgame."); return; } if ($game->toggleFlag($x, $y)) { $gameManager->saveGame($userId, $game); $status = getGameStatusText($game); $replyMarkup = $game->generateInlineKeyboard(); // Edit the previous message if possible, otherwise send new // For simplicity here, just send a new message with the updated board $telegram->sendMessage($chatId, $status, $replyMarkup); } else { $telegram->sendMessage($chatId, "Cannot toggle flag at ({$parts[0]}, {$parts[1]}). Invalid coordinates or cell already revealed?"); } } else { $telegram->sendMessage($chatId, "Usage: /flag (e.g., /flag 3 4). Use 1-based coordinates shown on board."); } break; case '/quit': if ($gameManager->deleteGame($userId)) { $telegram->sendMessage($chatId, "Your current game has been quit."); } else { $telegram->sendMessage($chatId, "You don't have an active game to quit."); } break; default: // Optional: Respond to unknown commands or ignore // $telegram->sendMessage($chatId, "Unknown command. Use /help to see available commands."); break; } } /** * Handles callback queries from inline keyboard buttons. */ function handleCallbackQuery(array $callbackQuery, TelegramApi $telegram, GameManager $gameManager, int $chatId, int $userId): void { $callbackId = $callbackQuery['id']; $data = $callbackQuery['data'] ?? null; $message = $callbackQuery['message'] ?? null; $messageId = $message['message_id'] ?? null; if (!$data || !$messageId) { $telegram->answerCallbackQuery($callbackId, "Error: Invalid callback data.", true); error_log("Invalid callback query for user {$userId}: " . json_encode($callbackQuery)); return; } // Parse callback data (expecting "action_x_y" e.g., "r_3_4") $parts = explode('_', $data); $action = $parts[0] ?? null; $x = isset($parts[1]) ? (int)$parts[1] : -1; $y = isset($parts[2]) ? (int)$parts[2] : -1; if ($action === 'noop') { $telegram->answerCallbackQuery($callbackId); // Acknowledge, do nothing return; } if (($action !== 'r' && $action !== 'f') || $x < 0 || $y < 0) { $telegram->answerCallbackQuery($callbackId, "Error: Invalid action.", true); error_log("Invalid callback action/coords for user {$userId}: {$data}"); return; } $game = $gameManager->getGame($userId); if (!$game) { $telegram->answerCallbackQuery($callbackId, "Game not found. Maybe it ended? Start a new one with /newgame.", true); $telegram->editMessageText($chatId, $messageId, "Game not found or has ended."); // Clear the board return; } if ($game->isGameOver()) { $telegram->answerCallbackQuery($callbackId, "This game is already over!", false); return; } $stateChanged = false; $alertText = null; try { if ($action === 'r') { // Reveal $stateChanged = $game->reveal($x, $y); if (!$stateChanged && !$game->isGameOver()) { // If reveal didn't change state (e.g. clicking revealed/flagged cell) $alertText = $game->flags[$y][$x] ? "Cell is flagged 🚩" : "Cell already revealed"; } } // Add handling for 'f' (flag) action if a flag mode button is implemented // elseif ($action === 'f') { // $stateChanged = $game->toggleFlag($x, $y); // } } catch (Exception $e) { $telegram->answerCallbackQuery($callbackId, "An error occurred.", true); error_log("Error processing callback action {$data} for user {$userId}: " . $e->getMessage()); return; } if ($stateChanged) { $gameManager->saveGame($userId, $game); $status = getGameStatusText($game); $replyMarkup = $game->generateInlineKeyboard(); // Regenerate keyboard based on new state // Edit the original message with the updated board $result = $telegram->editMessageText($chatId, $messageId, $status, $replyMarkup); if ($result === false) { // Log error, maybe message wasn't modified or other issue error_log("Failed to edit message {$messageId} for user {$userId}"); // Optionally send a new message as fallback, but could be spammy // $telegram->sendMessage($chatId, $status, $replyMarkup); } // Check for game over / win after state change if ($game->isGameOver()) { $endMessage = $game->isWon() ? "🎉 Congratulations! You won! 🎉" : "💥 BOOM! Game Over! 💥"; $telegram->answerCallbackQuery($callbackId, $endMessage, false); // Show win/loss in notification // Optionally delete the game state after win/loss shown // $gameManager->deleteGame($userId); } else { $telegram->answerCallbackQuery($callbackId); // Acknowledge successful move } } else { // Acknowledge the button press, optionally show why nothing happened $telegram->answerCallbackQuery($callbackId, $alertText); } } /** * Generates status text based on game state. */ function getGameStatusText(Minesweeper $game): string { if ($game->isGameOver()) { return $game->isWon() ? "🎉 You won! 🎉 ({$game->width}x{$game->height}, {$game->mineCount} mines)" : "💥 Game Over! 💥 ({$game->width}x{$game->height}, {$game->mineCount} mines)"; } else { return "Mines: {$game->mineCount} | Flags: {$game->getFlagCount()} | Board: {$game->width}x{$game->height}"; } } ?> # Ignore data files and sensitive config /data/ /config.php *.log # Ignore Composer dependencies (if used later) /vendor/ composer.lock