Тетрис на Python: Создание игры для начинающих

Создание игры Тетрис на Python: пошаговое руководство

Разработка собственной игры представляет собой эффективный способ совершенствования навыков программирования. Изучение Python через практические проекты позволяет глубже понять возможности языка. Классическая игра Тетрис сочетает интересную игровую механику с относительно простой реализацией графики.

Данное руководство содержит подробный разбор создания полноценной игры Тетрис на Python. Мы используем библиотеку Pygame для обработки графики и пользовательских событий. Вы получите готовый рабочий код и понимание всех этапов разработки.

Подготовка к разработке

Системные требования

Для создания игры Тетрис потребуется:

Python версии 3.x или выше
Библиотека Pygame для отрисовки графики
Базовые знания объектно-ориентированного программирования

Установка необходимых компонентов

Библиотека Pygame устанавливается через менеджер пакетов pip:

pip install pygame

После установки библиотека станет доступна для импорта в проекте. Pygame предоставляет инструменты для создания окон, обработки событий, рисования графических примитивов и воспроизведения звука.

Архитектура игры Тетрис

Основные этапы разработки

Процесс создания игры включает несколько ключевых этапов:

Инициализация игрового окна и настройка параметров
Определение геометрии фигур тетрамино
Реализация механики падения и перемещения фигур
Проверка коллизий с границами поля и другими блоками
Система удаления заполненных горизонтальных линий
Обработка пользовательского ввода для управления
Добавление системы подсчета очков и экрана окончания игры

Структура данных игрового поля

Игровое поле представляется двумерным массивом. Каждая ячейка содержит информацию о цвете блока или остается пустой. Размеры поля определяются константами, что позволяет легко изменять масштаб игры.

Инициализация игрового окна

Настройка основных параметров

import pygame
import random

# Инициализация Pygame
pygame.init()

# Размеры окна и сетки
SCREEN_WIDTH = 300
SCREEN_HEIGHT = 600
BLOCK_SIZE = 30

# Цветовая палитра
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
COLORS = [
    (0, 255, 255),  # I
    (255, 165, 0),  # L
    (0, 0, 255),    # J
    (255, 255, 0),  # O
    (0, 255, 0),    # S
    (128, 0, 128),  # T
    (255, 0, 0)     # Z
]

# Настройка окна
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
pygame.display.set_caption("Тетрис на Python")

Константы определяют размеры игрового окна и блоков. Массив COLORS содержит цвета для каждого типа фигуры. Pygame.init() инициализирует все модули библиотеки.

Создание игрового экрана

Функция pygame.display.set_mode() создает окно с заданными размерами. Метод set_caption() устанавливает заголовок окна. Эти настройки формируют визуальную основу игры.

Определение фигур тетрамино

Геометрия классических фигур

FIGURES = [
    [[1, 1, 1, 1]],  # I
    [[1, 0, 0],
     [1, 1, 1]],    # J
    [[0, 0, 1],
     [1, 1, 1]],    # L
    [[1, 1],
     [1, 1]],       # O
    [[0, 1, 1],
     [1, 1, 0]],    # S
    [[0, 1, 0],
     [1, 1, 1]],    # T
    [[1, 1, 0],
     [0, 1, 1]]     # Z
]

Каждая фигура представлена двумерным массивом. Единицы обозначают заполненные блоки, нули - пустые ячейки. Эта структура данных упрощает проверку коллизий и отрисовку фигур.

Система поворотов фигур

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

Класс игровой фигуры

Базовая структура класса Figure

class Figure:
    def __init__(self, x, y):
        self.x = x
        self.y = y
        self.type = random.randint(0, len(FIGURES) - 1)
        self.color = COLORS[self.type]
        self.rotation = 0

    def shape(self):
        return FIGURES[self.type][self.rotation % len(FIGURES[self.type])]

    def rotate(self):
        self.rotation = (self.rotation + 1) % len(FIGURES[self.type])

Класс Figure инкапсулирует данные о позиции фигуры, её типе и текущем угле поворота. Метод shape() возвращает текущую геометрию фигуры с учетом поворота.

