Как написать тетрис на python

Показываем и рассказываем, как написать тетрис на Python с помощью модуля Pygame.

Классический тетрис появился в 1984 году — но до сих пор будоражит умы людей со всего мира. В тетрис и по сей день играют миллионы, используя различные гаджеты и вычислительные машины.

Игру любят за четкость, достижимость цели и наглядную «обратную связь». В то же время тетрис полезен: развивает скорость реакции и пространственное мышление, учит концентрироваться на задаче и абстрагироваться от внешних раздражителей, успокаивает нервы и повышает производительность работы мозга.

Знать, как устроена любимая игра — захватывающе. Конструирование тетриса на языке Пайтон — способ испытать себя и усовершенствовать навыки программирования для начинающего кодера.

В конце инструкции — ссылка на тематический видеоурок: просмотр закрепит знания.

Начинаем воплощать тетрис на Пайтоне

Сразу напомним: модуль Pygame изначально не встроен в Python. Если он не установлен, проще это сделать в консоли командой pip install pygame.

Первым делом импортируем нужные библиотеки: pygame, random, copy. Copy понадобится, чтобы разобраться с одной особенностью хранения в Python.

После чего активируем модули Pygame и зададим 2 параметра сетки — I_max и J_max. Сетка строится по такому принципу: число ячеек равно числу точек -1. Можете убедиться в этом, посчитав на рисунке или нарисовав сами:

Задав число точек I_max и J_max 11 и 21, получим 11 и 20 ячеек соответственно.

Добавляем переменные

Зададим 2 переменные с параметрами экрана 300 на 600. После сделаем экран, туда запишем переменные, а также создадим класс Clock(). Он понадобится для работы со временем — с частотой обновления экрана.

Сосчитаем шаг по x и по y для сетки — ширину и высоту ячейки. Делим на I_max -1, J_max -1: область необходимо разделить на число ячеек, а оно как раз на 1 меньше числа точек. Создаем переменную для частоты обновления кадров.

Как сделать тетрис на Python: применяем списки и циклы

Делаем список, который будет хранить внутри себя параметры сетки, отображенные в окне. Добавим по списку на каждом элементе по ширине и на каждом элементе по высоте. Сразу занесем туда 1 — позднее станет понятно, зачем это сделано.

Кроме 1, заполним списки сущностями прямоугольников — rect, а также цветом для каждого из них. В координатах прямоугольников пишем координаты, где они должны находиться. Это можно сосчитать, умножив номер точки на шаг — ширину или высоту ячейки.

Пора запустить бесконечный цикл, заполнить экран для его обновления и нарисовать сетку. Для этого снова пройдемся по элементам сетки и нарисуем каждый квадратик. Третий элемент списка — 2: это цвет. Второй — 1: сущность прямоугольника, созданного ранее. Тип заполнения — 0: когда стоит 1, у прямоугольника нарисована граница шириной 1. Если бы поставили 0, он бы заполнился полностью.

Не забудьте добавить событие нажатия на крестик в игре.

Переходим к деталям

Тетрис — игра про детали. Потому рекомендуем посмотреть на 7 оригинальных фигур тетриса:

Распишем их координаты в списке. Будем придерживаться того, что каждый третий — 0,0 элемент, который в будущем примем за ось вращения.

Создадим список уже не с координатами, а с самими деталями. Для этого делаем список det: каждый элемент будем заполнять 4 прямоугольниками. Координаты берем из списка с координатами и создаем детали в центре экрана сверху.

Посмотрим, чем заполняется список, выведем это в консоль. Видим, что в нем 7 списков, по 4 прямоугольника в каждом — что и хотели получить.

Настроим случайный выбор детали из списка и ее отрисовку в программе. Каждый кадр проводится циклом по 4 прямоугольникам внутри детали. Прямоугольники будут отрисовываться.

Как создать тетрис на Python: проектируем движения

Для создания движения будем брать рандомно выбранную деталь det_choice и менять координаты у 4 прямоугольников на шаг dx и dy.

Для примера напишем 1*dx и посмотрим, что будет. Деталь быстро улетела вправо. Если поменяем на -1 — быстро улетит влево. Будем менять данные параметры с 0 на 1 и -1 при взаимодействии с клавишами стрелки вправо или стрелки влево. Создадим event нажатия на клавишу: если нажата стрелка влево, меняем переменную delta_x на -1. Для правой стрелки аналогично, только +1.

Теперь нужно настроить границы, чтобы за них нельзя было выходить. Для этого зададим условие: если хотя бы одна из деталей на следующей клетке (на следующем шаге) за пределами границ экрана, то delta_x зануляем, движения не произойдет.

Таким же образом сделаем перемещение по y. Для замедления включаем передвижение только каждые 30 обновлений. Для этого будем сохранять число обновлений в переменной.

Добавим вариант ускорения передвижения по y, если хотим резко уронить деталь и не ждать ее медленного падения. Чтобы зажимать клавишу, а не нажимать по кнопке много раз, используем функцию get_pressed(). Если ключ, который нажмет человек, совпадает с pygame.K_DOWN, т.е. стрелкой вниз, число обновлений сразу зададим равным 31.

Настроим границы для y: если на следующем шаге по y хотя бы одна деталь выйдет за нижнюю границу, остановим движение.

Остановили движение — зареспавним еще одну деталь. Для этого закрасим клетки сетки, где осталась фигура, белым цветом — зададим параметр заливки равным 0, а цвет изменим с серого на белый и сделаем новый выбор детали.

Исправляем ошибки

После проверки в игре обнаружен баг — деталь появляется только 7 раз, после этого ничего не происходит. Это связано с хранением информации в Python: меняя координаты деталей, меняем и список — фигуры сразу возникают в самом низу. Чтобы такого не происходило, будем делать копию детали из списка и менять уже координаты копии, а не фигуры.

Теперь их появляется уже больше 7 штук, но они не ставятся друг на друга. Это следует исправить: пропишем условие в границы: если следующая снизу ячейка сетки закрашена, останавливаем движение.

Доделываем игру тетрис на Python

Основные механики готовы, осталось только внедрить пару вещей из оригинальной игры: поворот деталей и снос заполненного ряда.

Начнем с поворота. Его сделаем по стандартной математической формуле поворота на 90 градусов в декартовой системе координат — относительно центра в (0,0). Центр записан в третьей ячейке, поэтому обозначаем как центр второй индекс det_choice[2].

Создадим проверку на контакт с клавишей стрелки вверх — при ее нажатии переменная rotate становится равной True, выполняется условие. Проходимся по элементам квадратика и смещаем их относительно центра вращения, после чего переписываем rotate на False.

Последний штрих — снос заполненного ряда. Для этого запустим цикл, проверяющий, насколько заполнен каждый ряд. Идти будем снизу вверх и слева направо, считая число заполненных ячеек: в этом случае параметр заполнения равен 0. Если же хотя бы одна ячейка не равна 0, можем сказать, что полоска не заполнена — а затем завершить цикл на этом ряду и перейти к проверке следующего.

Если число заполненных ячеек равно числу ячеек в целом, запускаем еще 2 цикла. Сначала ячейки верхнего ряда делаем незакрашенными, а после все ячейки рядов смещаем на ряд вниз, начиная с заполненного.

Надеемся, вы попробовали написать данный код и улучшить его — поверьте, здесь есть потенциал для совершенствования.

Что дальше

