用qt写一个俄罗斯方块，要提供代码

我很高兴为您提供代码。下面是用Qt写俄罗斯方块的代码：#include <QApplication>
#include <QGraphicsScene>
#include <QGraphicsView>
#include <QGraphicsRectItem>
#include <QTimer>int main(int argc, char *argv[])
{
QApplication a(argc, argv); // 创建场景
QGraphicsScene * scene = new QGraphicsScene(); // 创建矩形
QGraphicsRectItem * rect = new QGraphicsRectItem();
rect->setRect(0,0,100,100); // 把矩形放到场景中
scene->addItem(rect); // 创建视图
QGraphicsView * view = new QGraphicsView(scene);
view->show(); QTimer * timer = new QTimer();
QObject::connect(timer, SIGNAL(timeout()), scene, SLOT(advance()));
timer->start(100); return a.exec();
}

相关问题

帮我写一个俄罗斯方块的qt代码，并且运行

好的，以下是一个简单的俄罗斯方块游戏的Qt代码：

#include <QApplication>
#include <QWidget>
#include <QGridLayout>
#include <QLabel>
#include <QKeyEvent>
#include <QTimer>

class Tetris : public QWidget {
public:
    Tetris(QWidget *parent = 0);

protected:
    void keyPressEvent(QKeyEvent *event) override;
    void timerEvent(QTimerEvent *event) override;
    void paintEvent(QPaintEvent *event) override;

private:
    enum { BoardWidth = 10, BoardHeight = 22 };

    int timerId;
    int board[BoardWidth * BoardHeight];
    QLabel *labels[BoardWidth * BoardHeight];

    const int shapes[7][4][2] = {
        {{0, 1}, {1, 1}, {2, 1}, {3, 1}}, // I
        {{0, 0}, {0, 1}, {1, 1}, {1, 0}}, // O
        {{0, 0}, {0, 1}, {1, 1}, {2, 1}}, // L
        {{2, 0}, {0, 1}, {1, 1}, {2, 1}}, // J
        {{1, 0}, {2, 0}, {0, 1}, {1, 1}}, // S
        {{0, 0}, {1, 0}, {1, 1}, {2, 1}}, // Z
        {{1, 0}, {0, 1}, {1, 1}, {2, 1}}  // T
    };
    int curX, curY;
    int curShape;

    void clearBoard();
    void dropDown();
    void oneLineDown();
    bool tryMove(int newX, int newY, int newShape);
    void drawSquare(QPainter &painter, int x, int y, int shape);
};

Tetris::Tetris(QWidget *parent)
    : QWidget(parent),
      timerId(-1),
      curX(0),
      curY(0),
      curShape(0)
{
    QGridLayout *layout = new QGridLayout;
    for (int i = 0; i < BoardHeight; ++i) {
        for (int j = 0; j < BoardWidth; ++j) {
            labels[i * BoardWidth + j] = new QLabel;
            labels[i * BoardWidth + j]->setFixedSize(20, 20);
            labels[i * BoardWidth + j]->setFrameStyle(QFrame::Panel | QFrame::Sunken);
            layout->addWidget(labels[i * BoardWidth + j], i, j);
            board[i * BoardWidth + j] = 0;
        }
    }
    setLayout(layout);

    clearBoard();
    setFocusPolicy(Qt::StrongFocus);
    resize(200, 400);

    timerId = startTimer(300);
}

void Tetris::keyPressEvent(QKeyEvent *event)
{
    if (event->key() == Qt::Key_Left)
        tryMove(curX - 1, curY, curShape);
    else if (event->key() == Qt::Key_Right)
        tryMove(curX + 1, curY, curShape);
    else if (event->key() == Qt::Key_Down)
        tryMove(curX, curY + 1, curShape);
    else if (event->key() == Qt::Key_Up)
        tryMove(curX, curY, (curShape + 1) % 7);
    else
        QWidget::keyPressEvent(event);
}