Методы управления фигурой

Метод rotate() изменяет состояние поворота фигуры. Использование модульной арифметики обеспечивает циклический переход между состояниями. Координаты x и y определяют позицию фигуры на игровом поле.

Основной класс игры

Инициализация игрового состояния

class Tetris:
    def __init__(self, height, width):
        self.height = height
        self.width = width
        self.field = [[0 for _ in range(width)] for _ in range(height)]
        self.figure = None
        self.score = 0

    def new_figure(self):
        self.figure = Figure(self.width // 2 - 1, 0)

Класс Tetris управляет общим состоянием игры. Двумерный массив field представляет игровое поле. Метод new_figure() создает новую фигуру в верхней центральной части поля.

Система проверки коллизий

def intersects(self):
    shape = self.figure.shape()
    for y, row in enumerate(shape):
        for x, cell in enumerate(row):
            if cell:
                if (self.figure.y + y >= self.height or
                    self.figure.x + x < 0 or
                    self.figure.x + x >= self.width or
                    self.field[self.figure.y + y][self.figure.x + x]):
                    return True
    return False

Метод intersects() проверяет пересечение фигуры с границами поля и размещенными блоками. Функция возвращает True при обнаружении коллизии.

Механика игрового процесса

Фиксация фигур на поле

def freeze(self):
    shape = self.figure.shape()
    for y, row in enumerate(shape):
        for x, cell in enumerate(row):
            if cell:
                self.field[self.figure.y + y][self.figure.x + x] = self.figure.color
    self.clear_lines()
    self.new_figure()
    if self.intersects():
        self.__init__(self.height, self.width)  # Game Over

Метод freeze() размещает блоки упавшей фигуры на игровом поле. После фиксации проверяются заполненные линии, создается новая фигура. При невозможности размещения новой фигуры игра перезапускается.

Удаление заполненных линий

def clear_lines(self):
    lines_cleared = 0
    for i in range(self.height - 1, -1, -1):
        if all(self.field[i]):
            del self.field[i]
            self.field.insert(0, [0 for _ in range(self.width)])
            lines_cleared += 1
    self.score += lines_cleared ** 2

Система подсчета очков основана на количестве одновременно удаленных линий. Квадратичная зависимость поощряет удаление нескольких линий за один ход. Новые пустые строки добавляются в верхнюю часть поля.

Основной игровой цикл

Инициализация игрового процесса

game = Tetris(SCREEN_HEIGHT // BLOCK_SIZE, SCREEN_WIDTH // BLOCK_SIZE)
clock = pygame.time.Clock()
fall_speed = 500
last_move_down = pygame.time.get_ticks()

running = True
game.new_figure()

Создается экземпляр игры с размерами, рассчитанными исходя из размеров экрана и блоков. Объект clock контролирует частоту обновления экрана. Переменная fall_speed определяет скорость падения фигур.

Обработка пользовательского ввода

for event in pygame.event.get():
    if event.type == pygame.QUIT:
        running = False
    elif event.type == pygame.KEYDOWN:
        if event.key == pygame.K_LEFT:
            game.figure.x -= 1
            if game.intersects():
                game.figure.x += 1
        elif event.key == pygame.K_RIGHT:
            game.figure.x += 1
            if game.intersects():
                game.figure.x -= 1
        elif event.key == pygame.K_DOWN:
            game.figure.y += 1
            if game.intersects():
                game.figure.y -= 1
        elif event.key == pygame.K_UP:
            game.figure.rotate()
            if game.intersects():
                game.figure.rotate()

Система управления реагирует на нажатия клавиш. При обнаружении коллизии движение отменяется. Стрелки влево и вправо перемещают фигуру горизонтально, стрелка вниз ускоряет падение, стрелка вверх вращает фигуру.

Автоматическое падение фигур

if pygame.time.get_ticks() - last_move_down > fall_speed:
    game.figure.y += 1
    if game.intersects():
        game.figure.y -= 1
        game.freeze()
    last_move_down = pygame.time.get_ticks()

Таймер контролирует автоматическое движение фигур вниз. При невозможности дальнейшего падения фигура фиксируется на поле. Скорость падения можно изменять для регулировки сложности.

Отрисовка графики

Рендеринг игрового поля

for y in range(game.height):
    for x in range(game.width):
        if game.field[y][x]:
            pygame.draw.rect(
                screen,
                game.field[y][x],
                [x * BLOCK_SIZE, y * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE]
            )

Двойной цикл обходит все ячейки игрового поля. Заполненные ячейки отрисовываются как цветные прямоугольники. Размер и позиция каждого блока рассчитываются на основе координат в сетке.

Отображение активной фигуры

shape = game.figure.shape()
for y, row in enumerate(shape):
    for x, cell in enumerate(row):
        if cell:
            pygame.draw.rect(
                screen,
                game.figure.color,
                [(game.figure.x + x) * BLOCK_SIZE, (game.figure.y + y) * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE]
            )

Падающая фигура отрисовывается поверх игрового поля. Координаты блоков фигуры складываются с её позицией на поле. Это обеспечивает корректное отображение фигуры в движении.

Дополнительные возможности

Система подсчета очков

Для отображения текущего счета можно использовать модуль pygame.font:

font = pygame.font.Font(None, 36)
score_text = font.render(f"Счет: {game.score}", True, WHITE)
screen.blit(score_text, (10, 10))

Текст с очками выводится в верхней части экрана. Счет обновляется при удалении линий. Различные шрифты и размеры позволяют настроить внешний вид интерфейса.

Экран завершения игры

При заполнении верхней части поля можно отображать сообщение о завершении игры:

if game_over:
    game_over_text = font.render("GAME OVER", True, WHITE)
    screen.blit(game_over_text, (SCREEN_WIDTH//2 - 80, SCREEN_HEIGHT//2))

Расширение функциональности

Добавление звуковых эффектов

Pygame.mixer позволяет воспроизводить аудиофайлы:

pygame.mixer.init()
line_clear_sound = pygame.mixer.Sound("line_clear.wav")

Звуки можно проигрывать при удалении линий, повороте фигур или завершении игры. Это значительно улучшает игровой опыт.

Настройка уровней сложности

Изменение скорости падения фигур создает различные уровни сложности:

level = game.score // 10 + 1
fall_speed = max(50, 500 - level * 50)

Скорость увеличивается с ростом счета. Минимальное значение предотвращает слишком быстрое падение фигур.

Предпросмотр следующей фигуры

Отображение следующей фигуры повышает стратегическую составляющую игры:

next_figure = Figure(0, 0)
# Отрисовка в отдельной области экрана

Часто задаваемые вопросы

Изменение размеров игрового поля

Размеры поля настраиваются через константы SCREEN_WIDTH, SCREEN_HEIGHT и BLOCK_SIZE. Увеличение этих значений создает более просторное игровое поле.

Добавление музыкального сопровождения

Библиотека pygame.mixer поддерживает воспроизведение музыкальных файлов различных форматов. Фоновая музыка создается через pygame.mixer.music.load() и pygame.mixer.music.play().

Различные уровни сложности

Сложность регулируется изменением переменной fall_speed. Меньшие значения ускоряют падение фигур. Можно также изменять частоту появления сложных фигур.

Адаптация для мобильных устройств

Для мобильных платформ рекомендуется использовать фреймворки Kivy или BeeWare. Они предоставляют инструменты для создания кроссплатформенных приложений с сенсорным управлением.

Оконный режим с кнопками управления

Графические кнопки создаются как прямоугольные области на экране. События pygame.MOUSEBUTTONDOWN обрабатывают клики по кнопкам. Это позволяет создать альтернативный способ управления игрой.

Реализация мультиплеера

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

Заключение

Представленное руководство содержит полный рабочий проект игры Тетрис на Python с использованием библиотеки Pygame. Код можно модифицировать, добавляя новые функции, изменяя внешний вид или улучшая игровую механику.

Создание игр развивает логическое мышление и практические навыки программирования. Этот проект демонстрирует основные принципы разработки игр: обработку событий, управление состоянием, отрисовку графики и реализацию игровой логики.