Как и обещали, делимся YouTube-видеороликом о том, как сделать игру тетрис на Пайтоне: он поможет пройтись по изученному материалу. Также на канале находится плейлист с бесплатными роликами, посвященными реализации игр на Python. Стоит посмотреть, чтобы вдохновиться на конструирование игр.

Отточить мастерство геймдева и программирования на Питоне также можно на специальных курсах под присмотром опытного преподавателя.

Изучая разработку на Питоне любым из методов, ребенок приобретет полезные качества и умения, которые пригодятся в жизни и при построении карьеры в удивительном мире IT.

Полный код программы:

Starter File

To make our lives a little easier I have I have included a starter file that has the code for some of the more tedious parts of the game. Please copy the code below into your python script before starting. If you’d like an in-depth explanation of the starter file please refer to the video.

The way we will represent our pieces will be using multidimensional lists. Each list will have multiple sub-lists that represent all of the possible rotations of each shape. This will make it much easier to rotate and represent our shapes visually when we eventually draw them to the screen.

import pygame
import random

# creating the data structure for pieces
# setting up global vars
# functions
# - create_grid
# - draw_grid
# - draw_window
# - rotating shape in main
# - setting up the main

"""
10 x 20 square grid
shapes: S, Z, I, O, J, L, T
represented in order by 0 - 6
"""

pygame.font.init()

# GLOBALS VARS
s_width = 800
s_height = 700
play_width = 300  # meaning 300 // 10 = 30 width per block
play_height = 600  # meaning 600 // 20 = 20 height per block
block_size = 30

top_left_x = (s_width - play_width) // 2
top_left_y = s_height - play_height


# SHAPE FORMATS

S = [['.....',
      '......',
      '..00..',
      '.00...',
      '.....'],
     ['.....',
      '..0..',
      '..00.',
      '...0.',
      '.....']]

Z = [['.....',
      '.....',
      '.00..',
      '..00.',
      '.....'],
     ['.....',
      '..0..',
      '.00..',
      '.0...',
      '.....']]

I = [['..0..',
      '..0..',
      '..0..',
      '..0..',
      '.....'],
     ['.....',
      '0000.',
      '.....',
      '.....',
      '.....']]

O = [['.....',
      '.....',
      '.00..',
      '.00..',
      '.....']]

J = [['.....',
      '.0...',
      '.000.',
      '.....',
      '.....'],
     ['.....',
      '..00.',
      '..0..',
      '..0..',
      '.....'],
     ['.....',
      '.....',
      '.000.',
      '...0.',
      '.....'],
     ['.....',
      '..0..',
      '..0..',
      '.00..',
      '.....']]

L = [['.....',
      '...0.',
      '.000.',
      '.....',
      '.....'],
     ['.....',
      '..0..',
      '..0..',
      '..00.',
      '.....'],
     ['.....',
      '.....',
      '.000.',
      '.0...',
      '.....'],
     ['.....',
      '.00..',
      '..0..',
      '..0..',
      '.....']]

T = [['.....',
      '..0..',
      '.000.',
      '.....',
      '.....'],
     ['.....',
      '..0..',
      '..00.',
      '..0..',
      '.....'],
     ['.....',
      '.....',
      '.000.',
      '..0..',
      '.....'],
     ['.....',
      '..0..',
      '.00..',
      '..0..',
      '.....']]

shapes = [S, Z, I, O, J, L, T]
shape_colors = [(0, 255, 0), (255, 0, 0), (0, 255, 255), (255, 255, 0), (255, 165, 0), (0, 0, 255), (128, 0, 128)]
# index 0 - 6 represent shape


class Piece(object):
    pass

def create_grid(locked_positions={}):
    pass

def convert_shape_format(shape):
    pass

def valid_space(shape, grid):
    pass

def check_lost(positions):
    pass

def get_shape():
    pass

def draw_text_middle(text, size, color, surface):  
    pass
   
def draw_grid(surface, row, col):
    pass

def clear_rows(grid, locked):
    pass

def draw_next_shape(shape, surface):
    pass

def draw_window(surface):
    pass

def main():
    pass

def main_menu():
    pass

main_menu()  # start game

Piece Class

Since we will be creating multiple shapes it makes sense to create a piece class that can store some information about each shape.

class Piece(object):
    rows = 20  # y
    columns = 10  # x
 
    def __init__(self, column, row, shape):
        self.x = column
        self.y = row
        self.shape = shape
        self.color = shape_colors[shapes.index(shape)]
        self.rotation = 0  # number from 0-3

Creating a Grid

The way that we will keep track of pieces in the game is using a grid data structure. We will create a multidimensional list that contains 20 lists of 10 elements (rows and columns). Each element in the lists will be a tuple representing the color of the piece in that current position. This will allow us to draw all of the colored squares quite easily as we can simply loop through the multidimensional list.

The locked position parameter will contain a dictionary of key value pairs where each key is a position of a piece that has already fallen and each value is its color. We will loop through these locked positions and modify our blank grid to show these pieces.

def create_grid(locked_positions={}):
    grid = [[(0,0,0) for x in range(10)] for x in range(20)]
 
    for i in range(len(grid)):
        for j in range(len(grid[i])):
            if (j,i) in locked_positions:
                c = locked_positions[(j,i)]
                grid[i][j] = c
    return grid

Getting a Random Shape

Since we will be dropping shapes down the screen at random we need to generate a random shape. This will be done in the get_shape() function.

def get_shape():
    global shapes, shape_colors
 
    return Piece(5, 0, random.choice(shapes))

Drawing the Grid

I am not going to explain all of the pygame functions and methods I use as if you are familair with pygame you should know them. However, if you’d like to learn more about the basics of pygame click here!

We will simply be calling the function below to draw all of our objects to the screen. In this function we call some functions that we will be coding later.

    surface.fill((0,0,0))
    # Tetris Title
    font = pygame.font.SysFont('comicsans', 60)
    label = font.render('TETRIS', 1, (255,255,255))
 
    surface.blit(label, (top_left_x + play_width / 2 - (label.get_width() / 2), 30))
 
    for i in range(len(grid)):
        for j in range(len(grid[i])):
            pygame.draw.rect(surface, grid[i][j], (top_left_x + j* 30, top_left_y + i * 30, 30, 30), 0)
 
    # draw grid and border
    draw_grid(surface, 20, 10)
    pygame.draw.rect(surface, (255, 0, 0), (top_left_x, top_left_y, play_width, play_height), 5)
    pygame.display.update()

The Game Loop

In every game we have something called a game loop or a main loop. This is what will be running constantly and checking to see if events occur. Our game loop will go inside the main() function.

In this function we will start by defining some variables and then move into the while loop. Inside the while loop we will check for key press events and see if the user wants to exit the game.

When the user presses the up arrow key the piece will rotate. We can do this by simply increasing our shapes rotation attribute to be the next shape in the list we set up at the beginning of the program.

When the user hits the left or right arrow keys we will move accordingly bu changing the x value of our piece.

Finally when the user hist the down arrow key we will move down one square allowing the user to increase the speed at which the shape falls.

