Skip to content
TheChatArchiveThe Chat Archive
o1-mini-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

Реализовать игру "Пятнашки". Суть игры заключается в следующем: в игровом поле размером…

  1. User

    Реализовать игру "Пятнашки". Суть игры заключается в следующем: в игровом поле размером 4х4 клетки случайным образом размещается 15 пронумерованных фишек. Одна клетка, выбор которой также случайный, остается свободной. Передвигая фишки, необходимо добиться упорядоченности их расположения (от 1 до 15).

    Также нужно создать таймер, сохранение результата в файл и времени с таймера, сделать цветные плитки пятнашек и текст на них, поменять шрифт цифр на Verdana. И при этом программа не должна ломаться, если меняется размер окна: пользователь может растягивать его как хочет, но элементы должны адаптироваться (уменьшаться/увеличиваться). Пиши программу на С++ с использованием winapi. Не используй библиотеку vector, algorithm и map. Используй using namespace std; Пиши код полностью.

  2. Assistant
    // FifteenPuzzle.cpp
    // Compile with: cl /EHsc FifteenPuzzle.cpp user32.lib gdi32.lib
    
    #include <windows.h>
    #include <ctime>
    #include <cstring>
    #include <fstream>
    
    using namespace std;
    
    // Constants
    const int GRID_SIZE = 4;
    const int TILE_COUNT = GRID_SIZE * GRID_SIZE;
    const int TIMER_ID = 1;
    const int TIMER_INTERVAL = 1000; // 1 second
    
    // Global Variables
    HINSTANCE hInst;
    HWND hMainWnd;
    HFONT hFont;
    int board[TILE_COUNT];
    int emptyPos = TILE_COUNT - 1;
    bool gameWon = false;
    int elapsedSeconds = 0;
    
    // Function Declarations
    LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
    void InitializeBoard();
    void ShuffleBoard();
    bool IsSolvable(int arr[], int n);
    bool CheckWin();
    void MoveTile(int pos);
    void SaveResult();
    void DrawBoard(HDC hdc, RECT clientRect);
    int GetTileAtPosition(int x, int y, RECT clientRect);
    
    // WinMain: Entry point
    int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
        LPSTR lpCmdLine, int nCmdShow)
    {
        hInst = hInstance;
    
        // Register Window Class
        WNDCLASSEX wc = { sizeof(WNDCLASSEX) };
        wc.style = CS_HREDRAW | CS_VREDRAW;
        wc.lpfnWndProc = WndProc;
        wc.hInstance = hInst;
        wc.hCursor = LoadCursor(NULL, IDC_ARROW);
        wc.lpszClassName = "FifteenPuzzleClass";
    
        RegisterClassEx(&wc);
    
        // Create Window
        hMainWnd = CreateWindowEx(0, "FifteenPuzzleClass", "Пятнашки",
            WS_OVERLAPPEDWINDOW,
            CW_USEDEFAULT, CW_USEDEFAULT, 500, 500,
            NULL, NULL, hInst, NULL);
    
        ShowWindow(hMainWnd, nCmdShow);
        UpdateWindow(hMainWnd);
    
        // Main Message Loop
        MSG msg;
        while (GetMessage(&msg, NULL, 0, 0))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
        return (int)msg.wParam;
    }
    
    // Initialize the board to the solved state
    void InitializeBoard()
    {
        for (int i = 0; i < TILE_COUNT; ++i)
        {
            board[i] = i;
        }
        emptyPos = TILE_COUNT - 1;
        gameWon = false;
        elapsedSeconds = 0;
    }
    
    // Shuffle the board by making random valid moves
    void ShuffleBoard()
    {
        srand((unsigned)time(NULL));
        int lastMove = -1;
        int shuffleMoves = 1000; // Number of random moves
    
        for (int i = 0; i < shuffleMoves; ++i)
        {
            // Find possible moves
            int row = emptyPos / GRID_SIZE;
            int col = emptyPos % GRID_SIZE;
            int possibleMoves[4];
            int moveCount = 0;
    
            // Up
            if (row > 0 && lastMove != 2)
                possibleMoves[moveCount++] = emptyPos - GRID_SIZE;
            // Down
            if (row < GRID_SIZE - 1 && lastMove != 0)
                possibleMoves[moveCount++] = emptyPos + GRID_SIZE;
            // Left
            if (col > 0 && lastMove != 3)
                possibleMoves[moveCount++] = emptyPos - 1;
            // Right
            if (col < GRID_SIZE - 1 && lastMove != 1)
                possibleMoves[moveCount++] = emptyPos + 1;
    
            if (moveCount == 0)
                continue;
    
            // Choose a random move
            int move = possibleMoves[rand() % moveCount];
            // Move the tile
            board[emptyPos] = board[move];
            board[move] = TILE_COUNT - 1;
            emptyPos = move;
            lastMove = -1; // To allow reversing
        }
    }
    
    // Check if the current board is in a winning state
    bool CheckWin()
    {
        for (int i = 0; i < TILE_COUNT - 1; ++i)
        {
            if (board[i] != i)
                return false;
        }
        return true;
    }
    
    // Move tile at position pos if adjacent to empty
    void MoveTile(int pos)
    {
        // Check if pos is adjacent to emptyPos
        int row1 = pos / GRID_SIZE;
        int col1 = pos % GRID_SIZE;
        int row2 = emptyPos / GRID_SIZE;
        int col2 = emptyPos % GRID_SIZE;
    
        if ((abs(row1 - row2) == 1 && col1 == col2) ||
            (abs(col1 - col2) == 1 && row1 == row2))
        {
            board[emptyPos] = board[pos];
            board[pos] = TILE_COUNT - 1;
            emptyPos = pos;
    
            if (CheckWin())
            {
                gameWon = true;
                KillTimer(hMainWnd, TIMER_ID);
                SaveResult();
                MessageBox(hMainWnd, "Поздравляем! Вы решили головоломку.", "Победа", MB_OK);
            }
            InvalidateRect(hMainWnd, NULL, TRUE);
        }
    }
    
    // Save the result to a file
    void SaveResult()
    {
        ofstream outFile("results.txt", ios::app);
        if (outFile.is_open())
        {
            SYSTEMTIME st;
            GetLocalTime(&st);
            char buffer[100];
            sprintf(buffer, "Победа в %d секунд. Время: %02d:%02d:%02d\n",
                elapsedSeconds, st.wHour, st.wMinute, st.wSecond);
            outFile << buffer;
            outFile.close();
        }
    }
    
    // Get the tile index at mouse position
    int GetTileAtPosition(int x, int y, RECT clientRect)
    {
        int width = clientRect.right - clientRect.left;
        int height = clientRect.bottom - clientRect.top;
        int tileWidth = width / GRID_SIZE;
        int tileHeight = height / GRID_SIZE;
    
        int col = x / tileWidth;
        int row = y / tileHeight;
    
        if (col >= GRID_SIZE) col = GRID_SIZE - 1;
        if (row >= GRID_SIZE) row = GRID_SIZE - 1;
    
        return row * GRID_SIZE + col;
    }
    
    // Draw the board
    void DrawBoard(HDC hdc, RECT clientRect)
    {
        int width = clientRect.right - clientRect.left;
        int height = clientRect.bottom - clientRect.top;
        int tileWidth = width / GRID_SIZE;
        int tileHeight = height / GRID_SIZE;
    
        HBRUSH hBrush;
        RECT tileRect;
    
        for (int i = 0; i < TILE_COUNT; ++i)
        {
            int row = i / GRID_SIZE;
            int col = i % GRID_SIZE;
            tileRect.left = col * tileWidth;
            tileRect.top = row * tileHeight;
            tileRect.right = (col + 1) * tileWidth;
            tileRect.bottom = (row + 1) * tileHeight;
    
            if (board[i] != TILE_COUNT - 1)
            {
                // Set different colors for tiles
                switch (board[i] % 5)
                {
                case 0:
                    hBrush = CreateSolidBrush(RGB(255, 100, 100));
                    break;
                case 1:
                    hBrush = CreateSolidBrush(RGB(100, 255, 100));
                    break;
                case 2:
                    hBrush = CreateSolidBrush(RGB(100, 100, 255));
                    break;
                case 3:
                    hBrush = CreateSolidBrush(RGB(255, 255, 100));
                    break;
                case 4:
                    hBrush = CreateSolidBrush(RGB(255, 100, 255));
                    break;
                default:
                    hBrush = CreateSolidBrush(RGB(200, 200, 200));
                    break;
                }
    
                FillRect(hdc, &tileRect, hBrush);
                DeleteObject(hBrush);
    
                // Draw the number
                char numStr[3];
                sprintf(numStr, "%d", board[i] + 1);
                SetBkMode(hdc, TRANSPARENT);
                SetTextColor(hdc, RGB(0, 0, 0));
                DrawText(hdc, numStr, -1, &tileRect, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
            }
            else
            {
                // Draw empty cell
                FillRect(hdc, &tileRect, (HBRUSH)GetStockObject(WHITE_BRUSH));
            }
    
            // Draw grid lines
            HPEN hPen = CreatePen(PS_SOLID, 2, RGB(0, 0, 0));
            HPEN hOldPen = (HPEN)SelectObject(hdc, hPen);
            MoveToEx(hdc, tileRect.left, tileRect.top, NULL);
            LineTo(hdc, tileRect.right, tileRect.top);
            LineTo(hdc, tileRect.right, tileRect.bottom);
            LineTo(hdc, tileRect.left, tileRect.bottom);
            LineTo(hdc, tileRect.left, tileRect.top);
            SelectObject(hdc, hOldPen);
            DeleteObject(hPen);
        }
    
        // Draw Timer
        char timeStr[50];
        sprintf(timeStr, "Время: %d:%02d:%02d", elapsedSeconds / 3600, (elapsedSeconds / 60) % 60, elapsedSeconds % 60);
        SetTextColor(hdc, RGB(0, 0, 0));
        DrawText(hdc, timeStr, -1, &clientRect, DT_TOP | DT_RIGHT | DT_SINGLELINE | DT_NOPREFIX);
    }
    
    // Window Procedure
    LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
    {
        switch (message)
        {
        case WM_CREATE:
        {
            // Initialize Font
            LOGFONT lf;
            memset(&lf, 0, sizeof(LOGFONT));
            lf.lfHeight = 24;
            strcpy(lf.lfFaceName, "Verdana");
            hFont = CreateFontIndirect(&lf);
    
            // Initialize Board
            InitializeBoard();
            ShuffleBoard();
    
            // Set Timer
            SetTimer(hwnd, TIMER_ID, TIMER_INTERVAL, NULL);
        }
        break;
        case WM_TIMER:
        {
            if (wParam == TIMER_ID && !gameWon)
            {
                elapsedSeconds++;
                InvalidateRect(hwnd, NULL, TRUE);
            }
        }
        break;
        case WM_LBUTTONDOWN:
        {
            if (gameWon)
                break;
    
            int xPos = GET_X_LPARAM(lParam);
            int yPos = GET_Y_LPARAM(lParam);
            RECT clientRect;
            GetClientRect(hwnd, &clientRect);
            int pos = GetTileAtPosition(xPos, yPos, clientRect);
            MoveTile(pos);
        }
        break;
        case WM_PAINT:
        {
            PAINTSTRUCT ps;
            HDC hdc = BeginPaint(hwnd, &ps);
    
            // Select Font
            HFONT hOldFont = (HFONT)SelectObject(hdc, hFont);
    
            // Draw the board
            RECT clientRect;
            GetClientRect(hwnd, &clientRect);
            DrawBoard(hdc, clientRect);
    
            // Restore Font
            SelectObject(hdc, hOldFont);
    
            EndPaint(hwnd, &ps);
        }
        break;
        case WM_SIZE:
        {
            InvalidateRect(hwnd, NULL, TRUE);
        }
        break;
        case WM_DESTROY:
        {
            DeleteObject(hFont);
            PostQuitMessage(0);
        }
        break;
        default:
            return DefWindowProc(hwnd, message, wParam, lParam);
        }
        return 0;
    }
    

    Объяснение кода:

    1. Инициализация окна и глобальных переменных:

      • Создается главное окно приложения с использованием WinAPI.
      • Глобальный массив board представляет игровое поле 4x4, где board[i] содержит номер фишки или 15 для пустой клетки.
      • Переменная emptyPos хранит индекс пустой клетки.
      • Переменные gameWon и elapsedSeconds управляют состоянием игры и отсчетом времени.
    2. Функция InitializeBoard:

      • Инициализирует игровое поле в выигрышном состоянии, где фишки расположены по порядку от 0 до 14, а 15 - пустая клетка.
    3. Функция ShuffleBoard:

      • Перемешивает фишки путем выполнения случайных допустимых ходов из начального состояния.
      • Это гарантирует, что перемешанная конфигурация разрешима.
    4. Функция CheckWin:

      • Проверяет, расположены ли фишки в выигрышном порядке.
    5. Функция MoveTile:

      • Перемещает фишку, если она соседствует с пустой клеткой.
      • После перемещения проверяет, достигнуто ли состояние выигрыша, останавливает таймер и сохраняет результат.
    6. Функция SaveResult:

      • Сохраняет время достижения победы в файл results.txt вместе с текущим временем системы.
    7. Функция GetTileAtPosition:

      • Определяет, какую фишку пользователь кликнул на основе координат мыши и размера окна.
    8. Функция DrawBoard:

      • Рисует текущее состояние игрового поля.
      • Каждая фишка имеет свой цвет и отображает свой номер с использованием шрифта Verdana.
      • Также рисуется таймер в правом верхнем углу.
    9. Процедура окна WndProc:

      • Обрабатывает различные сообщения окна:
        • WM_CREATE: Инициализирует шрифт, игровое поле и устанавливает таймер.
        • WM_TIMER: Обновляет таймер каждую секунду, пока игра не выиграна.
        • WM_LBUTTONDOWN: Обрабатывает клики мыши для перемещения фишек.
        • WM_PAINT: Рисует игровое поле.
        • WM_SIZE: Обрабатывает изменение размера окна и перерисовывает элементы.
        • WM_DESTROY: Освобождает ресурсы и завершает приложение.
    10. Шрифт и видимость:

      • Используется шрифт Verdana для отображения номеров фишек.
      • Фишки имеют различные цвета для лучшей визуализации.
    11. Адаптивный интерфейс:

      • Размер фишек рассчитывается динамически на основе текущего размера окна, что позволяет пользователю изменять размер окна без нарушения интерфейса.
    12. Компиляция:

      • Код можно скомпилировать с помощью компилятора cl (Microsoft C++ Compiler) с подключением библиотек user32.lib и gdi32.lib.

    Примечания:

    • Код не использует библиотеки vector, algorithm или map, как было указано в задании.
    • Все случайные перемешивания гарантируют разрешимость пазла.
    • Результаты сохраняются в текстовом файле results.txt в той же директории, что и исполняемый файл.
    • Приложение устойчиво к изменению размера окна благодаря динамическому расчету размеров фишек и перерисовке элементов интерфейса.