Skip to content
TheChatArchiveThe Chat Archive
o1-mini-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

Please provide a Python script for the following request: write the tetris game in python.

  1. User

    Please provide a Python script for the following request: write the tetris game in python.

  2. Assistant

    Sure! Below is a Python implementation of the classic Tetris game using the pygame library. This script creates a playable Tetris game with basic functionalities like moving and rotating tetrominoes, line clearing, scoring, and game over detection.

    Prerequisites

    1. Python Installation: Ensure you have Python installed on your computer. You can download it from python.org.

    2. Pygame Installation: This script uses the pygame library for rendering and handling game mechanics. You can install it using pip:

      pip install pygame
      

    Tetris Game Script

    import pygame
    import random
    
    # Initialize Pygame
    pygame.init()
    
    # Global Variables
    s_width = 800
    s_height = 700
    play_width = 300  # 300 // 10 = 30 width per block
    play_height = 600  # 600 // 20 = 30 height per block
    block_size = 30
    
    top_left_x = (s_width - play_width) // 2
    top_left_y = s_height - play_height - 100
    
    # Shapes
    
    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),    # S
                    (255, 0, 0),    # Z
                    (0, 255, 255),  # I
                    (255, 255, 0),  # O
                    (255, 165, 0),  # J
                    (0, 0, 255),    # L
                    (128, 0, 128)]  # T
    
    # Define the Piece class
    class Piece(object):
        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
    
    # Create the game grid
    def create_grid(locked_positions={}):
        grid = [[(0, 0, 0) for _ in range(10)] for _ in range(20)]
    
        for i in range(len(grid)):
            for j in range(len(grid[i])):
                if (j, i) in locked_positions:
                    grid[i][j] = locked_positions[(j, i)]
                    
        return grid
    
    # Convert shape format
    def convert_shape_format(shape):
        positions = []
        format = shape.shape[shape.rotation % len(shape.shape)]
    
        for i, line in enumerate(format):
            row = list(line)
            for j, column in enumerate(row):
                if column == '0':
                    positions.append((shape.x + j - 2, shape.y + i - 4))
    
        return positions
    
    # Check if position is valid
    def valid_space(shape, grid):
        accepted_positions = [[(j, i) for j in range(10) if grid[i][j] == (0,0,0)] for i in range(20)]
        accepted_positions = [j for sub in accepted_positions for j in sub]
    
        formatted = convert_shape_format(shape)
    
        for pos in formatted:
            if pos not in accepted_positions:
                if pos[1] > -1:
                    return False
        return True
    
    # Check if game is lost
    def check_lost(positions):
        for pos in positions:
            x, y = pos
            if y < 1:
                return True
        return False
    
    # Get a random shape
    def get_shape():
        return Piece(5, 0, random.choice(shapes))
    
    # Draw text in the middle
    def draw_text_middle(text, size, color, surface):
        font = pygame.font.SysFont('comicsans', size, bold=True)
        label = font.render(text, 1, color)
    
        surface.blit(label, (top_left_x + play_width/2 - (label.get_width()/2), 
                            top_left_y + play_height/2 - label.get_height()/2))
    
    # Draw the grid
    def draw_grid(surface, grid):
        sx = top_left_x
        sy = top_left_y
        for i in range(len(grid)):
            # horizontal lines
            pygame.draw.line(surface, (128,128,128), (sx, sy + i*block_size), (sx + play_width, sy + i * block_size))
            for j in range(len(grid[i])):
                # vertical lines
                pygame.draw.line(surface, (128,128,128), (sx + j*block_size, sy), (sx + j*block_size, sy + play_height))
    
    # Clear completed lines
    def clear_rows(grid, locked):
        inc = 0
        for i in range(len(grid)-1, -1, -1):
            row = grid[i]
            if (0,0,0) not in row:
                inc +=1
                ind = i
                for j in range(len(row)):
                    try:
                        del locked[(j, i)]
                    except:
                        continue
        if inc > 0:
            # shift down
            for key in sorted(list(locked), key=lambda x: x[1])[::-1]:
                x, y = key
                if y < ind:
                    newKey = (x, y + inc)
                    locked[newKey] = locked.pop(key)
        return inc
    
    # Draw next shape
    def draw_next_shape(shape, surface):
        font = pygame.font.SysFont('comicsans', 30)
        label = font.render('Next Shape', 1, (255,255,255))
    
        sx = top_left_x + play_width + 50
        sy = top_left_y + play_height/2 - 100
        format = shape.shape[shape.rotation % len(shape.shape)]
    
        for i, line in enumerate(format):
            row = list(line)
            for j, column in enumerate(row):
                if column == '0':
                    pygame.draw.rect(surface, shape.color, 
                                     (sx + j*block_size, sy + i*block_size, block_size, block_size), 0)
    
        surface.blit(label, (sx + 10, sy - 30))
    
    # Draw the main window
    def draw_window(surface, grid, score=0):
        surface.fill((0,0,0))
    
        pygame.font.init()
        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))
    
        # Current score
        font = pygame.font.SysFont('comicsans', 30)
        label = font.render('Score: ' + str(score), 1, (255,255,255))
    
        sx = top_left_x - 200
        sy = top_left_y + 200
    
        surface.blit(label, (sx + 20, sy + 160))
    
        for i in range(len(grid)):
            for j in range(len(grid[i])):
                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 and border
        draw_grid(surface, grid)
        pygame.draw.rect(surface, (255, 0, 0), 
                         (top_left_x, top_left_y, play_width, play_height), 5)
    
    # Main game loop
    def main(win):
        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.27
        level_time = 0
        score = 0
    
        while run:
            grid = create_grid(locked_positions)
            fall_time += clock.get_rawtime()
            level_time += clock.get_rawtime()
            clock.tick()
    
            # Increase speed over time
            if level_time/1000 > 5:
                level_time = 0
                if fall_speed > 0.12:
                    fall_speed -= 0.005
    
            # Piece falls
            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
                    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_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)
    
            # Update grid
            for i in range(len(shape_pos)):
                x, y = shape_pos[i]
                if y > -1:
                    grid[y][x] = current_piece.color
    
            # Check if piece hit the ground
            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
                # Clear rows
                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()
    
            # Check loss
            if check_lost(locked_positions):
                draw_text_middle("YOU LOST!", 80, (255,255,255), win)
                pygame.display.update()
                pygame.time.delay(2000)
                run = False
    
    # Main menu
    def main_menu(win):
        run = True
        while run:
            win.fill((0,0,0))
            draw_text_middle('Press Any Key To Play', 60, (255,255,255), win)
            pygame.display.update()
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    run = False
    
                if event.type == pygame.KEYDOWN:
                    main(win)
        pygame.quit()
    
    # Start the game
    win = pygame.display.set_mode((s_width, s_height))
    pygame.display.set_caption('Tetris')
    main_menu(win)  # start game
    
    

    How to Run the Game

    1. Save the Script: Copy the above code and save it in a file named tetris.py.

    2. Install Pygame: If you haven't installed pygame yet, run:

      pip install pygame
      
    3. Run the Game:

      Navigate to the directory containing tetris.py and run:

      python tetris.py
      
    4. Controls:

      • Left Arrow: Move tetromino left
      • Right Arrow: Move tetromino right
      • Down Arrow: Move tetromino down faster
      • Up Arrow: Rotate tetromino

    Features Implemented

    • Tetromino Shapes: All seven standard Tetris shapes (S, Z, I, O, J, L, T) with their rotations.
    • Movement and Rotation: Control tetromino movement using arrow keys.
    • Line Clearing: Completed lines are cleared, and the score is updated accordingly.
    • Next Shape Preview: Shows the next tetromino that will appear.
    • Score Tracking: Displays the current score.
    • Game Over Detection: Ends the game when new tetrominoes can no longer enter the play area.

    Possible Enhancements

    • Level Progression: Increase difficulty as the player clears more lines.
    • Sound Effects and Music: Add audio for a better gaming experience.
    • Hold Functionality: Allow players to hold a tetromino for later use.
    • Better Graphics: Improve the visual aesthetics with more detailed graphics.

    Feel free to modify and enhance the game to suit your preferences! If you encounter any issues or have questions about the code, feel free to ask.

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