void Tetris::timerEvent(QTimerEvent *event)
{
    if (event->timerId() == timerId) {
        if (!tryMove(curX, curY + 1, curShape)) {
            dropDown();
        }
    } else {
        QWidget::timerEvent(event);
    }
}

void Tetris::paintEvent(QPaintEvent *event)
{
    QPainter painter(this);
    QRect rect = event->rect();

    for (int i = 0; i < BoardHeight; ++i) {
        for (int j = 0; j < BoardWidth; ++j) {
            if (board[i * BoardWidth + j] != 0) {
                drawSquare(painter, rect.left() + j * 20,
                           rect.top() + i * 20, board[i * BoardWidth + j]);
            }
        }
    }

    for (int i = 0; i < 4; i++) {
        int x = curX + shapes[curShape][i][0];
        int y = curY + shapes[curShape][i][1];
        drawSquare(painter, rect.left() + x * 20,
                   rect.top() + y * 20, curShape + 1);
    }
}

void Tetris::clearBoard()
{
    for (int i = 0; i < BoardWidth * BoardHeight; ++i) {
        board[i] = 0;
    }
}

void Tetris::dropDown()
{
    for (int i = 0; i < 4; i++) {
        int x = curX + shapes[curShape][i][0];
        int y = curY + shapes[curShape][i][1];
        board[y * BoardWidth + x] = curShape + 1;
    }

    int fullRows[BoardHeight];
    int numFullRows = 0;

    for (int i = BoardHeight - 1; i >= 0; --i) {
        bool rowIsFull = true;

        for (int j = 0; j < BoardWidth; ++j) {
            if (board[i * BoardWidth + j] == 0) {
                rowIsFull = false;
                break;
            }
        }

        if (rowIsFull) {
            fullRows[numFullRows++] = i;
        }
    }

    for (int i = 0; i < numFullRows; ++i) {
        int row = fullRows[i];
        for (int j = 0; j < BoardWidth; ++j) {
            for (int k = row; k < BoardHeight - 1; ++k) {
                board[k * BoardWidth + j] = board[(k + 1) * BoardWidth + j];
            }
            board[(BoardHeight - 1) * BoardWidth + j] = 0;
        }
    }

    curX = BoardWidth / 2;
    curY = 0;
    curShape = qrand() % 7;

    if (!tryMove(curX, curY, curShape)) {
        killTimer(timerId);
        timerId = -1;
    }
}

void Tetris::oneLineDown()
{
    if (!tryMove(curX, curY + 1, curShape))
        dropDown();
}

bool Tetris::tryMove(int newX, int newY, int newShape)
{
    for (int i = 0; i < 4; i++) {
        int x = newX + shapes[newShape][i][0];
        int y = newY + shapes[newShape][i][1];

        if (x < 0 || x >= BoardWidth || y < 0 || y >= BoardHeight)
            return false;

        if (board[y * BoardWidth + x] != 0)
            return false;
    }

    curX = newX;
    curY = newY;
    curShape = newShape;

    update();

    return true;
}

void Tetris::drawSquare(QPainter &painter, int x, int y, int shape)
{
    static const QRgb colorTable[8] = {
        0x000000, 0xCC6666, 0x66CC66, 0x6666CC,
        0xCCCC66, 0xCC66CC, 0x66CCCC, 0xDAAA00
    };

    QColor color = colorTable[shape];
    painter.fillRect(x + 1, y + 1, 18, 18, color);
    painter.setPen(color.lighter());
    painter.drawLine(x, y + 19, x, y);
    painter.drawLine(x, y, x + 19, y);
    painter.setPen(color.darker());
    painter.drawLine(x + 1, y + 19, x + 19, y + 19);
    painter.drawLine(x + 19, y + 19, x + 19, y + 1);
}

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);

    Tetris window;
    window.show();

    return app.exec();
}

