How to Create Tetris Game with C++

Tetris (Russian: Тетрис)[a] is a multimedia franchise originating from a puzzle video game created by Soviet software engineer Alexey Pajitnov in 1984.

Video games with Tetris’ core mechanics have been published by several companies for multiple platforms, most prominently during a dispute over the appropriation of the rights in the late 1980s. After a significant period of publication by Nintendo, the rights reverted to Pajitnov in 1996, who co-founded the Tetris Company with Henk Rogers to manage licensing. The franchise has since expanded into film, television, books, and music singles.

In this article we will create Tetris with C++ and SFML adding score and game over .

At the end of the article there is a video and also the link to the source code on GitHub .

01. DRAW THE SQUARES ON THE SCREEN

Basic start files:

tetris.hpp
tetris.cpp
main.cpp
Makefile
resources/

tetris.hpp

#pragma once

#include <SFML/Graphics.hpp>
#include <memory>

class Tetris {
  std::shared_ptr<sf::RenderWindow> window;
  sf::Texture tiles;
  std::shared_ptr<sf::Sprite> sprite;

  protected:
    void events();
    void draw();

  public:
    Tetris();
    void run();
};

tetris.cpp

#include "tetris.hpp"

Tetris::Tetris(){
  window = std::make_shared<sf::RenderWindow>(
    sf::VideoMode(360, 720),
    "Tetris (remix)",
    sf::Style::Titlebar | sf::Style::Close
  );
  window->setPosition(sf::Vector2i(100, 100));

  tiles.loadFromFile("./resources/img/squares.png");
  sprite = std::make_shared<sf::Sprite>();
  sprite->setTexture(tiles);
}

void Tetris::events(){
  auto e = std::make_shared<sf::Event>();
  while( window->pollEvent(*e)){
    if( e->type == sf::Event::Closed){
      window->close();
    }
  }
}

void Tetris::draw(){
  window->clear(sf::Color::Black);
  window->draw(*sprite);
  window->display();
}

void Tetris::run(){
  while( window->isOpen() ){
    events();
    draw();
  }
}

main.cpp

#include "tetris.hpp"

int main( int argc , char **argv ){
  auto tetris = std::make_shared<Tetris>();
  tetris->run();
  return 0;
}

Makefile

TARGET=a.out
CXX=g++
DEBUG=-g
OPT=-O0
WARN=-Wall
SFML=-lsfml-graphics -lsfml-window -lsfml-system
CXXFLAGS=$(DEBUG) $(OPT) $(WARN) $(SFML)
LD=g++
OBJS= main.o tetris.o
all: $(OBJS)
	$(LD) -o $(TARGET) $(OBJS) $(CXXFLAGS)
	@rm *.o
	@./$(TARGET)

main.o: main.cpp
	$(CXX) -c $(CXXFLAGS) main.cpp -o main.o

tetris.o: tetris.cpp
	$(CXX) -c $(CXXFLAGS) tetris.cpp -o tetris.o

Compile and run:

make

02. DRAW SHAPES ON THE SCREEN

Add to tetris.hpp(private and first of all)

static const std::uint32_t lines   {20};
static const std::uint32_t cols    {10};
static const std::uint32_t squares {4};
static const std::uint32_t shapes  {7};

struct Coords {
  std::uint32_t x, y;
} z[squares], k[squares];

std::vector<std::vector<std::uint32_t>> area;
std::vector<std::vector<std::uint32_t>> forms;

Add to tetris.hpp the member function: void moveToDown();

Shapes:

]
{1,3,5,7}, // I
{2,4,5,7}, // Z
{3,5,4,6}, // S
{3,5,4,7}, // T
{2,3,5,7}, // L
{3,5,7,6}, // J
{2,3,4,5}, // O

Add tetris.cpp to the Constructor:

 area.resize(lines);
 for (std::size_t i {}; i < area.size(); ++i) {
  area[i].resize(cols); 
 }

 forms = {
   {1,3,5,7}, // I
   {2,4,5,7}, // Z
   {3,5,4,6}, // S
   {3,5,4,7}, // T
   {2,3,5,7}, // L
   {3,5,7,6}, // J
   {2,3,4,5}, // O
 };

Add to tetris.hpp the member function void Tetris::moveToDown() to tetris.cpp:

void Tetris::moveToDown(){
 std::uint32_t number = {3};
 for (std::size_t i {}; i < squares; ++i) {
  z[i].x = forms[number][i] % 2; 
  z[i].y = forms[number][i] / 2; 
 }
}

Add to tetris.cpp the void Tetris::draw() member function:

for (std::size_t i {}; i < squares; ++i) {
  sprite->setPosition(z[i].x * 36, z[i].y * 36); 
  window->draw(*sprite);
}

Add to tetris.cpp the void Tetris::run() member function:

...
events();
moveToDown(); // ADD
...

03. ROTATE AND MOVE TO THE SIDE

