Skip to content
TheChatArchiveThe Chat Archive
o4-mini-2025-04-16· OpenAIHugging Face LMArena Human Preference 140K

Создай код игры Тетрис с графическим интерфейсом на языке Питон.

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Qwenqwen3-235b-a22b-no-thinking’s answer.
  1. User

    Создай код игры Тетрис с графическим интерфейсом на языке Питон.

  2. Assistant

    Ниже приведён полный пример простой реализации «Тетриса» на Python с использованием библиотеки Pygame. Скопируйте этот код в файл, например tetris.py, установите Pygame и запустите:

    1. Установка Pygame:
      pip install pygame
      
    2. Запуск:
      python tetris.py
      
    import pygame
    import random
    
    # Инициализация Pygame
    pygame.init()
    
    # Константы экрана и сетки
    SCREEN_WIDTH = 400
    SCREEN_HEIGHT = 600
    PLAY_WIDTH = 300  # 10 блоков * 30px
    PLAY_HEIGHT = 600  # 20 блоков * 30px
    BLOCK_SIZE = 30
    
    TOP_LEFT_X = (SCREEN_WIDTH - PLAY_WIDTH) // 2
    TOP_LEFT_Y = SCREEN_HEIGHT - PLAY_HEIGHT
    
    # Фигуры тетриса (разные повороты в виде 5x5 матриц строк)
    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)
    ]
    
    class Piece:
        def __init__(self, x, y, shape):
            self.x = x
            self.y = y
            self.shape = shape
            self.color = SHAPE_COLORS[SHAPES.index(shape)]
            self.rotation = 0  # индекс текущего поворота
    
    def create_grid(locked_positions={}):
        grid = [[(0,0,0) for _ in range(10)] for _ in range(20)]
        for i in range(20):
            for j in range(10):
                if (j, i) in locked_positions:
                    grid[i][j] = locked_positions[(j, i)]
        return grid
    
    def convert_shape_format(piece):
        positions = []
        format = piece.shape[piece.rotation % len(piece.shape)]
        for i, line in enumerate(format):
            row = list(line)
            for j, column in enumerate(row):
                if column == '0':
                    positions.append((piece.x + j, piece.y + i))
        # Сдвиг, чтобы убрать пустые строки сверху/слева
        positions = [(x-2, y-4) for x, y in positions]
        return positions
    
    def valid_space(piece, grid):
        accepted_positions = [(j, i) for i in range(20) for j in range(10) if grid[i][j] == (0,0,0)]
        formatted = convert_shape_format(piece)
        for pos in formatted:
            if pos not in accepted_positions:
                if pos[1] > -1:
                    return False
        return True
    
    def check_lost(positions):
        for pos in positions:
            x, y = pos
            if y < 1:
                return True
        return False
    
    def get_shape():
        return Piece(5, 0, random.choice(SHAPES))
    
    def draw_text_middle(surface, text, size, color):
        font = pygame.font.SysFont('comicsans', size, bold=True)
        label = font.render(text, True, color)
        surface.blit(label, (
            TOP_LEFT_X + PLAY_WIDTH/2 - (label.get_width()/2),
            TOP_LEFT_Y + PLAY_HEIGHT/2 - label.get_height()/2
        ))
    
    def draw_grid(surface, grid):
        sx = TOP_LEFT_X
        sy = TOP_LEFT_Y
        for i in range(20):
            pygame.draw.line(surface, (128,128,128), (sx, sy + i*BLOCK_SIZE), (sx + PLAY_WIDTH, sy + i*BLOCK_SIZE))
            for j in range(10):
                pygame.draw.line(surface, (128,128,128), (sx + j*BLOCK_SIZE, sy), (sx + j*BLOCK_SIZE, sy + PLAY_HEIGHT))
    
    def clear_rows(grid, locked):
        inc = 0
        for i in range(19, -1, -1):
            row = grid[i]
            if (0,0,0) not in row:
                inc += 1
                # Удаляем эту строку из locked
                for j in range(10):
                    try:
                        del locked[(j, i)]
                    except:
                        continue
        if inc > 0:
            # Сдвигаем все позиции выше вниз
            for key in sorted(list(locked), key=lambda k: k[1])[::-1]:
                x, y = key
                color = locked[key]
                if y < i:
                    del locked[key]
                    locked[(x, y + inc)] = color
        return inc
    
    def draw_next_shape(shape, surface):
        font = pygame.font.SysFont('comicsans', 30)
        label = font.render('Next:', True, (255,255,255))
        sx = TOP_LEFT_X + PLAY_WIDTH + 20
        sy = TOP_LEFT_Y + PLAY_HEIGHT/2 - 100
        surface.blit(label, (sx, sy))
        format = shape.shape[shape.rotation % len(shape.shape)]
        for i, line in enumerate(format):
            for j, column in enumerate(line):
                if column == '0':
                    pygame.draw.rect(surface, shape.color, (sx + j*BLOCK_SIZE, sy + i*BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE), 0)
    
    def draw_window(surface, grid, score=0):
        surface.fill((0,0,0))
        # Заголовок
        font = pygame.font.SysFont('comicsans', 60)
        label = font.render('TETRIS', True, (255,255,255))
        surface.blit(label, (SCREEN_WIDTH/2 - label.get_width()/2, 30))
        # Счет
        font = pygame.font.SysFont('comicsans', 30)
        label = font.render(f'Score: {score}', True, (255,255,255))
        surface.blit(label, (TOP_LEFT_X + PLAY_WIDTH + 20, TOP_LEFT_Y + 20))
        # Основная сетка
        for i in range(20):
            for j in range(10):
                pygame.draw.rect(surface, grid[i][j],
                                 (TOP_LEFT_X + j*BLOCK_SIZE, TOP_LEFT_Y + i*BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE), 0)
        draw_grid(surface, grid)
        pygame.draw.rect(surface, (255,0,0),
                         (TOP_LEFT_X, TOP_LEFT_Y, PLAY_WIDTH, PLAY_HEIGHT), 5)
    
    def main():
        locked_positions = {}
        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
        fall_speed = 0.5  # секунды на один шаг
    
        score = 0
    
        win = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
        pygame.display.set_caption('Tetris')
    
        while run:
            grid = create_grid(locked_positions)
            fall_time += clock.get_rawtime()
            clock.tick()
    
            # движение фигуры вниз
            if fall_time/1000 >= fall_speed:
                fall_time = 0
                current_piece.y += 1
                if not valid_space(current_piece, grid) and current_piece.y > 0:
                    current_piece.y -= 1
                    change_piece = True
    
            # Обработка событий
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    run = False
    
                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_DOWN:
                        current_piece.y += 1
                        if not valid_space(current_piece, grid):
                            current_piece.y -= 1
                    elif event.key == pygame.K_UP:
                        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)
    
            shape_pos = convert_shape_format(current_piece)
    
            # Запоминаем текущую фигуру в сетке
            for x, y in shape_pos:
                if y > -1:
                    grid[y][x] = current_piece.color
    
            # Если фигура встала — фиксируем и генерим следующую
            if change_piece:
                for pos in shape_pos:
                    p = (pos[0], pos[1])
                    locked_positions[p] = current_piece.color
                current_piece = next_piece
                next_piece = get_shape()
                change_piece = False
                # Очищаем заполненные ряды
                cleared = clear_rows(grid, locked_positions)
                if cleared > 0:
                    score += cleared * 10
    
            draw_window(win, grid, score)
            draw_next_shape(next_piece, win)
            pygame.display.update()
    
            # Проверка конца игры
            if check_lost(locked_positions):
                draw_text_middle(win, "YOU LOST!", 80, (255,255,255))
                pygame.display.update()
                pygame.time.delay(2000)
                run = False
    
        pygame.quit()
    
    if __name__ == '__main__':
        main()
    

    Пояснения:

    • Мы используем сетку 10×20 блоков по 30×30 px.
    • Фигуры описаны в виде 5×5 строк, где символ 0 – это одна единица блока.
    • Обработка клавиш: стрелки влево/вправо двигают фигуру, вниз — ускоренный спуск, вверх — поворот.
    • При заполнении строк происходит их удаление и начисление очков.
    • Показаны следующая фигура и текущий счёт.

    Удачи в изучении и модификации! 🚀

  3. User

    В левой версии "несхлопнутые" ряды не опускаются вниз "стакана", в правой версии сразу после запуска появляется сообщение "вы проиграли".

  4. Assistant

    Ниже – минимальные правки к вашему «скелету» Тетриса, которые убирают обе проблемы:

    1. «синусы» при очистке строк (rows don’t drop down)
    2. мгновенный «YOU LOST» при старте

    1. Исправляем clear_rows

    Замените вашу функцию на эту (обратите внимание на логику shift – именно так мы «опускаем» все блоки, которые были выше удалённых рядов):

    def clear_rows(grid, locked_positions):
        """
        1) Находим все полностью заполненные ряды.
        2) Удаляем их из locked_positions.
        3) Опускаем все блоки, у которых y < удалённого ряда, вниз на количество удалённых рядов ниже них.
        Возвращает количество удалённых рядов.
        """
        rows_to_clear = [i for i, row in enumerate(grid) if all(cell != (0,0,0) for cell in row)]
        if not rows_to_clear:
            return 0
    
        # Удаляем эти ряды из locked_positions
        for row in rows_to_clear:
            for col in range(10):
                locked_positions.pop((col, row), None)
    
        # Сдвигаем вниз все оставшиеся блоки
        # (сортируем по y ↓, чтобы не перезаписывать ключи при pop/push)
        for (x, y) in sorted(list(locked_positions), key=lambda p: p[1], reverse=True):
            # count how many cleared rows are below this block
            shift = sum(1 for cleared_row in rows_to_clear if cleared_row < y)
            if shift > 0:
                color = locked_positions.pop((x, y))
                locked_positions[(x, y - shift)] = color
    
        return len(rows_to_clear)
    

    Пояснение по shift:

    • Наши ряды нумеруются сверху вниз от 0 до 19.
    • Если мы очистили, скажем, row = 18, то все блоки с y < 18 (т. е. выше очистки) должны «упасть» на 1.
    • При нескольких очищениях (например, ряд 17 и 18) – «падают» на 2, и т. д.

    2. Исправляем check_lost

    Иногда при проверке сразу срабатывает «проигрыш» из-за того, что часть блоков лежит по отрицательным координатам (или <1). Предлагаю упростить до:

    def check_lost(locked_positions):
        """
        Если какая-либо заблокированная клетка вышла за верхнюю границу (y < 0) — считаем, что игрок проиграл.
        """
        return any(y < 0 for (x, y) in locked_positions)
    

    Теперь при старте locked_positions пуст, и вы не получите «YOU LOST» до того, как фигура упрётся в самый верх.


    3. Как подкрутить в своём коде

    В вашем основном файле просто найдите старые реализации clear_rows и check_lost и замените их на предложенные выше. Больше ничего трогать не нужно – всё остальное у вас было уже правильно организовано.

    После этих правок:

    • При удалении полного ряда незаполненные ряды автоматически опустятся на нужное число блоков.
    • «YOU LOST» не вылетит сразу при старте.

    Дайте знать, если что-то ещё пойдёт не так! Удачи! 😊

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.