将上述代码保存为一个.cpp文件，然后在终端中使用以下命令编译运行：

qmake -project
qmake
make
./<YourFileName>

注意将上述命令中的`<YourFileName>`替换为您的文件名。如果您的Qt环境配置正确，应该可以成功编译并运行这个俄罗斯方块游戏。

用qt编写一个俄罗斯方块游戏

好的，下面是一个简单的俄罗斯方块游戏的Qt代码示例：

#include <QApplication>
#include <QWidget>
#include <QGridLayout>
#include <QLabel>
#include <QTimer>
#include <QKeyEvent>

const int ROWS = 20;
const int COLUMNS = 10;
const int SQUARE_SIZE = 30;

class Tetris : public QWidget {
public:
    Tetris(QWidget *parent = nullptr);

protected:
    void keyPressEvent(QKeyEvent *event) override;

private:
    QLabel *square[ROWS][COLUMNS];
    QTimer *timer;
    int board[ROWS][COLUMNS];
    int currentShape[4][4];
    int currentX;
    int currentY;
    int currentShapeIndex;
    int score;

    void initBoard();
    void initWindow();
    void initTimer();
    void newShape();
    void drawSquare(int row, int column, int shapeIndex);
    void undrawSquare(int row, int column);
    void updateBoard();
    bool isCollision(int x, int y, int shapeIndex);
    void rotateShape();
    void moveShape(int dx, int dy);
    void dropShape();
    void clearFullRows();
    void gameOver();
};

Tetris::Tetris(QWidget *parent)
    : QWidget(parent)
{
    initBoard();
    initWindow();
    initTimer();
    newShape();
}

void Tetris::keyPressEvent(QKeyEvent *event)
{
    switch (event->key()) {
    case Qt::Key_Left:
        moveShape(-1, 0);
        break;
    case Qt::Key_Right:
        moveShape(1, 0);
        break;
    case Qt::Key_Down:
        dropShape();
        break;
    case Qt::Key_Space:
        rotateShape();
        break;
    }
}

void Tetris::initBoard()
{
    for (int i = 0; i < ROWS; ++i) {
        for (int j = 0; j < COLUMNS; ++j) {
            board[i][j] = 0;
        }
    }
}

void Tetris::initWindow()
{
    QGridLayout *layout = new QGridLayout(this);
    for (int i = 0; i < ROWS; ++i) {
        for (int j = 0; j < COLUMNS; ++j) {
            square[i][j] = new QLabel(this);
            square[i][j]->setFixedSize(SQUARE_SIZE, SQUARE_SIZE);
            square[i][j]->setStyleSheet("border: 1px solid black;");
            layout->addWidget(square[i][j], i, j);
        }
    }
    setLayout(layout);
}

void Tetris::initTimer()
{
    timer = new QTimer(this);
    connect(timer, &QTimer::timeout, this, &Tetris::dropShape);
    timer->start(500);
}

void Tetris::newShape()
{
    static const int shapes[7][4][4] = {
        {{1, 1, 0, 0}, {1, 1, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}},
        {{0, 2, 2, 0}, {2, 2, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}},
        {{3, 3, 0, 0}, {0, 3, 3, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}},
        {{4, 0, 0, 0}, {4, 4, 4, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}},
        {{0, 0, 5, 0}, {5, 5, 5, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}},
        {{6, 6, 6, 6}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}},
        {{7, 7, 7, 0}, {0, 0, 7, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}}
    };
    currentShapeIndex = qrand() % 7;
    for (int i = 0; i < 4; ++i) {
        for (int j = 0; j < 4; ++j) {
            currentShape[i][j] = shapes[currentShapeIndex][i][j];
        }
    }
    currentX = COLUMNS / 2 - 2;
    currentY = 0;
    if (isCollision(currentX, currentY, currentShapeIndex)) {
        gameOver();
    }
    updateBoard();
}