Add to tetris.hpp:

int dirx;
bool rotate;

void changePosition();
void setRotate();
void resetValues();

Add tetris.cpp to the constructor:

dirx = {0};
rotate = {false};

Add tetris.cpp to the events() loop

if( e->type == sf::Event::KeyPressed ){
  if( e->key.code == sf::Keyboard::Up ){
    rotate = true;
  }else if( e->key.code == sf::Keyboard::Left ){
    --dirx;
  }else if( e->key.code == sf::Keyboard::Right ){
    ++dirx;
  }
}

Add tetris.cpp contents of the 3 created member functions:

void Tetris::changePosition(){
  for (std::size_t i {}; i < squares; ++i) {
   z[i].x += dirx; 
  }
}

void Tetris::setRotate(){
  if( rotate ){
    Coords coord = z[1];
    for (std::size_t i {}; i < squares; ++i) {
     int x = z[i].y - coord.y; // INVERTIDOS
     int y = z[i].x - coord.x; // INVERTIDOS

     z[i].x = coord.x - x;
     z[i].y = coord.y + y; // AQUI É SOMA
    }
  }
}

void Tetris::resetValues(){
  dirx = 0;
  rotate = false;
}

Change the run() member function into tetris.cpp and add the new created member functions in that order:

void Tetris::run(){
  while( window->isOpen() ){
    events();

    changePosition();
    setRotate();
    moveToDown();
    resetValues();

    draw();
  }
}

TO MOVE YOU NEED TO CHANGE moveToDown() and add the condition if( z[0].x == 0 ){} and put the LOOP inside

if( z[0].x == 0 ){ // ADD
  for (std::size_t i {}; i < squares; ++i) {
    z[i].x = forms[number][i] % 2; 
    z[i].y = forms[number][i] / 2; 
  }
}

COMPILE AND DISPLAY ROTATION AND SIDES MOVEMENT!

04. MOVE DOWN

Add to tetris.hpp:

sf::Clock clock;
float timercount, delay;

Adicionar ao construtor:

timercount = {0.f};
delay = {0.2f};

Adicionar à void Tetris::events() antes de auto e = ...:

float time = clock.getElapsedTime().asSeconds();
clock.restart();
timercount += time;

Adicionar à void Tetris::moveToDown() antes do std::uint32_t number = {3}:

if( timercount > delay ){
  for (std::size_t i {}; i < squares; ++i) {
    ++z[i].y; 
  }
  timercount = 0;
}

Add to builder:

timercount = {0.f};
delay = {0.2f};

Add to void Tetris::events() before auto and = ...:

float time = clock.getElapsedTime().asSeconds();
clock.restart();
timercount += time;

Add to void Tetris::moveToDown() before std::uint32_t number = {3}:

if( timercount > delay ){
  for (std::size_t i {}; i < squares; ++i) {
    ++z[i].y; 
  }
  timercount = 0;
}

05. LIMIT THE PARTS TO THE FLOOR AND FIT ONE ON TOP OF THE OTHER

Add to tetris.hpp:

bool maxLimit();

Add to bool Tetris::maxLimit():

bool Tetris::maxLimit(){
  for (std::size_t i {}; i < squares; ++i) {

    if( z[i].x < 0 || 
        z[i].x >= cols || 
        z[i].y >= lines || 
        area[ z[i].y][ z[i].x ] ){
      return true;
    }
  }
  return false;
}

Add the seeder to main.cpp:

std::srand( std::time( 0 ));

Change changePosition() to store the value of the moving shape(z[i]) to fix it(k[i]) and check with maxLimit():

void Tetris::changePosition(){
  for (std::size_t i {}; i < squares; ++i) {
   k[i] = z[i];
   z[i].x += dirx; 

   if(maxLimit()){
     for (std::size_t i {}; i < squares; ++i) {
      z[i] = k[i]; 
     }
   }

  }
}

Copy the condition from if( maxLimit() )... and paste inside the if( rotate )..., but outside the for loop in void Tetris::setRotate()

if( maxLimit() ){
  for (std::size_t i {}; i < squares; ++i) {
    z[i] = k[i]; 
  }
}

Add to int color tetris.hpp and initialize it to 1: color = {1};

