Этот код запускает Тетрис на Python: 
import pygame
import random

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

# Цвета
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
CYAN = (0, 255, 255)      # I-форма
YELLOW = (255, 255, 0)    # O-форма
PURPLE = (160, 32, 240)   # T-форма
GREEN = (0, 255, 0)       # S-форма
RED = (255, 0, 0)         # Z-форма
ORANGE = (255, 165, 0)    # L-форма
BLUE = (0, 0, 255)        # J-форма

# Размеры игры
BLOCK_SIZE = 30
GRID_WIDTH = 10
GRID_HEIGHT = 20

# Расширяем ширину экрана для сдвига кнопки паузы вправо
SCREEN_WIDTH = BLOCK_SIZE * (GRID_WIDTH + 8)  # Увеличили на 2 клетки
SCREEN_HEIGHT = BLOCK_SIZE * GRID_HEIGHT

# Фигуры-тетромино и их цвета
SHAPES = [
    [[1, 1, 1, 1]],                  # I-форма
    [[1, 1], [1, 1]],                # O-форма
    [[1, 1, 1], [0, 1, 0]],          # T-форма
    [[0, 1, 1], [1, 1, 0]],          # S-форма
    [[1, 1, 0], [0, 1, 1]],          # Z-форма
    [[1, 1, 1], [1, 0, 0]],          # L-форма
    [[1, 1, 1], [0, 0, 1]]           # J-форма
]

SHAPE_COLORS = [CYAN, YELLOW, PURPLE, GREEN, RED, ORANGE, BLUE]


