Tetris v2.0

TetrisTask.pro

@@ -10,11 +10,19 @@ CONFIG += c++17
 
 SOURCES += \
     gamefield.cpp \
+    gameoverdialog.cpp \
     main.cpp \
+    modaldialog.cpp \
+    nextfiguregamegrid.cpp \
+    tetramino.cpp \
     tetris.cpp
 
 HEADERS += \
     gamefield.h \
+    gameoverdialog.h \
+    modaldialog.h \
+    nextfiguregamegrid.h \
+    tetramino.h \
     tetris.h
 
 FORMS += \

gamefield.cpp

@@ -1,32 +1,256 @@
 #include "gamefield.h"
 
 #include <QDebug>
+#include <QPainter>
+#include <QtAlgorithms>
+#include <QTimer>
+#include <QVector>
 
-GameField::GameField(QWidget *parent) : QWidget{parent} {
-  connect(this, &GameField::InitialisationStarted, this, &GameField::SetCells,
-          Qt::QueuedConnection);
+GameField::GameField(QWidget *parent) : QWidget(parent) {
+    setStyleSheet("border: 4px solid black;");
 
-  emit InitialisationStarted();
+    SetColumnNumber(20);
+    SetRowsNumber(24);
+
+    gameGrid_ = QVector<QVector<int>>(rowsNumber_, QVector<int>(columnsNumber_, 0));
+
+    currentFigureRow_ = 0;
+    currentFigureColumn_ = 0;
+}
+
+void GameField::SetNextFigureGrid(QVector<QVector<int>> figure) {
+    nextFigure_ = figure;
 }
 
 uint GameField::GetRowsNumber() const { return rowsNumber_; }
 
 void GameField::SetRowsNumber(uint rowsNumber) {
-  if (rowsNumber_ == rowsNumber) return;
+    if (rowsNumber_ == rowsNumber) return;
 
-  rowsNumber_ = rowsNumber;
-  emit RowsNumberChanged();
+    rowsNumber_ = rowsNumber;
+    emit RowsNumberChanged();
+    update();
 }
 
 uint GameField::GetColumnsNumber() const { return columnsNumber_; }
 
 void GameField::SetColumnNumber(uint columnsCount) {
-  if (columnsNumber_ == columnsCount) return;
+    if (columnsNumber_ == columnsCount) return;
+
+    columnsNumber_ = columnsCount;
+    emit ColumnsNumberChanged();
+    update();
+}
+
+void GameField::SetFigurePosition(int row, int column) {
+    if (column >= 0 && column + currentFigure_[0].size() <= columnsNumber_ && gameGrid_[row][column] != 1) {
+        currentFigureRow_ = row;
+        currentFigureColumn_ = column;
+    }
+    update();
+}
+
+void GameField::SpawnNextFigure() {
+    currentFigure_ = nextFigure_;
+    figureColor_ = Qt::blue;
+    emit FigureSpawned();
+}
+
+QVector<QVector<int>> GameField::GetCurrentFigure() {
+    return currentFigure_;
+}
+
+QVector<QVector<int>> GameField::GetRotateCurrentFigure() {
+    QVector<QVector<int>> currFigure = GetCurrentFigure();
+    QVector<QVector<int>> RotateFigure;
+
+    RotateFigure.resize(currFigure[0].size());
+
+    for (int i = 0; i < RotateFigure.size(); ++i) {
+        RotateFigure[i].resize(currFigure.size());
+    }
+
+
+    for(int i = 0; i < currFigure.size(); i++) {
+        for (int j = 0; j < currFigure[0].size(); j++) {
+            RotateFigure[j][currFigure.size() - i - 1] = currFigure[i][j];
+        }
+    }
+
+    currentFigure_ = RotateFigure;
+
+    emit CurrentFigureChanged();
+    return currentFigure_;
+}
+
+void GameField::UpdateGameGrid() {
+    for (int i = 0; i < currentFigure_.size(); ++i) {
+        for (int j = 0; j < currentFigure_[0].size(); ++j) {
+            if (currentFigure_[i][j] == 1) {
+                int x = currentFigureRow_ + i;
+                int y = currentFigureColumn_ + j;
+                CheckingLine();
+                gameGrid_[x][y] = 1;
+            }
+        }
+    }
+}
+
+bool GameField::HasCollisionMove(int x0, int y0) {
+    for (int i = 0; i < currentFigure_.size(); i++) {
+        for (int j = 0; j < currentFigure_[0].size(); j++) {
+            if (currentFigure_[i][j] == 1) {
+                int x = currentFigureRow_ + i + x0;
+                int y = currentFigureColumn_ + j + y0;
+
+                if (x < 0 || x >= rowsNumber_ || y < 0 || y >= columnsNumber_ || gameGrid_[x][y] == 1) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+
+bool GameField::HasCollisionRotation() {
+    for (int i = 0; i < currentFigure_.size(); i++) {
+        for (int j = 0; j < currentFigure_[0].size(); j++) {
+            if (currentFigure_[i][j] == 1) {
+                int x = currentFigureRow_ + i;
+                int y = currentFigureColumn_ + j;
+
+                if (x >= rowsNumber_ || y < 0 || y >= columnsNumber_ || gameGrid_[x][y] == 1) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+
+bool GameField::HasFullLine(int row) {
+    for(int j = 0; j < columnsNumber_; j++) {
+        if(gameGrid_[row][j] != 1) {
+            return false;
+        }
+    }
+    return true;
+}
+
+void GameField::RemoveFullLine(int row) {
+    for (int j = 0; j < columnsNumber_; j++) {
+        gameGrid_[row][j] = 0;
+    }
+
+    for(int k = row;k > 0;k--) {
+        for(int j = 0;j < columnsNumber_; j++) {
+            gameGrid_[k][j] = gameGrid_[k-1][j];
+        }
+    }
+}
+
+int GameField::GetWinPoints() {
+    return winPoints_;
+}
+
+void GameField::CheckingLine() {
+    for(int i = rowsNumber_ - 1; i >= 0; i--) {
+        if (HasFullLine(i)) {
+            RemoveFullLine(i);
+            winPoints_ += 100;
+            emit ChangeWinPoints();
+        }
+    }
+}
+
+void GameField::MoveFigure() {
+    GetGameOver();
+    int CenterPointX = 2;
+
+    if(!isGameOver_) {
+        if (currentFigureRow_ + currentFigure_.size() < rowsNumber_) {
+            bool hasCollision = HasCollisionMove(1, 0);
+
+            if (hasCollision) {
+                UpdateGameGrid();
+                SpawnNextFigure();
+                SetFigurePosition(0, columnsNumber_ / CenterPointX);
+                CheckingLine();
+            } else {
+                SetFigurePosition(currentFigureRow_ + 1, currentFigureColumn_);
+            }
+        } else {
+            UpdateGameGrid();
+            SpawnNextFigure();
+            SetFigurePosition(0, columnsNumber_ / CenterPointX);
+            CheckingLine();
+        }
+        update();
+    } else {
+        isGameOver_ = false;
+        emit GameOver();
+    }
+}
 
-  columnsNumber_ = columnsCount;
-  emit ColumnsNumberChanged();
+void GameField::GetGameOver() {
+    for (int i = 0; i < columnsNumber_; i++) {
+        if (gameGrid_[0][i] != 0) {
+            isGameOver_ = true;
+        }
+    }
 }
 
-void GameField::SetCells() {
-  qDebug() << rowsNumber_ << " " << columnsNumber_ << "|";
+uint GameField::GetCurrentFigureRow() {
+    return currentFigureRow_;
+}
+
+uint GameField::GetCurrentFigureColumn() {
+    return currentFigureColumn_;
+}
+
+void GameField::ClearGameGrid() {
+    gameGrid_ = QVector<QVector<int>>(rowsNumber_, QVector<int>(columnsNumber_, 0));
+
+    currentFigure_ = QVector<QVector<int>>();
+    currentFigureRow_ = 0;
+    currentFigureColumn_ = 0;
+
+    update();
+}
+
+void GameField::SetWinPoints(int points) {
+    winPoints_ = points;
+    emit ChangeWinPoints();
+}
+
+void GameField::paintEvent(QPaintEvent *event) {
+    Q_UNUSED(event);
+    QPainter painter(this);
+
+    painter.setPen(Qt::black);
+    painter.fillRect(rect(), Qt::white);
+
+    for (int i = 0; i < currentFigure_.size(); ++i) {
+        for (int j = 0; j < currentFigure_[0].size(); ++j) {
+            if (currentFigure_[i][j] == 1) {
+                int x = (currentFigureColumn_ + j) * blockSize_;
+                int y = (currentFigureRow_ + i) * blockSize_;
+                painter.fillRect(x, y, blockSize_, blockSize_, figureColor_);
+            }
+        }
+    }
+
+    for (int i = 0; i < rowsNumber_; i++) {
+        for (int j = 0; j < columnsNumber_; j++) {
+            if (gameGrid_[i][j] == 1) {
+                int x = j * blockSize_;
+                int y = i * blockSize_;
+                painter.fillRect(x, y, blockSize_, blockSize_, Qt::blue);
+                painter.drawRect(j * blockSize_, i * blockSize_, blockSize_, blockSize_);
+            } else {
+                painter.drawRect(j * blockSize_, i * blockSize_, blockSize_, blockSize_);
+            }
+        }
+    }
+    update();
 }

gamefield.h

@@ -1,36 +1,96 @@
 #ifndef GAMEFIELD_H
 #define GAMEFIELD_H
 
+#include "tetramino.h"
+#include "nextfiguregamegrid.h"
+
 #include <QWidget>
 
+class Tetris;
+
 class GameField : public QWidget {
   Q_OBJECT
  public:
   explicit GameField(QWidget *parent = nullptr);
 
-  Q_PROPERTY(uint rowsNumber READ GetRowsNumber WRITE SetRowsNumber NOTIFY
+    Q_PROPERTY(uint rowsNumber READ GetRowsNumber WRITE SetRowsNumber NOTIFY
                  RowsNumberChanged FINAL)
-  Q_PROPERTY(uint columnsNumber READ GetColumnsNumber WRITE SetColumnNumber
+    Q_PROPERTY(uint columnsNumber READ GetColumnsNumber WRITE SetColumnNumber
                  NOTIFY ColumnsNumberChanged FINAL)
 
  signals:
-  void RowsNumberChanged();
-  void ColumnsNumberChanged();
-  void InitialisationStarted();
-
- private slots:
-  void SetCells();
+    void RowsNumberChanged();
+    void ColumnsNumberChanged();
+    void FigureSpawned();
+    void FigureFalling();
+    void CurrentFigureChanged();
+    void ChangeWinPoints();
+    void GameOver();
 
  public:
-  uint GetRowsNumber() const;
-  void SetRowsNumber(uint newRowsNumber);
+    void SetNextFigureGrid(QVector<QVector<int>> figure);
+
+    uint GetRowsNumber() const;
+    void SetRowsNumber(uint newRowsNumber);
+
+    uint GetColumnsNumber() const;
+    void SetColumnNumber(uint newColumnsCount);
+
+    void SetFigurePosition(int row, int column);
+
+    void SpawnNextFigure();
+    void UpdateGameGrid();
+
+    bool HasCollisionMove(int xO, int yO);
+
+    bool HasCollisionRotation();
+
+    QVector<QVector<int>> GetCurrentFigure();
+    QVector<QVector<int>> GetRotateCurrentFigure();
+
+    bool HasFullLine(int row);
+    void CheckingLine();
+
+    void RemoveFullLine(int row);
 
-  uint GetColumnsNumber() const;
-  void SetColumnNumber(uint newColumnsCount);
+    int GetWinPoints();
+
+    void MoveFigure();
+
+    void GetGameOver();
+
+    uint GetCurrentFigureRow();
+    uint GetCurrentFigureColumn();
+
+    void ClearGameGrid();
+    void SetWinPoints(int points);
+
+protected:
+    void paintEvent(QPaintEvent *event);
 
  private:
-  uint rowsNumber_ = 0;
-  uint columnsNumber_ = 0;
+    uint rowsNumber_ = 0;
+    uint columnsNumber_ = 0;
+    int currentRow_ = 0;
+
+    int blockSize_ = 30;
+    int winPoints_ = 0;
+
+    bool isLineFull_ = true;
+    bool isGameOver_ = false;
+
+    QVector<QVector<int>> currentFigure_;
+    QVector<QVector<int>> nextFigure_;
+
+    QVector<QVector<int>> gameGrid_;
+
+    uint currentFigureRow_;
+    uint currentFigureColumn_;
+
+    QColor figureColor_;
+
+    Tetramino *tetraminoGeneratorFirst_;
+    NextFigureGameGrid *nextGameGrid_;
 };
 
 #endif  // GAMEFIELD_H