Same thing also in moveToDown(), but creating random pieces and changing the position of the number line into the if( maxLimit() ) condition, REMOVE CONDITION: if( z[0 ].x == 0 ){ ... :

IMPORTANT: create the loop to set the color to a fixed position and make it random;

void Tetris::moveToDown(){

  if( timercount > delay ){
    for (std::size_t i {}; i < squares; ++i) {
      k[i] = z[i]; 
      z[i].y += 1; 
    }
    if( maxLimit() ){

      for (std::size_t i {}; i < squares; ++i) { // ADD
       area[ k[i].y ][ k[i].x ] = color;
      }

      color = 1 + std::rand() % shapes;
      std::uint32_t number = std::rand() % shapes;
      for (std::size_t i {}; i < squares; ++i) {
        z[i].x = forms[number][i] % 2; 
        z[i].y = forms[number][i] / 2; 
      }

    }
    timercount = 0;
  }
}

Add loop in void Tetris::draw():

for (std::size_t i {}; i < lines; ++i) {
  for (std::size_t j {}; j < cols; ++j) {
    if( area[i][j] != 0 ){
      sprite->setPosition( j * 36, i * 36 );
      window->draw( *sprite );
    }
  }
}

Add to events() outside the loop:

if(sf::Keyboard::isKeyPressed(sf::Keyboard::Down)){ // ADD
  delay = 0.05f;
}

TO MAKE THE FIRST PIECE ALSO RANDOM, add to the constructor:

Copy from moveToDown()

std::uint32_t number = std::rand() % shapes; // ADD
for (std::size_t i {}; i < squares; ++i) {
  z[i].x = forms[number][i] % 2; 
  z[i].y = forms[number][i] / 2; 
}

06. ADD RANDOM COLORS

Add sprite->setTextureRect(sf::IntRect(color * 36, 0, 36, 36)); to the squares loop in draw()

for (std::size_t i {}; i < squares; ++i) {
  sprite->setTextureRect(sf::IntRect(color * 36, 0, 36, 36));
  sprite->setPosition(z[i].x * 36, z[i].y * 36); 
  window->draw(*sprite);
}

Note that the fixed part will also change color, so to solve this, just add sprite->setTextureRect(sf::IntRect(area[i][j] * 36, 0, 36, 36));(COPY the already existing and modify) to the lines cols loop:

for (std::size_t i {}; i < lines; ++i) {
  for (std::size_t j {}; j < cols; ++j) {
    if( area[i][j] == 0 ){
      continue;
    } 
    sprite->setTextureRect(sf::IntRect(area[i][j] * 36, 0, 36, 36));
    sprite->setPosition( j * 36, i * 36 );
    window->draw( *sprite );
  } 
}

07. ADD SCORE

Create a new member function in tetris.hpp also create score and add as zero to the constructor:

void setScore();

Add to tetris.cpp the execution of setScore():

void Tetris::setScore(){
  int match = {lines - 1};
  for (std::size_t i = match; i >= 1; --i) {
   std::uint32_t sum {};
   for (std::size_t j {}; j < cols; ++j) {
    if( area[i][j] ){
      ++sum;
    }
    area[match][j] = area[i][j];
   }
   if( sum < cols ){
     --match;
   }else{
     std::cout << "Score: " << ++score << '\n';
   }
  }
}

08. ADD BACKGROUNDS AND TEXT FOR SCORING

GIMP → 360x720 → Filters → Render → Textures → Grid → 36 1 COLOR
Export → background.png
Add sf::Texture tiles, bg; and std::shared_ptr<sf::Sprite> sprite, background;
Constructor:

bg.loadFromFile("./resources/img/background.png");
background = std::make_shared<sf::Sprite>();
background->setTexture(bg);

draw() → window->draw(*background);

09. ADD SCORE AND GAMEOVER

Add to tetris.hpp

sf::Font font;
sf::Text txtScore, txtGameOver;
bool rotate, gameover;

Add to tetris.cpp

score = {0};
gameover = {false};

font.loadFromFile("./font.ttf");
txtScore.setFont(font);
txtScore.setPosition(100.f, 10.f);
txtScore.setString( "SCORE: " + std::to_string( score ));
txtScore.setStyle(sf::Text::Bold);
txtScore.setCharacterSize(30);
txtScore.setOutlineThickness(3);

txtGameOver.setFont(font);
txtGameOver.setPosition( 30.f , 330.f);
txtGameOver.setString("GAME OVER");
txtGameOver.setStyle(sf::Text::Bold);
txtGameOver.setCharacterSize(50);
txtGameOver.setOutlineThickness(3);

Tetris::draw():

window->draw( txtScore );

if( gameover ){
  window->draw( txtGameOver );
}

Tetris::run()

if( !gameover ){
  changePosition();
  setRotate();
  moveToDown();
  setScore();
  resetValues();
}

Tetris::setScore:

void Tetris::setScore(){
  int match = {lines - 1};
  for (std::size_t i = match; i >= 1; --i) {
    std::uint32_t sum {};
    for (std::size_t j {}; j < cols; ++j) {
      //if( area[i][j] != 0 ){
      if( area[i][j] ){
        if( i == 1 ){
          gameover = true;
        }
        ++sum;
      }
      area[match][j] = area[i][j]; // FIXA AO CHAO
    }
    if( sum < cols ){
      --match;
    }else{
      txtScore.setString( "SCORE: " + std::to_string( ++score ));
    }
  }
}

WATCH THE VIDEO

The video is in Portuguese, but you can follow the steps even if you don’t understand the language. You can also enable subtitles and use Youtube’s automatic translation.