def main():
    global grid
 
    locked_positions = {}  # (x,y):(255,0,0)
    grid = create_grid(locked_positions)
 
    change_piece = False
    run = True
    current_piece = get_shape()
    next_piece = get_shape()
    clock = pygame.time.Clock()
    fall_time = 0
 
    while run:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                run = False
                pygame.display.quit()
                quit()
 
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_LEFT:
                    current_piece.x -= 1
                    if not valid_space(current_piece, grid):
                        current_piece.x += 1
 
                elif event.key == pygame.K_RIGHT:
                    current_piece.x += 1
                    if not valid_space(current_piece, grid):
                        current_piece.x -= 1
                elif event.key == pygame.K_UP:
                    # rotate shape
                    current_piece.rotation = current_piece.rotation + 1 % len(current_piece.shape)
                    if not valid_space(current_piece, grid):
                        current_piece.rotation = current_piece.rotation - 1 % len(current_piece.shape)
 
                if event.key == pygame.K_DOWN:
                    # move shape down
                    current_piece.y += 1
                    if not valid_space(current_piece, grid):
                        current_piece.y -= 1

        draw_window(win)

We will be adding more to this function in the future.

Setting up The Window

The last thing we need to do for this tutorial is setup the pygame window and give it a caption. This will go at the very end of the program, not within any function.

win = pygame.display.set_mode((s_width, s_height))
pygame.display.set_caption('Tetris')

Testing The Program

If you’d like to test the program you can simply call main() at the very end of the program like so.

Разработка

У нас нет изображений для нашего Тетриса, мы рисуем тетрамино, используя доступное в программном инструментарии PyQt5 инструменты рисования. У каждой компьютерной игры имеется математическая модель. Также и в Тетрисе.

Некоторые идеи, применяющиеся в игре:

• Мы используем QtCore.QBasicTimer(), чтобы создать игровой цикл.
• Тетрамино рисуются.
• Фигуры перемещаются по принципу «кубик за кубиком» (не «пиксель за пикселем»).
• Математически, доска – это просто список чисел.

Код содержит четыре класса: Tetris, Board, Tetrominoe и Shape. Класс Tetris организовывает игру. Board – это то, где пишется игровая логика. Класс Tetrominoe содержит имена всех частей тетриса и класс Shape содержит код для частей тетриса.

Код игры Тетрис:

#!/usr/bin/python3
# -*- coding: utf-8 -*-

import sys, random
from PyQt5.QtWidgets import QMainWindow, QFrame, QDesktopWidget, QApplication
from PyQt5.QtCore import Qt, QBasicTimer, pyqtSignal
from PyQt5.QtGui import QPainter, QColor


class Tetris(QMainWindow):

    def __init__(self):
        super().__init__()

        self.initUI()


    def initUI(self):

        self.tboard = Board(self)
        self.setCentralWidget(self.tboard)

        self.statusbar = self.statusBar()
        self.tboard.msg2Statusbar[str].connect(self.statusbar.showMessage)

        self.tboard.start()

        self.resize(180, 380)
        self.center()
        self.setWindowTitle('Tetris')
        self.show()


    def center(self):

        screen = QDesktopWidget().screenGeometry()
        size = self.geometry()
        self.move((screen.width()-size.width())/2,
            (screen.height()-size.height())/2)


class Board(QFrame):

    msg2Statusbar = pyqtSignal(str)

    BoardWidth = 10
    BoardHeight = 22
    Speed = 300

    def __init__(self, parent):
        super().__init__(parent)

        self.initBoard()


    def initBoard(self):

        self.timer = QBasicTimer()
        self.isWaitingAfterLine = False

        self.curX = 0
        self.curY = 0
        self.numLinesRemoved = 0
        self.board = []

        self.setFocusPolicy(Qt.StrongFocus)
        self.isStarted = False
        self.isPaused = False
        self.clearBoard()


    def shapeAt(self, x, y):
        return self.board[(y * Board.BoardWidth) + x]


    def setShapeAt(self, x, y, shape):
        self.board[(y * Board.BoardWidth) + x] = shape


    def squareWidth(self):
        return self.contentsRect().width() // Board.BoardWidth


    def squareHeight(self):
        return self.contentsRect().height() // Board.BoardHeight


    def start(self):

        if self.isPaused:
            return

        self.isStarted = True
        self.isWaitingAfterLine = False
        self.numLinesRemoved = 0
        self.clearBoard()

        self.msg2Statusbar.emit(str(self.numLinesRemoved))

        self.newPiece()
        self.timer.start(Board.Speed, self)


    def pause(self):

        if not self.isStarted:
            return

        self.isPaused = not self.isPaused

        if self.isPaused:
            self.timer.stop()
            self.msg2Statusbar.emit("paused")

        else:
            self.timer.start(Board.Speed, self)
            self.msg2Statusbar.emit(str(self.numLinesRemoved))

        self.update()


    def paintEvent(self, event):

        painter = QPainter(self)
        rect = self.contentsRect()

        boardTop = rect.bottom() - Board.BoardHeight * self.squareHeight()

        for i in range(Board.BoardHeight):
            for j in range(Board.BoardWidth):
                shape = self.shapeAt(j, Board.BoardHeight - i - 1)

                if shape != Tetrominoe.NoShape:
                    self.drawSquare(painter,
                        rect.left() + j * self.squareWidth(),
                        boardTop + i * self.squareHeight(), shape)

        if self.curPiece.shape() != Tetrominoe.NoShape:

            for i in range(4):

                x = self.curX + self.curPiece.x(i)
                y = self.curY - self.curPiece.y(i)
                self.drawSquare(painter, rect.left() + x * self.squareWidth(),
                    boardTop + (Board.BoardHeight - y - 1) * self.squareHeight(),
                    self.curPiece.shape())


    def keyPressEvent(self, event):

        if not self.isStarted or self.curPiece.shape() == Tetrominoe.NoShape:
            super(Board, self).keyPressEvent(event)
            return

        key = event.key()

        if key == Qt.Key_P:
            self.pause()
            return

        if self.isPaused:
            return

        elif key == Qt.Key_Left:
            self.tryMove(self.curPiece, self.curX - 1, self.curY)

        elif key == Qt.Key_Right:
            self.tryMove(self.curPiece, self.curX + 1, self.curY)

        elif key == Qt.Key_Down:
            self.tryMove(self.curPiece.rotateRight(), self.curX, self.curY)

        elif key == Qt.Key_Up:
            self.tryMove(self.curPiece.rotateLeft(), self.curX, self.curY)

        elif key == Qt.Key_Space:
            self.dropDown()

        elif key == Qt.Key_D:
            self.oneLineDown()

        else:
            super(Board, self).keyPressEvent(event)


    def timerEvent(self, event):

        if event.timerId() == self.timer.timerId():

            if self.isWaitingAfterLine:
                self.isWaitingAfterLine = False
                self.newPiece()
            else:
                self.oneLineDown()

        else:
            super(Board, self).timerEvent(event)


    def clearBoard(self):

        for i in range(Board.BoardHeight * Board.BoardWidth):
            self.board.append(Tetrominoe.NoShape)


    def dropDown(self):

        newY = self.curY

        while newY > 0:

            if not self.tryMove(self.curPiece, self.curX, newY - 1):
                break

            newY -= 1

        self.pieceDropped()


    def oneLineDown(self):

        if not self.tryMove(self.curPiece, self.curX, self.curY - 1):
            self.pieceDropped()


    def pieceDropped(self):

        for i in range(4):

            x = self.curX + self.curPiece.x(i)
            y = self.curY - self.curPiece.y(i)
            self.setShapeAt(x, y, self.curPiece.shape())

        self.removeFullLines()

        if not self.isWaitingAfterLine:
            self.newPiece()


    def removeFullLines(self):

        numFullLines = 0
        rowsToRemove = []

        for i in range(Board.BoardHeight):

            n = 0
            for j in range(Board.BoardWidth):
                if not self.shapeAt(j, i) == Tetrominoe.NoShape:
                    n = n + 1

            if n == 10:
                rowsToRemove.append(i)

        rowsToRemove.reverse()


        for m in rowsToRemove:

            for k in range(m, Board.BoardHeight):
                for l in range(Board.BoardWidth):
                        self.setShapeAt(l, k, self.shapeAt(l, k + 1))

        numFullLines = numFullLines + len(rowsToRemove)

        if numFullLines > 0:

            self.numLinesRemoved = self.numLinesRemoved + numFullLines
            self.msg2Statusbar.emit(str(self.numLinesRemoved))

            self.isWaitingAfterLine = True
            self.curPiece.setShape(Tetrominoe.NoShape)
            self.update()


    def newPiece(self):

        self.curPiece = Shape()
        self.curPiece.setRandomShape()
        self.curX = Board.BoardWidth // 2 + 1
        self.curY = Board.BoardHeight - 1 + self.curPiece.minY()

        if not self.tryMove(self.curPiece, self.curX, self.curY):

            self.curPiece.setShape(Tetrominoe.NoShape)
            self.timer.stop()
            self.isStarted = False
            self.msg2Statusbar.emit("Game over")



    def tryMove(self, newPiece, newX, newY):

        for i in range(4):

            x = newX + newPiece.x(i)
            y = newY - newPiece.y(i)

            if x < 0 or x >= Board.BoardWidth or y < 0 or y >= Board.BoardHeight:
                return False

            if self.shapeAt(x, y) != Tetrominoe.NoShape:
                return False

        self.curPiece = newPiece
        self.curX = newX
        self.curY = newY
        self.update()

        return True


    def drawSquare(self, painter, x, y, shape):

        colorTable = [0x000000, 0xCC6666, 0x66CC66, 0x6666CC,
                      0xCCCC66, 0xCC66CC, 0x66CCCC, 0xDAAA00]

        color = QColor(colorTable[shape])
        painter.fillRect(x + 1, y + 1, self.squareWidth() - 2,
            self.squareHeight() - 2, color)

        painter.setPen(color.lighter())
        painter.drawLine(x, y + self.squareHeight() - 1, x, y)
        painter.drawLine(x, y, x + self.squareWidth() - 1, y)

        painter.setPen(color.darker())
        painter.drawLine(x + 1, y + self.squareHeight() - 1,
            x + self.squareWidth() - 1, y + self.squareHeight() - 1)
        painter.drawLine(x + self.squareWidth() - 1,
            y + self.squareHeight() - 1, x + self.squareWidth() - 1, y + 1)


