QT写出一个2048

好的，下面是实现 2048 游戏的大体思路：

1.界面设计：2048 游戏界面一般是一个 4x4 的矩阵，每个格子上会有一个数值，我们可以通过继承 QWidget 类来自定义一个小部件，然后在小部件中绘制游戏界面。

2.游戏逻辑：2048 游戏的核心逻辑就是将相同数值的格子合并，最终得到一个数值为 2048 的格子。我们可以通过维护一个 4x4 的二维数组来表示游戏界面，然后在每次移动格子时，根据当前游戏状态对数组进行更新，最后再更新界面。

3.用户交互：我们需要通过键盘事件来实现用户对游戏的控制，比如向上、向下、向左、向右移动格子。同时，也需要在游戏结束时弹出一个对话框提示用户游戏结束。

下面是一个简单的实现示例，你可以参考它来编写自己的 2048 游戏：

#include <QWidget>
#include <QKeyEvent>
#include <QPainter>
#include <QMessageBox>

class Game2048 : public QWidget
{
public:
    Game2048(QWidget *parent = nullptr) : QWidget(parent)
    {
        setFixedSize(400, 400);
        reset();
    }

protected:
    void paintEvent(QPaintEvent *event) override
    {
        QPainter painter(this);
        painter.setRenderHint(QPainter::Antialiasing, true);
        painter.fillRect(rect(), QBrush(QColor(187, 173, 160)));

        for (int i = 0; i < 4; ++i) {
            for (int j = 0; j < 4; ++j) {
                drawTile(painter, i, j);
            }
        }
    }

    void keyPressEvent(QKeyEvent *event) override
    {
        bool moved = false;

        switch (event->key()) {
        case Qt::Key_Up:
            moved = moveTiles(-1, 0);
            break;
        case Qt::Key_Down:
            moved = moveTiles(1, 0);
            break;
        case Qt::Key_Left:
            moved = moveTiles(0, -1);
            break;
        case Qt::Key_Right:
            moved = moveTiles(0, 1);
            break;
        default:
            break;
        }

        if (moved) {
            spawnTile();
            update();
        }

        if (checkGameOver()) {
            QMessageBox::information(this, "Game Over", "Game Over!");
            reset();
            update();
        }
    }

private:
    void reset()
    {
        for (int i = 0; i < 4; ++i) {
            for (int j = 0; j < 4; ++j) {
                m_tiles[i][j] = 0;
            }
        }

        spawnTile();
        spawnTile();
    }

    void spawnTile()
    {
        QList<QPoint> emptyTiles;

        for (int i = 0; i < 4; ++i) {
            for (int j = 0; j < 4; ++j) {
                if (m_tiles[i][j] == 0) {
                    emptyTiles.append(QPoint(i, j));
                }
            }
        }

        if (emptyTiles.isEmpty()) {
            return;
        }

        QPoint pos = emptyTiles[qrand() % emptyTiles.size()];
        m_tiles[pos.x()][pos.y()] = qrand() % 2 ? 2 : 4;
    }

    bool moveTiles(int dx, int dy)
    {
        bool moved = false;

        for (int i = 0; i < 4; ++i) {
            for (int j = 0; j < 4; ++j) {
                int ni = i + dx;
                int nj = j + dy;

                while (ni >= 0 && ni < 4 && nj >= 0 && nj < 4) {
                    if (m_tiles[ni][nj] == 0) {
                        m_tiles[ni][nj] = m_tiles[ni - dx][nj - dy];
                        m_tiles[ni - dx][nj - dy] = 0;
                        ni += dx;
                        nj += dy;
                        moved = true;
                    } else if (m_tiles[ni][nj] == m_tiles[ni - dx][nj - dy]) {
                        m_tiles[ni][nj] *= 2;
                        m_tiles[ni - dx][nj - dy] = 0;
                        moved = true;
                        break;
                    } else {
                        break;
                    }
                }
            }
        }

        return moved;
    }

    bool checkGameOver()
    {
        for (int i = 0; i < 4; ++i) {
            for (int j = 0; j < 4; ++j) {
                if (m_tiles[i][j] == 0) {
                    return false;
                }

                if (i > 0 && m_tiles[i][j] == m_tiles[i - 1][j]) {
                    return false;
                }

                if (i < 3 && m_tiles[i][j] == m_tiles[i + 1][j]) {
                    return false;
                }

                if (j > 0 && m_tiles[i][j] == m_tiles[i][j - 1]) {
                    return false;
                }

                if (j < 3 && m_tiles[i][j] == m_tiles[i][j + 1]) {
                    return false;
                }
            }
        }

        return true;
    }

    void drawTile(QPainter &painter, int i, int j)
    {
        painter.save();

        int x = 20 + j * 90;
        int y = 20 + i * 90;
        int value = m_tiles[i][j];

        painter.setPen(Qt::NoPen);
        painter.setBrush(tileColor(value));
        painter.drawRect(x, y, 80, 80);

        if (value > 0) {
            painter.setPen(value < 8 ? Qt::black : Qt::white);
            QFont font("Arial", 32, QFont::Bold);
            painter.setFont(font);
            painter.drawText(x, y, 80, 80, Qt::AlignCenter, QString::number(value));
        }

        painter.restore();
    }

    QColor tileColor(int value)
    {
        switch (value) {
        case 2:
            return QColor(238, 228, 218);
        case 4:
            return QColor(237, 224, 200);
        case 8:
            return QColor(242, 177, 121);
        case 16:
            return QColor(245, 149, 99);
        case 32:
            return QColor(246, 124, 95);
        case 64:
            return QColor(246, 94, 59);
        case 128:
            return QColor(237, 207, 114);
        case 256:
            return QColor(237, 204, 97);
        case 512:
            return QColor(237, 200, 80);
        case 1024:
            return QColor(237, 197, 63);
        case 2048:
            return QColor(237, 194, 46);
        default:
            return QColor(205, 193, 180);
        }
    }

    int m_tiles[4][4];
};