Skip to content
TheChatArchiveThe Chat Archive
Googlegemma-3-27b-it· GoogleHugging Face LMArena Human Preference 140K

помоги создать игру тетрис

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Geminigemini-2.5-pro’s answer.
  1. User

    помоги создать игру тетрис

  2. Google Assistant

    Отлично! Создание Тетриса - хороший проект для изучения программирования. Вот план и примерный код на Python с использованием библиотеки Pygame, чтобы помочь тебе начать. Я разобью процесс на части и дам пояснения.

    1. Планирование и Основные Компоненты

    • Игровое поле: Матрица (двумерный список) для представления блоков Тетриса.
    • Фигуры: Определение различных форм Тетриса (I, O, T, L, J, S, Z). Каждая фигура будет представлена списком координат относительно точки поворота.
    • Текущая фигура: Фигура, которая в данный момент падает.
    • Управление: Обработка нажатий клавиш для перемещения и поворота текущей фигуры.
    • Движение: Автоматическое перемещение фигуры вниз с течением времени.
    • Коллизии: Проверка, не сталкивается ли фигура с другими блоками или границами поля.
    • Удаление полных линий: Проверка и удаление полных горизонтальных линий.
    • Подсчет очков: Ведение счета.
    • Конец игры: Определение, когда игра заканчивается (например, когда фигура не может появиться на поле).
    • Отображение: Отрисовка игрового поля, текущей фигуры и информации об игре (счет, уровень и т.д.).

    2. Необходимые библиотеки

    • Pygame: Библиотека для создания игр на Python. Установите ее, если она еще не установлена: pip install pygame

    3. Пример кода (основная структура)

    import pygame
    import random
    
    # Константы
    WIDTH, HEIGHT = 10, 20  # Ширина и высота игрового поля
    BLOCK_SIZE = 30  # Размер одного блока
    SCREEN_WIDTH = WIDTH * BLOCK_SIZE
    SCREEN_HEIGHT = HEIGHT * BLOCK_SIZE
    FPS = 30
    
    # Цвета
    WHITE = (255, 255, 255)
    BLACK = (0, 0, 0)
    GRAY = (128, 128, 128)
    
    # Фигуры Тетриса (представлены координатами блоков относительно точки поворота)
    SHAPES = [
        [[1, 1, 1, 1]],  # I
        [[1, 1], [1, 1]],  # O
        [[0, 1, 0], [1, 1, 1]],  # T
        [[1, 0, 0], [1, 1, 1]],  # L
        [[0, 0, 1], [1, 1, 1]],  # J
        [[0, 1, 1], [1, 1, 0]],  # S
        [[1, 1, 0], [0, 1, 1]]   # Z
    ]
    
    COLORS = [
        (0, 255, 0),  # Зеленый
        (255, 0, 0),  # Красный
        (0, 0, 255),  # Синий
        (255, 255, 0),  # Желтый
        (255, 0, 255),  # Пурпурный
        (0, 255, 255),  # Голубой
        (255, 165, 0)   # Оранжевый
    ]
    
    
    class Tetris:
        def __init__(self, width, height):
            self.width = width
            self.height = height
            self.grid = [[0] * width for _ in range(height)]  # Игровое поле
            self.current_piece = None
            self.next_piece = None
            self.score = 0
            self.game_over = False
            self.new_piece()
            self.hold_piece = None
    
        def new_piece(self):
            self.current_piece = self.get_random_piece()
            self.next_piece = self.get_random_piece()
            self.current_piece_x = self.width // 2 - len(self.current_piece[0]) // 2
            self.current_piece_y = 0
    
            if self.check_collision(self.current_piece, self.current_piece_x, self.current_piece_y):
                self.game_over = True
    
        def get_random_piece(self):
            return random.choice(SHAPES)
    
        def rotate_piece(self):
            rotated_piece = list(zip(*self.current_piece[::-1]))
            if self.check_collision(rotated_piece, self.current_piece_x, self.current_piece_y):
                return
            self.current_piece = rotated_piece
    
        def move(self, dx):
            if self.check_collision(self.current_piece, self.current_piece_x + dx, self.current_piece_y):
                return
            self.current_piece_x += dx
    
        def drop(self):
            if self.check_collision(self.current_piece, self.current_piece_x, self.current_piece_y + 1):
                self.lock_piece()
                return True
            self.current_piece_y += 1
            return False
    
        def lock_piece(self):
            for i, row in enumerate(self.current_piece):
                for j, cell in enumerate(row):
                    if cell:
                        self.grid[self.current_piece_y + i][self.current_piece_x + j] = 1
            self.clear_lines()
            self.new_piece()
    
        def check_collision(self, piece, x, y):
            for i, row in enumerate(piece):
                for j, cell in enumerate(row):
                    if cell:
                        grid_x = x + j
                        grid_y = y + i
                        if grid_x < 0 or grid_x >= self.width or grid_y >= self.height or self.grid[grid_y][grid_x]:
                            return True
            return False
    
        def clear_lines(self):
            lines_cleared = 0
            for i in range(self.height):
                if all(self.grid[i]):
                    del self.grid[i]
                    self.grid.insert(0, [0] * self.width)
                    lines_cleared += 1
            self.score += lines_cleared ** 2 * 100
    
        def draw(self, screen):
            for y in range(self.height):
                for x in range(self.width):
                    if self.grid[y][x]:
                        pygame.draw.rect(screen, GRAY, (x * BLOCK_SIZE, y * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE))
    
            if self.current_piece:
                for i, row in enumerate(self.current_piece):
                    for j, cell in enumerate(row):
                        if cell:
                            pygame.draw.rect(screen, COLORS[SHAPES.index(self.current_piece)],
                                             ((self.current_piece_x + j) * BLOCK_SIZE, (self.current_piece_y + i) * BLOCK_SIZE,
                                              BLOCK_SIZE, BLOCK_SIZE))
    
            # Отображение следующей фигуры
            font = pygame.font.Font(None, 36)
            text = font.render("Next:", True, WHITE)
            screen.blit(text, (WIDTH * BLOCK_SIZE + 20, 20))
            for i, row in enumerate(self.next_piece):
                for j, cell in enumerate(row):
                    if cell:
                        pygame.draw.rect(screen, COLORS[SHAPES.index(self.next_piece)],
                                         (WIDTH * BLOCK_SIZE + 20 + j * BLOCK_SIZE, 60 + i * BLOCK_SIZE,
                                          BLOCK_SIZE, BLOCK_SIZE))
    
            # Отображение счета
            text = font.render(f"Score: {self.score}", True, WHITE)
            screen.blit(text, (WIDTH * BLOCK_SIZE + 20, 200))
    
            if self.game_over:
                font = pygame.font.Font(None, 72)
                text = font.render("Game Over", True, WHITE)
                text_rect = text.get_rect(center=(SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2))
                screen.blit(text, text_rect)
    
    
    def main():
        pygame.init()
        screen = pygame.display.set_mode((SCREEN_WIDTH + 200, SCREEN_HEIGHT))
        pygame.display.set_caption("Tetris")
        clock = pygame.time.Clock()
        tetris = Tetris(WIDTH, HEIGHT)
    
        fall_time = 0
        fall_speed = 500  # milliseconds
    
        running = True
        while running:
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    running = False
                if not tetris.game_over:
                    if event.type == pygame.KEYDOWN:
                        if event.key == pygame.K_LEFT:
                            tetris.move(-1)
                        if event.key == pygame.K_RIGHT:
                            tetris.move(1)
                        if event.key == pygame.K_DOWN:
                            tetris.drop()
                        if event.key == pygame.K_UP:
                            tetris.rotate_piece()
    
            if not tetris.game_over:
                fall_time += clock.get_rawtime()
                if fall_time > fall_speed:
                    fall_time = 0
                    tetris.drop()
    
            screen.fill(BLACK)
            tetris.draw(screen)
            pygame.display.flip()
            clock.tick(FPS)
    
        pygame.quit()
    
    
    if __name__ == "__main__":
        main()
    

    4. Пояснения к коду:

    • Константы: Определяют размеры поля, размер блоков, цвета и FPS.
    • SHAPES: Список, содержащий представления каждой фигуры Тетриса. Каждая фигура - это список списков, где 1 представляет блок, а 0 - пустое место.
    • COLORS: Список цветов для каждой фигуры.
    • Tetris класс:
      • __init__: Инициализирует игровое поле, текущую фигуру, счет и другие переменные.
      • new_piece: Создает новую случайную фигуру и помещает ее в верхнюю часть поля.
      • get_random_piece: Выбирает случайную фигуру из SHAPES.
      • rotate_piece: Поворачивает текущую фигуру. Проверяет, не приведет ли поворот к столкновению.
      • move: Перемещает текущую фигуру влево или вправо. Проверяет на столкновения.
      • drop: Перемещает текущую фигуру вниз. Если происходит столкновение, фиксирует фигуру на поле.
      • lock_piece: Фиксирует текущую фигуру на игровом поле.
      • check_collision: Проверяет, не сталкивается ли фигура с границами поля или другими блоками.
      • clear_lines: Удаляет полные горизонтальные линии и сдвигает верхние линии вниз.
      • draw: Отрисовывает игровое поле, текущую фигуру и информацию об игре.
    • main функция:
      • Инициализирует Pygame.
      • Создает окно игры.
      • Создает экземпляр класса Tetris.
      • Основной игровой цикл:
        • Обрабатывает события (нажатия клавиш, закрытие окна).
        • Перемещает текущую фигуру вниз с течением времени.
        • Отрисовывает игру.
        • Обновляет экран.
        • Ограничивает FPS.

    5. Что дальше?

    • Реализация удержания фигуры (Hold): Добавьте возможность удерживать текущую фигуру и заменить ее на следующую.
    • Уровни сложности: Увеличивайте скорость падения фигур с повышением уровня.
    • Более продвинутый интерфейс: Добавьте меню, экран результатов и т.д.
    • Звуковые эффекты: Добавьте звуки для поворота, перемещения, фиксации фигуры и удаления линий.
    • Оптимизация: Улучшите производительность игры, особенно при большом количестве блоков на поле.
    • Реализация Ghost Piece: Отображение "тени" фигуры, показывающей, где она остановится, если ее не перемещать.

    Советы:

    • Начните с малого: Не пытайтесь реализовать все функции сразу. Начните с базового движения и поворота фигуры, а затем добавляйте функциональность постепенно.
    • Тестируйте часто: Проверяйте свой код после каждого изменения, чтобы убедиться, что он работает правильно.
    • Используйте отладчик: Отладчик поможет вам найти и исправить ошибки в вашем коде.
    • Ищите примеры: В интернете есть много примеров кода Тетриса на Python. Используйте их в качестве отправной точки, но не копируйте код без понимания.
    • Разбивайте задачу на подзадачи: Это поможет вам организовать свой код и сделать его более понятным.

    Удачи в создании Тетриса! Если у тебя возникнут вопросы, не стесняйся спрашивать.

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