class Tetrominoe(object):

    NoShape = 0
    ZShape = 1
    SShape = 2
    LineShape = 3
    TShape = 4
    SquareShape = 5
    LShape = 6
    MirroredLShape = 7


class Shape(object):

    coordsTable = (
        ((0, 0),     (0, 0),     (0, 0),     (0, 0)),
        ((0, -1),    (0, 0),     (-1, 0),    (-1, 1)),
        ((0, -1),    (0, 0),     (1, 0),     (1, 1)),
        ((0, -1),    (0, 0),     (0, 1),     (0, 2)),
        ((-1, 0),    (0, 0),     (1, 0),     (0, 1)),
        ((0, 0),     (1, 0),     (0, 1),     (1, 1)),
        ((-1, -1),   (0, -1),    (0, 0),     (0, 1)),
        ((1, -1),    (0, -1),    (0, 0),     (0, 1))
    )

    def __init__(self):

        self.coords = [[0,0] for i in range(4)]
        self.pieceShape = Tetrominoe.NoShape

        self.setShape(Tetrominoe.NoShape)


    def shape(self):
        return self.pieceShape


    def setShape(self, shape):

        table = Shape.coordsTable[shape]

        for i in range(4):
            for j in range(2):
                self.coords[i][j] = table[i][j]

        self.pieceShape = shape


    def setRandomShape(self):
        self.setShape(random.randint(1, 7))


    def x(self, index):
        return self.coords[index][0]


    def y(self, index):
        return self.coords[index][1]


    def setX(self, index, x):
        self.coords[index][0] = x


    def setY(self, index, y):
        self.coords[index][1] = y


    def minX(self):

        m = self.coords[0][0]
        for i in range(4):
            m = min(m, self.coords[i][0])

        return m


    def maxX(self):

        m = self.coords[0][0]
        for i in range(4):
            m = max(m, self.coords[i][0])

        return m


    def minY(self):

        m = self.coords[0][1]
        for i in range(4):
            m = min(m, self.coords[i][1])

        return m


    def maxY(self):

        m = self.coords[0][1]
        for i in range(4):
            m = max(m, self.coords[i][1])

        return m


    def rotateLeft(self):

        if self.pieceShape == Tetrominoe.SquareShape:
            return self

        result = Shape()
        result.pieceShape = self.pieceShape

        for i in range(4):

            result.setX(i, self.y(i))
            result.setY(i, -self.x(i))

        return result


    def rotateRight(self):

        if self.pieceShape == Tetrominoe.SquareShape:
            return self

        result = Shape()
        result.pieceShape = self.pieceShape

        for i in range(4):

            result.setX(i, -self.y(i))
            result.setY(i, self.x(i))

        return result


if __name__ == '__main__':

    app = QApplication([])
    tetris = Tetris()
    sys.exit(app.exec_())

Игра немного упрощена для более легкого понимания. Игра начинается сразу же после её запуска. Мы можем приостановить игру, нажав клавишу p. Клавиша Space будет немедленно бросать блок тетриса вниз. Игра идёт на постоянной скорости, ускорение не реализуется. Очки – это число линий, который мы удалили.

self.tboard = Board(self)
self.setCentralWidget(self.tboard)

Экземпляр класса Board создаётся и устанавливается центральным виджетом приложения.

self.statusbar = self.statusBar()
self.tboard.msg2Statusbar[str].connect(self.statusbar.showMessage)

Мы создаём строку состояния, где мы будем отображать сообщения. Мы будем отображать три возможных сообщения: количество уже удалённых линий, сообщение паузы, или сообщение «Игра окончена». msgStatusbar – это пользовательский сигнал, который реализуется в классе Board. showMessage() – это встроенный метод, который отображает сообщение в строке состояния.

self.tboard.start()

Эта строка инициирует игру.

class Board(QFrame):

    msg2Statusbar = pyqtSignal(str)
    ...

Создаётся пользовательский сигнал. msgStatusbar – это сигнал, который срабатывает, когда мы хотим написать сообщение или количество очков в строку состояния.

BoardWidth = 10
BoardHeight = 22
Speed = 300

Это переменные класса Board. BoardWidth и BoardHeight определяют размер доски в блоках. Speed определяет скорость игры. Каждые 300 мс будет начинаться цикл новой игры.

...
self.curX = 0
self.curY = 0
self.numLinesRemoved = 0
self.board = []
...

В методе initBoard() мы инициализируем несколько важных переменных. Переменная self.board – это список чисел от 0 до 7. Она представляет местоположение различных фигур и оставляет фигуры на доске.

def shapeAt(self, x, y):
    return self.board[(y * Board.BoardWidth) + x]

Метод shapeAt() определяет тип фигуры в данном блоке.