class Tetris:
    def __init__(self):
        self.game_state = 'menu'  # Возможные состояния: 'menu', 'playing', 'paused', 'settings', 'game_over', 'exit'
        self.screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
        self.hold_piece = None
        pygame.display.set_caption("Тетрис")
        self.clock = pygame.time.Clock()
        self.grid = [[0 for _ in range(GRID_WIDTH)] for _ in range(GRID_HEIGHT)]
        self.piece_queue = [self.create_random_piece() for _ in range(3)]
        self.current_piece = self.get_next_piece()
        self.game_over = False
        self.score = 0
        self.total_lines_cleared = 0  # Общее число удаленных линий
        self.fall_speed = 0.5  # Начальная скорость падения
        self.pause_button_rect = None  # Для кнопки паузы
        self.buttons = []  # Список кнопок для мобильных устройств
        self.hold_used = False  # Ограничение на использование резерва
        self.button_sizes = {
            'влево': 50,
            'вниз': 50,
            'вправо': 50,
            'поворота': 50,
            'перекладывания': 50
        }
        self.dragging_slider = None  # Для отслеживания перетаскивания ползунка

    def show_menu(self):
        while self.game_state == 'menu':
            self.screen.fill(BLACK)
            font = pygame.font.Font(None, 74)
            title_text = font.render("Тетрис", True, WHITE)
            self.screen.blit(title_text, (SCREEN_WIDTH // 2 - title_text.get_width() // 2, SCREEN_HEIGHT // 4))

            # Кнопка "Начать игру"
            button_font = pygame.font.Font(None, 50)
            button_text = button_font.render("Начать игру", True, WHITE)
            button_rect = button_text.get_rect(center=(SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2))

            pygame.draw.rect(self.screen, WHITE, button_rect.inflate(20, 20), 2)
            self.screen.blit(button_text, button_rect)

            # Кнопка "Настройки"
            settings_text = button_font.render("Настройки", True, WHITE)
            settings_rect = settings_text.get_rect(center=(SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2 + 80))
            pygame.draw.rect(self.screen, WHITE, settings_rect.inflate(20, 20), 2)
            self.screen.blit(settings_text, settings_rect)

            pygame.display.flip()

            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    self.game_state = 'exit'
                    self.game_over = True
                if event.type == pygame.MOUSEBUTTONDOWN:
                    if button_rect.collidepoint(event.pos):
                        self.game_state = 'playing'
                    if settings_rect.collidepoint(event.pos):
                        self.game_state = 'settings'
                        self.show_settings()

            self.clock.tick(60)

    def show_settings(self):
        settings = True
        while settings:
            self.screen.fill(BLACK)
            font = pygame.font.Font(None, 50)
            title_text = font.render("Настройки", True, WHITE)
            self.screen.blit(title_text, (SCREEN_WIDTH // 2 - title_text.get_width() // 2, 50))

            button_font = pygame.font.Font(None, 36)
            y_offset = 150
            sliders = []
            for name in self.button_sizes:
                text = button_font.render(f"Размер кнопки '{name}': {self.button_sizes[name]}", True, WHITE)
                self.screen.blit(text, (100, y_offset))
                slider_rect = pygame.Rect(400, y_offset + 10, 200, 10)
                pygame.draw.rect(self.screen, WHITE, slider_rect)
                handle_x = 400 + int((self.button_sizes[name] - 30) / 70 * slider_rect.width)
                handle_rect = pygame.Rect(handle_x - 5, y_offset + 5, 10, 20)
                pygame.draw.rect(self.screen, WHITE, handle_rect)
                sliders.append((name, slider_rect, handle_rect))
                y_offset += 60

            back_text = button_font.render("Назад", True, WHITE)
            back_rect = back_text.get_rect(center=(SCREEN_WIDTH // 2, SCREEN_HEIGHT - 80))
            pygame.draw.rect(self.screen, WHITE, back_rect.inflate(20, 20), 2)
            self.screen.blit(back_text, back_rect)

            pygame.display.flip()

            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    self.game_state = 'exit'
                    self.game_over = True
                    settings = False
                elif event.type == pygame.MOUSEBUTTONDOWN:
                    if back_rect.collidepoint(event.pos):
                        self.game_state = 'menu'
                        settings = False
                    for name, slider_rect, handle_rect in sliders:
                        if slider_rect.collidepoint(event.pos) or handle_rect.collidepoint(event.pos):
                            self.dragging_slider = (name, slider_rect)
                            # Изменяем размер кнопки при нажатии
                            pos_x = event.pos[0]
                            new_size = max(30, min(100, int((pos_x - slider_rect.x) / slider_rect.width * 70 + 30)))
                            self.button_sizes[name] = new_size
                            self.create_mobile_buttons()  # Пересоздаем кнопки с новым размером
                elif event.type == pygame.MOUSEBUTTONUP:
                    self.dragging_slider = None
                elif event.type == pygame.MOUSEMOTION and self.dragging_slider:
                    name, slider_rect = self.dragging_slider
                    pos_x = event.pos[0]
                    new_size = max(30, min(100, int((pos_x - slider_rect.x) / slider_rect.width * 70 + 30)))
                    self.button_sizes[name] = new_size
                    self.create_mobile_buttons()  # Пересоздаем кнопки с новым размером

            self.clock.tick(60)

    def create_random_piece(self, index=None):
        if index is None:
            index = random.randint(0, len(SHAPES) - 1)
        shape = SHAPES[index]
        color = SHAPE_COLORS[index]
        return {
            'shape': shape,
            'color': color,
            'x': 0,
            'y': 0
        }

    def get_next_piece(self):
        next_piece = self.piece_queue.pop(0)
        next_piece['x'] = GRID_WIDTH // 2 - len(next_piece['shape'][0]) // 2
        next_piece['y'] = 0
        self.piece_queue.append(self.create_random_piece())
        self.hold_used = False  # Сброс использования резерва при появлении новой фигуры
        return next_piece

    def valid_move(self, piece, x, y):
        for i, row in enumerate(piece['shape']):
            for j, cell in enumerate(row):
                if cell:
                    if (x + j < 0 or x + j >= GRID_WIDTH or
                            y + i >= GRID_HEIGHT or
                            self.grid[y + i][x + j]):
                        return False
        return True

    def place_piece(self, piece):
        for i, row in enumerate(piece['shape']):
            for j, cell in enumerate(row):
                if cell:
                    self.grid[piece['y'] + i][piece['x'] + j] = piece['color']

    def remove_complete_lines(self):
        lines_cleared = 0
        new_grid = []
        for row in self.grid:
            if not all(row):
                new_grid.append(row)
            else:
                lines_cleared += 1
        for _ in range(lines_cleared):
            new_grid.insert(0, [0 for _ in range(GRID_WIDTH)])
        self.grid = new_grid
        self.score += lines_cleared * 100
        self.total_lines_cleared += lines_cleared

        # Ускорение игры на 1,005x за каждую удаленную линию
        for _ in range(lines_cleared):
            self.fall_speed /= 1.005

    def rotate_piece(self, piece):
        return {
            'shape': [list(row) for row in zip(*reversed(piece['shape']))],
            'color': piece['color'],
            'x': piece['x'],
            'y': piece['y']
        }

    def draw_next_pieces(self):
        font = pygame.font.Font(None, 36)
        next_text = font.render("Следующие:", True, WHITE)
        # Перемещаем 'Следующие:' на 2 клетки вниз
        self.screen.blit(next_text, (GRID_WIDTH * BLOCK_SIZE + 10, 100 + 2 * BLOCK_SIZE))

        for index, piece in enumerate(self.piece_queue[:2]):
            for i, row in enumerate(piece['shape']):
                for j, cell in enumerate(row):
                    if cell:
                        pygame.draw.rect(
                            self.screen,
                            piece['color'],
                            (GRID_WIDTH * BLOCK_SIZE + 10 + j * BLOCK_SIZE,
                             130 + 2 * BLOCK_SIZE + index * 100 + i * BLOCK_SIZE,
                             BLOCK_SIZE, BLOCK_SIZE)
                        )
                        pygame.draw.rect(
                            self.screen,
                            WHITE,
                            (GRID_WIDTH * BLOCK_SIZE + 10 + j * BLOCK_SIZE,
                             130 + 2 * BLOCK_SIZE + index * 100 + i * BLOCK_SIZE,
                             BLOCK_SIZE, BLOCK_SIZE), 1
                        )

    def hold_piece_swap(self):
        # Разрешить положить фигуру в резерв, если он пуст
        # Если резерв уже занят, ничего не делаем
        if self.hold_piece is None:
            self.current_piece['x'] = GRID_WIDTH // 2 - len(self.current_piece['shape'][0]) // 2
            self.current_piece['y'] = 0
            self.hold_piece = self.current_piece
            self.current_piece = self.get_next_piece()
            self.hold_used = True
        else:
            # Ничего не делаем, если резерв не пуст
            pass

    def draw_hold_piece(self):
        font = pygame.font.Font(None, 36)
        hold_text = font.render("Резерв:", True, WHITE)
        self.screen.blit(hold_text, (GRID_WIDTH * BLOCK_SIZE + 10, 10))

        if self.hold_piece is not None:
            for i, row in enumerate(self.hold_piece['shape']):
                for j, cell in enumerate(row):
                    if cell:
                        pygame.draw.rect(
                            self.screen,
                            self.hold_piece['color'],
                            (GRID_WIDTH * BLOCK_SIZE + 10 + j * BLOCK_SIZE,
                             40 + i * BLOCK_SIZE,
                             BLOCK_SIZE, BLOCK_SIZE)
                        )
                        pygame.draw.rect(
                            self.screen,
                            WHITE,
                            (GRID_WIDTH * BLOCK_SIZE + 10 + j * BLOCK_SIZE,
                             40 + i * BLOCK_SIZE,
                             BLOCK_SIZE, BLOCK_SIZE), 1
                        )

    def draw_grid(self):
        # Рисуем сетку и линии
        for y, row in enumerate(self.grid):
            for x, color in enumerate(row):
                if color:
                    pygame.draw.rect(self.screen, color, (x * BLOCK_SIZE, y * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE))
                    pygame.draw.rect(self.screen, WHITE, (x * BLOCK_SIZE, y * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE), 1)
        # Рисуем белую полосу справа впритык к игровому полю
        pygame.draw.line(self.screen, WHITE, (GRID_WIDTH * BLOCK_SIZE, 0),
                         (GRID_WIDTH * BLOCK_SIZE, SCREEN_HEIGHT), 2)

    def draw_piece(self, piece):
        for i, row in enumerate(piece['shape']):
            for j, cell in enumerate(row):
                if cell:
                    pygame.draw.rect(self.screen, piece['color'],
                                     ((piece['x'] + j) * BLOCK_SIZE, (piece['y'] + i) * BLOCK_SIZE, BLOCK_SIZE,
                                      BLOCK_SIZE))
                    pygame.draw.rect(self.screen, WHITE,
                                     ((piece['x'] + j) * BLOCK_SIZE, (piece['y'] + i) * BLOCK_SIZE, BLOCK_SIZE,
                                      BLOCK_SIZE), 1)

    def draw_score(self):
        font = pygame.font.Font(None, 24)  # Уменьшенный размер шрифта
        score_text = font.render(f"Количество очков: {self.score}", True, WHITE)
        # Создаем поверхность с прозрачностью
        text_surface = pygame.Surface(score_text.get_size(), pygame.SRCALPHA)
        text_surface.blit(score_text, (0, 0))
        text_surface.set_alpha(150)  # Устанавливаем прозрачность
        self.screen.blit(text_surface, (10, 10))

    def show_game_over(self):
        self.screen.fill(BLACK)
        font = pygame.font.Font(None, 74)
        game_over_text = font.render("Игра окончена", True, RED)
        self.screen.blit(
            game_over_text,
            (SCREEN_WIDTH // 2 - game_over_text.get_width() // 2,
             SCREEN_HEIGHT // 2 - game_over_text.get_height() // 2)
        )
        pygame.display.flip()
        pygame.time.delay(1500)
        self.reset_game()
        self.game_state = 'menu'

    def reset_game(self):
        self.grid = [[0 for _ in range(GRID_WIDTH)] for _ in range(GRID_HEIGHT)]
        self.piece_queue = [self.create_random_piece() for _ in range(3)]
        self.current_piece = self.get_next_piece()
        self.score = 0
        self.total_lines_cleared = 0
        self.hold_piece = None
        self.hold_used = False
        self.fall_speed = 0.5  # Сброс скорости падения

    def create_mobile_buttons(self):
        # Создаем кнопки для управления на мобильных устройствах
        gap = 10
        y_position = SCREEN_HEIGHT - max(self.button_sizes.values()) - gap

        # Смещаем кнопки вправо за пределы игрового поля
        base_x = GRID_WIDTH * BLOCK_SIZE + 20

        # Кнопки влево, вниз, вправо
        left_size = self.button_sizes['влево']
        down_size = self.button_sizes['вниз']
        right_size = self.button_sizes['вправо']

        left_button = pygame.Rect(base_x, y_position, left_size, left_size)
        down_button = pygame.Rect(base_x + left_size + gap, y_position, down_size, down_size)
        right_button = pygame.Rect(base_x + left_size + gap + down_size + gap, y_position, right_size, right_size)

        # Кнопка поворота (над пространством между влево и вниз)
        rotate_size = self.button_sizes['поворота']
        rotate_button = pygame.Rect(
            base_x + (left_size + gap) // 2 - rotate_size // 2,
            y_position - rotate_size - gap,
            rotate_size, rotate_size
        )

        # Кнопка перекладывания (над пространством между вниз и вправо)
        hold_size = self.button_sizes['перекладывания']
        hold_button = pygame.Rect(
            base_x + left_size + gap + (down_size + gap) // 2 - hold_size // 2,
            y_position - hold_size - gap,
            hold_size, hold_size
        )

        self.buttons = [
            ('влево', left_button),
            ('вниз', down_button),
            ('вправо', right_button),
            ('поворота', rotate_button),
            ('перекладывания', hold_button),
        ]

        # Кнопка паузы (сдвинута дальше вправо)
        self.pause_button_rect = pygame.Rect(SCREEN_WIDTH - 50 - gap, gap, 50, 50)

    def draw_mobile_buttons(self):
        for name, rect in self.buttons:
            pygame.draw.rect(self.screen, WHITE, rect, 2)
            # Используем шрифт, поддерживающий символы Unicode и кириллицу
            font = pygame.font.SysFont('Arial', int(rect.width * 0.4))
            if name == 'влево':
                # Рисуем стрелку влево
                self.draw_left_arrow(rect)
            elif name == 'вправо':
                # Рисуем стрелку вправо
                self.draw_right_arrow(rect)
            elif name == 'вниз':
                # Рисуем стрелку вниз
                self.draw_down_arrow(rect)
            elif name == 'поворота':
                # Рисуем круговую стрелку
                self.draw_rotate_icon(rect)
            elif name == 'перекладывания':
                # Рисуем изображение закрытой или открытой упаковки
                self.draw_hold_icon(rect, self.hold_piece is not None)
            else:
                text = font.render(name, True, WHITE)
                text_rect = text.get_rect(center=rect.center)
                self.screen.blit(text, text_rect)

        # Кнопка паузы
        pygame.draw.rect(self.screen, WHITE, self.pause_button_rect, 2)
        font = pygame.font.SysFont('Arial', 36)
        pause_text = font.render("||", True, WHITE)
        pause_text_rect = pause_text.get_rect(center=self.pause_button_rect.center)
        self.screen.blit(pause_text, pause_text_rect)

    def draw_left_arrow(self, rect):
        x, y, w, h = rect
        points = [
            (x + w * 0.7, y + h * 0.2),
            (x + w * 0.3, y + h * 0.5),
            (x + w * 0.7, y + h * 0.8),
        ]
        pygame.draw.polygon(self.screen, WHITE, points)

    def draw_right_arrow(self, rect):
        x, y, w, h = rect
        points = [
            (x + w * 0.3, y + h * 0.2),
            (x + w * 0.7, y + h * 0.5),
            (x + w * 0.3, y + h * 0.8),
        ]
        pygame.draw.polygon(self.screen, WHITE, points)

    def draw_down_arrow(self, rect):
        x, y, w, h = rect
        points = [
            (x + w * 0.2, y + h * 0.3),
            (x + w * 0.5, y + h * 0.7),
            (x + w * 0.8, y + h * 0.3),
        ]
        pygame.draw.polygon(self.screen, WHITE, points)

    def draw_rotate_icon(self, rect):
        x, y, w, h = rect
        center = (x + w // 2, y + h // 2)
        radius = w * 0.3
        start_angle = 0
        end_angle = 270
        pygame.draw.arc(self.screen, WHITE, (x + w * 0.2, y + h * 0.2, w * 0.6, h * 0.6), 
                        start_angle * (3.14 / 180), end_angle * (3.14 / 180), 2)
        # Рисуем стрелку
        arrow_points = [
            (x + w * 0.65, y + h * 0.25),
            (x + w * 0.75, y + h * 0.25),
            (x + w * 0.75, y + h * 0.35),
        ]
        pygame.draw.polygon(self.screen, WHITE, arrow_points)

    def draw_hold_icon(self, rect, is_open):
        x, y, w, h = rect
        # Рисуем упаковку (коробку)
        pygame.draw.rect(self.screen, WHITE, (x + w * 0.2, y + h * 0.4, w * 0.6, h * 0.4), 2)
        if is_open:
            # Рисуем открытую крышку
            pygame.draw.polygon(self.screen, WHITE, [
                (x + w * 0.2, y + h * 0.4),
                (x + w * 0.5, y + h * 0.2),
                (x + w * 0.8, y + h * 0.4)
            ], 2)
        else:
            # Рисуем закрытую крышку
            pygame.draw.rect(self.screen, WHITE, (x + w * 0.2, y + h * 0.2, w * 0.6, h * 0.2), 2)

    def run(self):
        self.create_mobile_buttons()  # Создаем кнопки для мобильных устройств
        fall_time = 0
        key_down_pressed = False
        down_key_timer = 0

        while not self.game_over:
            if self.game_state == 'menu':
                self.show_menu()
                continue  # Возвращаемся в начало цикла после меню
            elif self.game_state == 'playing':
                pass  # Логика игры будет здесь
            elif self.game_state == 'paused':
                self.screen.fill(BLACK)
                font = pygame.font.Font(None, 74)
                paused_text = font.render("Пауза", True, WHITE)
                self.screen.blit(
                    paused_text,
                    (SCREEN_WIDTH // 2 - paused_text.get_width() // 2,
                     SCREEN_HEIGHT // 2 - paused_text.get_height() // 2)
                )
                pygame.display.flip()
                # Ждем нажатия в любом месте экрана для продолжения
                paused = True
                while paused:
                    event = pygame.event.wait()
                    if event.type == pygame.MOUSEBUTTONDOWN:
                        self.game_state = 'playing'
                        paused = False
                    elif event.type == pygame.QUIT:
                        self.game_over = True
                        paused = False
                continue  # Возвращаемся в начало цикла после обработки паузы
            elif self.game_state == 'game_over':
                self.show_game_over()
                continue  # Возвращаемся в начало цикла после экрана окончания игры
            elif self.game_state == 'exit':
                break  # Выходим из основного цикла

            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    self.game_over = True
                if event.type == pygame.KEYDOWN:
                    if event.key == pygame.K_LEFT:
                        if self.valid_move(self.current_piece, self.current_piece['x'] - 1, self.current_piece['y']):
                            self.current_piece['x'] -= 1
                    if event.key == pygame.K_RIGHT:
                        if self.valid_move(self.current_piece, self.current_piece['x'] + 1, self.current_piece['y']):
                            self.current_piece['x'] += 1
                    if event.key == pygame.K_DOWN:
                        key_down_pressed = True
                        down_key_timer = 0  # Начинаем отсчет времени
                        if self.valid_move(self.current_piece, self.current_piece['x'], self.current_piece['y'] + 1):
                            self.current_piece['y'] += 1
                    if event.key == pygame.K_UP:
                        rotated_piece = self.rotate_piece(self.current_piece)
                        if self.valid_move(rotated_piece, rotated_piece['x'], rotated_piece['y']):
                            self.current_piece = rotated_piece
                    if event.key == pygame.K_c:
                        self.hold_piece_swap()
                if event.type == pygame.KEYUP:
                    if event.key == pygame.K_DOWN:
                        key_down_pressed = False
                        down_key_timer = 0

                if event.type == pygame.MOUSEBUTTONDOWN:
                    pos = event.pos
                    for name, rect in self.buttons:
                        if rect.collidepoint(pos):
                            if name == 'влево':
                                if self.valid_move(self.current_piece, self.current_piece['x'] - 1,
                                                   self.current_piece['y']):
                                    self.current_piece['x'] -= 1
                            if name == 'вправо':
                                if self.valid_move(self.current_piece, self.current_piece['x'] + 1,
                                                   self.current_piece['y']):
                                    self.current_piece['x'] += 1
                            if name == 'вниз':
                                if self.valid_move(self.current_piece, self.current_piece['x'],
                                                   self.current_piece['y'] + 1):
                                    self.current_piece['y'] += 1
                            if name == 'поворота':
                                rotated_piece = self.rotate_piece(self.current_piece)
                                if self.valid_move(rotated_piece, rotated_piece['x'], rotated_piece['y']):
                                    self.current_piece = rotated_piece
                            if name == 'перекладывания':
                                self.hold_piece_swap()
                    if self.pause_button_rect.collidepoint(pos):
                        self.game_state = 'paused'

            if key_down_pressed:
                down_key_timer += self.clock.get_time()
                if down_key_timer >= 150:  # После 0.15 секунды
                    if self.valid_move(self.current_piece, self.current_piece['x'], self.current_piece['y'] + 1):
                        self.current_piece['y'] += 1
                    down_key_timer = 0

            fall_time += self.clock.get_rawtime()
            self.clock.tick()

            if fall_time / 1000 > self.fall_speed:
                if self.valid_move(self.current_piece, self.current_piece['x'], self.current_piece['y'] + 1):
                    self.current_piece['y'] += 1
                else:
                    self.place_piece(self.current_piece)
                    self.remove_complete_lines()
                    self.current_piece = self.get_next_piece()
                    if not self.valid_move(self.current_piece, self.current_piece['x'], self.current_piece['y']):
                        self.game_state = 'game_over'
                fall_time = 0

            self.screen.fill(BLACK)
            self.draw_grid()
            self.draw_piece(self.current_piece)
            self.draw_score()
            self.draw_next_pieces()  # Отображаем следующие фигуры
            self.draw_hold_piece()   # Отображаем резервную фигуру
            self.draw_mobile_buttons()  # Отображаем кнопки для мобильных устройств
            pygame.display.flip()

        pygame.quit()


if __name__ == "__main__":
    game = Tetris()
    game.run()
.
Сделай
А. Перемещение ползунков вниз под соответствующие им надписи в настройках.
B. Удаление всех символов ' в тексте там же.
C. Исправление ошибки отображения дисплейных кнопок с выкрученным размером за рамки игры во время игрового процесса.
D. Приказ кнопке HOLD помещать фигуру в резерв, а при повторном нажатии вынимать её оттуда, заменяя текущую и перемещая её наверх, как будто она только возникла.
E. Переименование надписи Следующие: в Следующие фигуры в очереди: (убедись в том, что она не выходит за рамки игры).
F. Приказ игре останавливаться, когда она свёрнута.
G. Разворот иконок закрытой и открытой коробки кнопки HOLD лицом к игроку.
H. Кнопку перезапуска за место кнопки паузы, а весь связанный с ней до этого код удали (новая иконка должна выглядеть как ↻ ).