void Tetris::drawSquare(int row, int column, int shapeIndex)
{
    QColor color;
    switch (shapeIndex) {
    case 1:
        color = Qt::red;
        break;
    case 2:
        color = Qt::green;
        break;
    case 3:
        color = Qt::blue;
        break;
    case 4:
        color = Qt::yellow;
        break;
    case 5:
        color = Qt::cyan;
        break;
    case 6:
        color = Qt::magenta;
        break;
    case 7:
        color = Qt::gray;
        break;
    }
    square[row][column]->setStyleSheet(QString("background-color: %1; border: 1px solid black;").arg(color.name()));
}

void Tetris::undrawSquare(int row, int column)
{
    square[row][column]->setStyleSheet("border: 1px solid black;");
}

void Tetris::updateBoard()
{
    for (int i = 0; i < ROWS; ++i) {
        for (int j = 0; j < COLUMNS; ++j) {
            if (board[i][j] == 0) {
                undrawSquare(i, j);
            } else {
                drawSquare(i, j, board[i][j]);
            }
        }
    }
    for (int i = 0; i < 4; ++i) {
        for (int j = 0; j < 4; ++j) {
            if (currentShape[i][j] != 0) {
                drawSquare(currentY + i, currentX + j, currentShapeIndex + 1);
            }
        }
    }
}

bool Tetris::isCollision(int x, int y, int shapeIndex)
{
    for (int i = 0; i < 4; ++i) {
        for (int j = 0; j < 4; ++j) {
            if (currentShape[i][j] == 0) {
                continue;
            }
            int newX = x + j;
            int newY = y + i;
            if (newX < 0 || newX >= COLUMNS || newY >= ROWS) {
                return true;
            }
            if (newY < 0) {
                continue;
            }
            if (board[newY][newX] != 0) {
                return true;
            }
        }
    }
    return false;
}

void Tetris::rotateShape()
{
    int newShape[4][4];
    for (int i = 0; i < 4; ++i) {
        for (int j = 0; j < 4; ++j) {
            newShape[i][j] = currentShape[3 - j][i];
        }
    }
    if (!isCollision(currentX, currentY, newShape)) {
        for (int i = 0; i < 4; ++i) {
            for (int j = 0; j < 4; ++j) {
                currentShape[i][j] = newShape[i][j];
            }
        }
        updateBoard();
    }
}

void Tetris::moveShape(int dx, int dy)
{
    if (!isCollision(currentX + dx, currentY + dy, currentShape)) {
        currentX += dx;
        currentY += dy;
        updateBoard();
    }
}

void Tetris::dropShape()
{
    if (!isCollision(currentX, currentY + 1, currentShape)) {
        currentY++;
        updateBoard();
    } else {
        for (int i = 0; i < 4; ++i) {
            for (int j = 0; j < 4; ++j) {
                if (currentShape[i][j] != 0) {
                    board[currentY + i][currentX + j] = currentShapeIndex + 1;
                }
            }
        }
        updateBoard();
        clearFullRows();
        newShape();
    }
}

void Tetris::clearFullRows()
{
    for (int i = ROWS - 1; i >= 0; --i) {
        bool full = true;
        for (int j = 0; j < COLUMNS; ++j) {
            if (board[i][j] == 0) {
                full = false;
                break;
            }
        }
        if (full) {
            for (int k = i; k > 0; --k) {
                for (int j = 0; j < COLUMNS; ++j) {
                    board[k][j] = board[k - 1][j];
                }
            }
            score += 10;
            updateBoard();
        }
    }
}

void Tetris::gameOver()
{
    timer->stop();
    QMessageBox::information(this, "Game Over", QString("Your score is %1").arg(score));
}

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    Tetris tetris;
    tetris.show();
    return a.exec();
}

这个程序使用了一个二维数组来表示俄罗斯方块游戏面板上的方块，使用 QLabel 来绘制方块。具体实现请参考代码注释。