def squareWidth(self):
    return self.contentsRect().width() // Board.BoardWidth

Доска может динамически менять размер (например, при изменении размера окна). Как следствие, размер блока может меняться. squareWidth() вычисляет ширину простого квадратика в пикселях и возвращает её. Board.BoardWidth – это размер доски в блоках.

for i in range(Board.BoardHeight):
    for j in range(Board.BoardWidth):
        shape = self.shapeAt(j, Board.BoardHeight - i - 1)

        if shape != Tetrominoe.NoShape:
            self.drawSquare(painter,
                rect.left() + j * self.squareWidth(),
                boardTop + i * self.squareHeight(), shape)

Рисование игры разделяется на два шага. Первым шагом, мы рисуем все фигуры, или оставляем фигуры, которые были сброшены вниз доски. Все квадратики запоминаются в списке переменных self.board. Доступ к переменной получают, используя метод shapeAt().

if self.curPiece.shape() != Tetrominoe.NoShape:

    for i in range(4):

        x = self.curX + self.curPiece.x(i)
        y = self.curY - self.curPiece.y(i)
        self.drawSquare(painter, rect.left() + x * self.squareWidth(),
            boardTop + (Board.BoardHeight - y - 1) * self.squareHeight(),
            self.curPiece.shape())

Следующий шаг – это рисование упавших вниз частей.

elif key == Qt.Key_Right:
    self.tryMove(self.curPiece, self.curX + 1, self.curY)

В методе keyPressEvent(), мы проверяем нажатые клавиши. Если мы нажали клавишу правой стрелки, мы пробуем передвинуть часть вправо. Мы говорим «пробуем», поскольку часть может быть на правом крае.

elif key == Qt.Key_Up:
    self.tryMove(self.curPiece.rotateLeft(), self.curX, self.curY)

Клавиша стрелки вверх будет поворачивать падающую часть влево.

elif key == Qt.Key_Space:
    self.dropDown()

Клавиша «Пробел» будет немедленно бросать падающую часть.

elif key == Qt.Key_D:
    self.oneLineDown()

Нажимая клавишу «d», часть спустится вниз на один блок. Это может быть использовано, чтобы слегка ускорить падение части.

def tryMove(self, newPiece, newX, newY):

    for i in range(4):

        x = newX + newPiece.x(i)
        y = newY - newPiece.y(i)

        if x < 0 or x >= Board.BoardWidth or y < 0 or y >= Board.BoardHeight:
            return False

        if self.shapeAt(x, y) != Tetrominoe.NoShape:
            return False

    self.curPiece = newPiece
    self.curX = newX
    self.curY = newY
    self.update()
    return True

В методе tryMove(), мы пробуем переместить наши фигуры. Если фигура находится на краю доски или примыкает к некоторой другой части, мы возвращаем значение «Ложь». В противном случае, мы перемещаем текущую падающую часть в новую позицию.

def timerEvent(self, event):

    if event.timerId() == self.timer.timerId():

        if self.isWaitingAfterLine:
            self.isWaitingAfterLine = False
            self.newPiece()
        else:
            self.oneLineDown()

    else:
        super(Board, self).timerEvent(event)

В timerEvent (событии таймера), мы либо создаём новую фигуру после предыдущей, которая упала, либо мы передвигаем падающую часть на одну линию вниз.

def clearBoard(self):

    for i in range(Board.BoardHeight * Board.BoardWidth):
        self.board.append(Tetrominoe.NoShape)

Метод clearBoard() очищает доску путём установки Tetrominoe.Noshape на каждый блок доски.

def removeFullLines(self):

    numFullLines = 0
    rowsToRemove = []

    for i in range(Board.BoardHeight):

        n = 0
        for j in range(Board.BoardWidth):
            if not self.shapeAt(j, i) == Tetrominoe.NoShape:
                n = n + 1

        if n == 10:
            rowsToRemove.append(i)

    rowsToRemove.reverse()


    for m in rowsToRemove:

        for k in range(m, Board.BoardHeight):
            for l in range(Board.BoardWidth):
                    self.setShapeAt(l, k, self.shapeAt(l, k + 1))

    numFullLines = numFullLines + len(rowsToRemove)
    ...

Когда фигура падает, мы вызываем метод removeFullLines(). Мы обнаруживаем все полные линии и удаляем их. Обратите внимание, что мы развернули порядок удаляемых линий. В противном случае, это не будет работать правильно. В нашем случае, мы используем «никакую» гравитацию. Это означает, что части могут парить над пустыми промежутками.

def newPiece(self):

    self.curPiece = Shape()
    self.curPiece.setRandomShape()
    self.curX = Board.BoardWidth // 2 + 1
    self.curY = Board.BoardHeight - 1 + self.curPiece.minY()

    if not self.tryMove(self.curPiece, self.curX, self.curY):

        self.curPiece.setShape(Tetrominoe.NoShape)
        self.timer.stop()
        self.isStarted = False
        self.msg2Statusbar.emit("Game over")

Метод newPiece() случайным образом создаёт новую часть тетриса. Если часть не может прийти в свою начальную позицию, игра заканчивается.

class Tetrominoe(object):
    NoShape = 0
    ZShape = 1
    SShape = 2
    LineShape = 3
    TShape = 4
    SquareShape = 5
    LShape = 6
    MirroredLShape = 7

Класс Tetrominoe содержит в себе имена всех возможных фигур. Мы также имеем NoShape для пустого пространства.

class Shape(object):

    coordsTable = (
        ((0, 0),     (0, 0),     (0, 0),     (0, 0)),
        ((0, -1),    (0, 0),     (-1, 0),    (-1, 1)),
        ...
    )
    ...

Класс Shape хранит информацию о частях тетриса.

Набор coordsTable содержит в себе всевозможные значения координат наших частей тетриса. Это шаблон, из которого все части берут свои значения координат.

self.coords = [[0,0] for i in range(4)]

После создания, мы создаём пустой список координат. Список будет хранить координаты частей тетриса.

Изображение выше поможет понять значения координат. Для примера, набор (0, -1), (0, 0), (-1, 0), (-1, -1) представляет S-фигуру. Схема иллюстрирует фигуру.

def rotateLeft(self):

    if self.pieceShape == Tetrominoe.SquareShape:
        return self

    result = Shape()
    result.pieceShape = self.pieceShape

    for i in range(4):

        result.setX(i, self.y(i))
        result.setY(i, -self.x(i))

    return result

Метод rotateLeft() поворачивает часть влево. Квадрат не должен поворачиваться. Вот почему мы просто возвращаем ссылку на текущий объект. Новая часть создаётся и её координаты устанавливаются в одну из повернутых частей.

Это была игра Тетрис в PyQt5 (а также перевод последней части туториала от zetcode).

The Python Tetris Game is a GUI based title matching puzzle game which is very easy to understand and use. Talking about the gameplay it’s all same as the real one.

The user has to manage the random sequence of Tetriminos. This Tetris Game In Python project, I will teach you on How To Make A Tetris Game In Python.

Tetris Python Code : Project Information

A Tetris Game Python player has steps to be follow of playing the game, first the player has to move each one sideways and rotate quarter-turns to form a solid horizontal line without leaving gaps.

It disappears whenever such lines are formed. The user can only enter to next level if they cross the specific number by the game rules.

As the game progresses, the Tetriminos falls faster and faster. As a result, the game ends when the stack of Tetriminos reaches to the top of the field and no new Tetriminos are able to enter.

Anyway if you want level up your knowledge in programming especially games in python, try this new article I’ve made for you Code For Game in Python: Python Game Projects With Source Code

This Tetris Game In Python also includes a downloadable Tetris Game Source Code In Python, just find the downloadable source code below and click to start downloading.

To start Create Tetris In Python, makes sure that you have PyCharm IDE installed in you computer.

By the way if you are new to python programming and you don’t know what would be the the Python IDE to use, I have here a list of Best Python IDE for Windows, Linux, Mac OS that will suit for you. I also have here How to Download and Install Latest Version of Python on Windows.

Steps on how to create a Tetris Game Code in Python

Code Explanations

1. Installation of Pygame

Code:

pip install pygame

2. Importing PyGame

Code:

import pygame

3. The Code Given Below Is For The Class Game

Code:

    class Game(object):
    def main(self, screen):
        clock = pygame.time.Clock()

        self.matris = Matris()
        
        screen.blit(construct_nightmare(screen.get_size()), (0,0))
        
        matris_border = Surface((MATRIX_WIDTH*BLOCKSIZE+BORDERWIDTH*2, VISIBLE_MATRIX_HEIGHT*BLOCKSIZE+BORDERWIDTH*2))
        matris_border.fill(BORDERCOLOR)
        screen.blit(matris_border, (MATRIS_OFFSET,MATRIS_OFFSET))
        
        self.redraw()

        while True:
            try:
                timepassed = clock.tick(50)
                if self.matris.update((timepassed / 1000.) if not self.matris.paused else 0):
                    self.redraw()
            except GameOver:
                return
      

    def redraw(self):
        if not self.matris.paused:
            self.blit_next_tetromino(self.matris.surface_of_next_tetromino)
            self.blit_info()

            self.matris.draw_surface()

        pygame.display.flip()


    def blit_info(self):
        textcolor = (255, 255, 255)
        font = pygame.font.Font(None, 30)
        width = (WIDTH-(MATRIS_OFFSET+BLOCKSIZE*MATRIX_WIDTH+BORDERWIDTH*2)) - MATRIS_OFFSET*2

        def renderpair(text, val):
            text = font.render(text, True, textcolor)
            val = font.render(str(val), True, textcolor)

            surf = Surface((width, text.get_rect().height + BORDERWIDTH*2), pygame.SRCALPHA, 32)

            surf.blit(text, text.get_rect(top=BORDERWIDTH+10, left=BORDERWIDTH+10))
            surf.blit(val, val.get_rect(top=BORDERWIDTH+10, right=width-(BORDERWIDTH+10)))
            return surf

        scoresurf = renderpair("Score", self.matris.score)
        levelsurf = renderpair("Level", self.matris.level)
        linessurf = renderpair("Lines", self.matris.lines)
        combosurf = renderpair("Combo", "x{}".format(self.matris.combo))

        height = 20 + (levelsurf.get_rect().height + 
                       scoresurf.get_rect().height +
                       linessurf.get_rect().height + 
                       combosurf.get_rect().height )

        area = Surface((width, height))
        area.fill(BORDERCOLOR)
        area.fill(BGCOLOR, Rect(BORDERWIDTH, BORDERWIDTH, width-BORDERWIDTH*2, height-BORDERWIDTH*2))

        area.blit(levelsurf, (0,0))
        area.blit(scoresurf, (0, levelsurf.get_rect().height))
        area.blit(linessurf, (0, levelsurf.get_rect().height + scoresurf.get_rect().height))
        area.blit(combosurf, (0, levelsurf.get_rect().height + scoresurf.get_rect().height + linessurf.get_rect().height))

        screen.blit(area, area.get_rect(bottom=HEIGHT-MATRIS_OFFSET, centerx=TRICKY_CENTERX))


    def blit_next_tetromino(self, tetromino_surf):
        area = Surface((BLOCKSIZE*5, BLOCKSIZE*5))
        area.fill(BORDERCOLOR)
        area.fill(BGCOLOR, Rect(BORDERWIDTH, BORDERWIDTH, BLOCKSIZE*5-BORDERWIDTH*2, BLOCKSIZE*5-BORDERWIDTH*2))

        areasize = area.get_size()[0]
        tetromino_surf_size = tetromino_surf.get_size()[0]
        # ^^ I'm assuming width and height are the same

        center = areasize/2 - tetromino_surf_size/2
        area.blit(tetromino_surf, (center, center))

        screen.blit(area, area.get_rect(top=MATRIS_OFFSET, centerx=TRICKY_CENTERX))

Explanation:

In this class which is declare the following module:

• main – The main module of the class Game
• redraw – In this module which is the draw surface
• blit_info – In this module which is declaring the text color, font and width
• renderpair – In this module which is displayed the score, level ,lines and combo of the game in changing process of time.
• blit_next_tetromino – In this module which is declaring the size of the surface

Code:

class Menu(object):
    running = True
    def main(self, screen):
        clock = pygame.time.Clock()
        menu = kezmenu.KezMenu(
            ['Play!', lambda: Game().main(screen)],
            ['Quit', lambda: setattr(self, 'running', False)],
        )
        menu.position = (50, 50)
        menu.enableEffect('enlarge-font-on-focus', font=None, size=60, enlarge_factor=1.2, enlarge_time=0.3)
        menu.color = (255,255,255)
        menu.focus_color = (40, 200, 40)

        nightmare = construct_nightmare(screen.get_size())
        highscoresurf = self.construct_highscoresurf()

        timepassed = clock.tick(30) / 1000.

        while self.running:
            events = pygame.event.get()

            for event in events:
                if event.type == pygame.QUIT:
                    exit()

            menu.update(events, timepassed)

            timepassed = clock.tick(30) / 1000.

            if timepassed > 1: # A game has most likely been played 
                highscoresurf = self.construct_highscoresurf()

            screen.blit(nightmare, (0,0))
            screen.blit(highscoresurf, highscoresurf.get_rect(right=WIDTH-50, bottom=HEIGHT-50))
            menu.draw(screen)
            pygame.display.flip()

    def construct_highscoresurf(self):
        font = pygame.font.Font(None, 50)
        highscore = load_score()
        text = "Highscore: {}".format(highscore)
        return font.render(text, True, (255,255,255))

def construct_nightmare(size):
    surf = Surface(size)

    boxsize = 8
    bordersize = 1
    vals = '1235' # only the lower values, for darker colors and greater fear
    arr = pygame.PixelArray(surf)
    for x in range(0, len(arr), boxsize):
        for y in range(0, len(arr[x]), boxsize):

            color = int(''.join([random.choice(vals) + random.choice(vals) for _ in range(3)]), 16)

            for LX in range(x, x+(boxsize - bordersize)):
                for LY in range(y, y+(boxsize - bordersize)):
                    if LX < len(arr) and LY < len(arr[x]):
                        arr[LX][LY] = color
    del arr
    return surf

Explanation:

In this class which is declare the following module:

• main – The main module of the class menu that you see in the first page when you run the game.
• construct_highscoresurf – In this module which is declaring the font design and highscore of the game.
• construct_nightmare – In this module which is declaring the size of the surface and its conditions.

5. The Code Given Below Is For The Class Game Over

Code:

class GameOver(Exception):
    """Exception used for its control flow properties"""

def get_sound(filename):
    return pygame.mixer.Sound(os.path.join(os.path.dirname(__file__), "resources", filename))

BGCOLOR = (15, 15, 20)
BORDERCOLOR = (140, 140, 140)

BLOCKSIZE = 30
BORDERWIDTH = 10

MATRIS_OFFSET = 20

MATRIX_WIDTH = 10
MATRIX_HEIGHT = 22

LEFT_MARGIN = 340

WIDTH = MATRIX_WIDTH*BLOCKSIZE + BORDERWIDTH*2 + MATRIS_OFFSET*2 + LEFT_MARGIN
HEIGHT = (MATRIX_HEIGHT-2)*BLOCKSIZE + BORDERWIDTH*2 + MATRIS_OFFSET*2

TRICKY_CENTERX = WIDTH-(WIDTH-(MATRIS_OFFSET+BLOCKSIZE*MATRIX_WIDTH+BORDERWIDTH*2))/2

VISIBLE_MATRIX_HEIGHT = MATRIX_HEIGHT - 2

Explanation:

In this class which is declare the following module:

• get_sound – This module which is getting the sound when you are already game over.

Downloadable Source Code

I have here the list of Best Python Project with Source code free to download for free, I hope this can help you a lot.

Summary

The Tetris In Python Code is written in python programming language, Python is very smooth to research the syntax emphasizes readability and it is able to reduces time ingesting in developing.

Also in this tutorial is the simplest way for the beginners or the student to enhance their logical skills in programming. and also in this game project is the way for the students or beginners in designing and developing games.

Inquiries

If you have any questions or suggestions about Python Tetris Game with Source Code, please feel free to leave a comment below.

24 min read

Apply for Byte Academy’s Coding Bootcamp with ISA options

pygame is a Free and Open Source python programming language library for making multimedia applications like games built on top of the excellent SDL (Simple DirectMedia Layer) library. Simple DirectMedia Layer is a cross-platform development library designed to provide low-level access to audio, keyboard, mouse, joystick, and graphics hardware via OpenGL and Direct3D. Like SDL, pygame is highly portable and runs on nearly every platform and operating system. Millions of people have downloaded pygame itself, which is a whole lot of bits flying across the interwebs.

pygame.org (the website) welcomes all Python game, art, music, sound, video and multimedia projects.

History of Pygame

Pygame was originally written by Pete Shinners to replace PySDL after its development stalled. It has been a community project since 2000 and is released under the open source free software GNU Lesser General Public License.

Pygame Installation

Pygame requires Python. The best way to install pygame is with the pip tool (which is what python uses to install packages). Note, this comes with python in recent versions. We use the —user flag to tell it to install into the home directory, rather than globally.

Installation on Windows

For Windows, make sure you add Python 3.6.1 in the PATH, from there, you run the below command:

python3 -m pip install -U pygame —user

Installation on Ubuntu

For Ubuntu and many Linux distributions, they have their own Pygame package. Run the below command for these operating systems:

sudo apt-get install python3-pygame

Installation on Mac

There are issues pertaining in installation of Pygame on Mac. But it is available, if you start a virtual environment in your Mac system using the below command:

python3 —m virtualenv anenv

Activate the virtual environment:

. ./anenv/bin/activate

The venvdotapp helps the python be a Mac ‘app’, so that the pygame window can get focus

python —m pip install venvdotapp
venvdotapp
python —m pip install pygame

Features of pygame

• Silliness built in. Pygame is meant to make things fun. New silliness is added every 3.1415 seconds. Silliness is a fun feature added into pygame package, in order to denote the simplicity in coding a game using pygame.
• Does not require OpenGL. With many people having broken OpenGL setups, requiring OpenGL exclusively will cut into your user base significantly. Pygame uses either opengl, directx, windib, X11, linux frame buffer, and many other different backends… including an ASCII art backend! OpenGL is often broken on linux systems, and also on windows systems — which is why professional games use multiple backends.
• Multi-core CPUs can be used easily. With dual-core CPUs common, and 8 core CPUs cheaply available on desktop systems, making use of multi-core CPUs allows you to do more in your game. Selected pygame functions release the dreaded python GIL, which is something you can do from C code.
• Uses optimized C, and Assembly code for core functions. C code is often 10-20 times faster than python code, and assembly code can easily be 100x or more times faster than python code.
• Comes with many Operating systems. Just an apt-get, emerge, pkg_add, or yast install away.  No need to mess with installing it outside of your operating systems package manager. Comes with binary installers (and uninstallers) for Windows or MacOS X.
• Truly portable. Supports Linux (pygame comes with most mainstream linux distributions), Windows (95,98,me,2000,XP,vista, 64bit windows etc), Windows CE, BeOS, MacOS, Mac OS X, FreeBSD, NetBSD, OpenBSD, BSD/OS, Solaris, IRIX, and QNX.
• It’s Simple and easy to use. Kids and adults make games with pygame.
• Does not require a GUI to use all functions. You can use pygame without a monitor — like if you want to use it just to process images, get joystick input, or play sounds.
• A small amount of code. It does not have hundreds of thousands of lines of code for things you won’t use anyway. The core is kept simple, and extra things like GUI libraries, and effects are developed separately outside of pygame.

Pros of Pygame

• Easy Python syntax
• Pygame uses Python as its scripting language. Python is widely considered one of the easiest languages to grasp even for beginners.
• Very easy to understand
• The API is very straightforward.
• Good canvas system
• Pygame has a drawing system that allows the user to create and draw on an unlimited number of canvases.

Cons of Pygame

• Pygame does not scale well with large project games, but it works well with small games and hobby projects. For small-scale game development, pygame is a good option.
• You might have a hard time finding out the basic functions that you require and their workings, but most of the functions in pygame has been incorporated as small apps across. You can get github programs related to Pygame. All those functions and their descriptions will be given in their code.
• As I have said before, as there is not much description about the functions and their uses, Pygame also lacks the Pygame community and Pygame developers. Those who develop their small-scale applications in Pygame, put up in Github, but the reliability of those developers is still doubtful

• Most of the game that we play, has a certain amount of Physics, AI, networking and inputs involved. In Pygame, we won’t be having these complexities as it is not supported by Pygame.
• Pygame uses an old version of SDL, hence it can be said to be outdated. Some of the features used by SDL2 are also not supported in Pygame. But still remember Old is Gold.

Let us build a Tetris game using Pygame

from random import randrange as rand

import pygame, sys

import getpass

# The configuration

cell_size =    18

cols =    10

rows =    22

maxfps =     30

colors = [

(0,   0, 0  ),

(255, 85,  85),

(100, 200, 115),

(120, 108, 245),

(255, 140, 50 ),

(50,  120, 52 ),

(146, 202, 73 ),

(150, 161, 218 ),

(35,  35, 35)

]

# Define the shapes of the single parts

tetris_shapes = [

   [[1, 1, 1],

    [0, 1, 0]],

   [[0, 2, 2],

    [2, 2, 0]],

   [[3, 3, 0],

    [0, 3, 3]],

   [[4, 0, 0],

    [4, 4, 4]],

   [[0, 0, 5],

    [5, 5, 5]],

   [[6, 6, 6, 6]],

   [[7, 7],

    [7, 7]]

]

def rotate_clockwise(shape):

   return [ [ shape[y][x]

   for y in range(len(shape)) ]

   for x in range(len(shape[0]) — 1, -1, -1) ]

def check_collision(board, shape, offset):

   off_x, off_y = offset

   for cy, row in enumerate(shape):

   for cx, cell in enumerate(row):

   try:

   if cell and board[ cy + off_y ][ cx + off_x ]:

   return True

   except IndexError:

   return True

   return False

def remove_row(board, row):

   del board[row]

   return [[0 for i in range(cols)]] + board

def join_matrixes(mat1, mat2, mat2_off):

   off_x, off_y = mat2_off

   for cy, row in enumerate(mat2):

   for cx, val in enumerate(row):

   mat1[cy+off_y-1    ][cx+off_x] += val

   return mat1

def new_board():

   board = [ [ 0 for x in range(cols) ]

   for y in range(rows) ]

   board += [[ 1 for x in range(cols)]]

   return board

class TetrisApp(object):

   def __init__(self):

   pygame.init()

   pygame.key.set_repeat(250,25)

   self.width = cell_size*(cols+6)

   self.height = cell_size*rows

   self.rlim = cell_size*cols

   self.bground_grid = [[ 8 if x%2==y%2 else 0 for x in range(cols)] for y in range(rows)]

   self.default_font =  pygame.font.Font(

   pygame.font.get_default_font(), 12)

   self.screen = pygame.display.set_mode((self.width, self.height))

   pygame.event.set_blocked(pygame.MOUSEMOTION) # We do not need

                                             # mouse movement

                                             # events, so we

                                             # block them.

   self.next_stone = tetris_shapes[rand(len(tetris_shapes))]

   self.init_game()

   def new_stone(self):

   self.stone = self.next_stone[:]

   self.next_stone = tetris_shapes[rand(len(tetris_shapes))]

   self.stone_x = int(cols / 2 — len(self.stone[0])/2)

   self.stone_y = 0

   if check_collision(self.board,

                   self.stone,

                   (self.stone_x, self.stone_y)):

   self.gameover = True

   def init_game(self):

   self.board = new_board()

   self.new_stone()

   self.level = 1

   self.score = 0

   self.lines = 0

   pygame.time.set_timer(pygame.USEREVENT+1, 1000)

   def disp_msg(self, msg, topleft):

   x,y = topleft

   for line in msg.splitlines():

   self.screen.blit(

   self.default_font.render(

   line,

   False,

   (255,255,255),

   (0,0,0)),

   (x,y))

   y+=14

   def center_msg(self, msg):

   for i, line in enumerate(msg.splitlines()):

   msg_image =  self.default_font.render(line, False,

   (255,255,255), (0,0,0))

   msgim_center_x, msgim_center_y = msg_image.get_size()

   msgim_center_x //= 2

   msgim_center_y //= 2

   self.screen.blit(msg_image, (

     self.width // 2-msgim_center_x,

     self.height // 2-msgim_center_y+i*22))

   def draw_matrix(self, matrix, offset):

   off_x, off_y  = offset

   for y, row in enumerate(matrix):

   for x, val in enumerate(row):

   if val:

   pygame.draw.rect(

   self.screen,

   colors[val],

   pygame.Rect(

   (off_x+x) *

     cell_size,

   (off_y+y) *

     cell_size,

   cell_size,

   cell_size),0)

   def add_cl_lines(self, n):

   linescores = [0, 40, 100, 300, 1200]

   self.lines += n

   self.score += linescores[n] * self.level

   if self.lines >= self.level*6:

   self.level += 1

   newdelay = 1000-50*(self.level-1)

   newdelay = 100 if newdelay < 100 else newdelay

   pygame.time.set_timer(pygame.USEREVENT+1, newdelay)

   def move(self, delta_x):

   if not self.gameover and not self.paused:

   new_x = self.stone_x + delta_x

   if new_x < 0:

   new_x = 0

   if new_x > cols — len(self.stone[0]):

   new_x = cols — len(self.stone[0])

   if not check_collision(self.board,

                       self.stone,

                       (new_x, self.stone_y)):

   self.stone_x = new_x

   def quit(self):

   self.center_msg(«Exiting…»)

   pygame.display.update()

   sys.exit()

   def drop(self, manual):

   if not self.gameover and not self.paused:

   self.score += 1 if manual else 0

   self.stone_y += 1

   if check_collision(self.board,

                   self.stone,

                   (self.stone_x, self.stone_y)):

   self.board = join_matrixes(

     self.board,

     self.stone,

     (self.stone_x, self.stone_y))

   self.new_stone()

   cleared_rows = 0

   while True:

   for i, row in enumerate(self.board[:-1]):

   if 0 not in row:

   self.board = remove_row(

     self.board, i)

   cleared_rows += 1

   break

   else:

   break

   self.add_cl_lines(cleared_rows)

   return True

   return False

   def insta_drop(self):

   if not self.gameover and not self.paused:

   while(not self.drop(True)):

   pass

   def rotate_stone(self):

   if not self.gameover and not self.paused:

   new_stone = rotate_clockwise(self.stone)

   if not check_collision(self.board,

                       new_stone,

                       (self.stone_x, self.stone_y)):

   self.stone = new_stone

   def toggle_pause(self):

   self.paused = not self.paused

   def start_game(self):

   if self.gameover:

   self.init_game()

   self.gameover = False

   def run(self):

   key_actions = {

   ‘ESCAPE’:    self.quit,

   ‘LEFT’:    lambda:self.move(-1),

   ‘RIGHT’:    lambda:self.move(+1),

   ‘DOWN’:    lambda:self.drop(True),

   ‘UP’:    self.rotate_stone,

   ‘p’:    self.toggle_pause,

   ‘SPACE’:    self.start_game,

   ‘RETURN’:    self.insta_drop

   }

   self.gameover = False

   self.paused = False

   dont_burn_my_cpu = pygame.time.Clock()

   while 1:

   self.screen.fill((0,0,0))

   if self.gameover:

   self.center_msg(«»»Game Over!nYour score: %d

Press space to continue»»» % self.score)

   else:

   if self.paused:

   self.center_msg(«Paused»)

   else:

   pygame.draw.line(self.screen,

   (255,255,255),

   (self.rlim+1, 0),

   (self.rlim+1, self.height-1))

   self.disp_msg(«Next:», (

   self.rlim+cell_size,

   2))

   self.disp_msg(«Score: %dnnLevel: %d

nLines: %d» % (self.score, self.level, self.lines),

   (self.rlim+cell_size, cell_size*5))

   self.draw_matrix(self.bground_grid, (0,0))

   self.draw_matrix(self.board, (0,0))

   self.draw_matrix(self.stone,

   (self.stone_x, self.stone_y))

   self.draw_matrix(self.next_stone,

   (cols+1,2))

   pygame.display.update()

   for event in pygame.event.get():

   if event.type == pygame.USEREVENT+1:

   self.drop(False)

   elif event.type == pygame.QUIT:

   self.quit()

   elif event.type == pygame.KEYDOWN:

   for key in key_actions:

   if event.key == eval(«pygame.K_»

   +key):

   key_actions[key]()

   dont_burn_my_cpu.tick(maxfps)

if __name__ == ‘__main__’:

   s = getpass.getpass()

   App = TetrisApp()

  App.run()

Snapshots of Tetris Game

Running the Python Tetris program from the Ubuntu terminal

The Tetris game will open in the new window, which will allow us to use the arrow keys of the keyboard

The game continues… So does the fun.

Happy Gaming!

Want to expertise Python? Checkout Intro to Python and Python bootcamp offered by Byte Academy.

Topics:

coding exercises

Python

Programming Tips