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: create the tetris game in…

  1. User

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

  2. Assistant

    Creating a Tetris game in Python is a fun project that helps you understand game development concepts such as game loops, collision detection, and handling user input. Below is a complete Python script using the pygame library to create a functional Tetris game.

    Prerequisites

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

    2. Pygame Installation: pygame is a popular library for creating games in Python. You can install it using pip:

      pip install pygame
      

    Complete Tetris Game Code

    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
    
    # Shape Formats
    
    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 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:
                    c = locked_positions[(j,i)]
                    grid[i][j] = c
        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 space 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] >= 0:
                    return False
        return True
    
    # Check if 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
    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 grid lines
    def draw_grid(surface, grid):
        sx = top_left_x
        sy = top_left_y
        for i in range(len(grid)):
            pygame.draw.line(surface, (128,128,128), (sx, sy + i*block_size), 
                             (sx + play_width, sy + i * block_size))  # horizontal lines
            for j in range(len(grid[i])):
                pygame.draw.line(surface, (128,128,128), (sx + j * block_size, sy), 
                                 (sx + j * block_size, sy + play_height))  # vertical lines
    
    # Clear rows
    def clear_rows(grid, locked):
        # need to see if row is clear the shift every other row above down one
        inc = 0
        for i in range(len(grid)-1,-1,-1):
            row = grid[i]
            if (0,0,0) not in row:
                inc += 1
                # add positions to remove
                ind = i
                for j in range(len(row)):
                    try:
                        del locked[(j, i)]
                    except:
                        continue
        if inc > 0:
            # Shift every row above 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 window
    def draw_window(surface, grid, score=0):
        surface.fill((0,0,0))
        
        # Tetris Title
        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(f'Score: {score}', 1, (255,255,255))
        
        sx = top_left_x + play_width + 50
        sy = top_left_y + play_height / 2 - 100
        
        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)
        
        pygame.draw.rect(surface, (255, 0, 0), 
                         (top_left_x, top_left_y, play_width, play_height), 5)
        
        draw_grid(surface, grid)
    
    # 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 difficulty over time
            if level_time/1000 > 5:
                level_time = 0
                if fall_speed > 0.12:
                    fall_speed -= 0.005
    
            # Handle piece falling
            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
    
            # Handle user input
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    run = False
                    pygame.display.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)
    
            # Add piece to the grid for drawing
            for i in range(len(shape_pos)):
                x, y = shape_pos[i]
                if y > -1:
                    grid[y][x] = current_piece.color
    
            # If piece hit the ground
            if change_piece:
                for pos in shape_pos:
                    locked_positions[pos] = current_piece.color
                current_piece = next_piece
                next_piece = get_shape()
                change_piece = False
                score += clear_rows(grid, locked_positions) * 10
    
            draw_window(win, grid, score)
            pygame.display.update()
    
            # Check if user lost
            if check_lost(locked_positions):
                draw_text_middle("YOU LOST!", 80, (255,255,255), win)
                pygame.display.update()
                pygame.time.delay(2000)
                run = False
    
    # Start screen
    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()
    
    if __name__ == '__main__':
        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: Save the above code in a file named tetris.py.

    2. Install Pygame: If you haven't installed pygame yet, do so using the following command:

      pip install pygame
      
    3. Run the Game: Navigate to the directory containing tetris.py and run:

      python tetris.py
      

      A window titled "Tetris" should open, displaying the start screen.

    How to Play

    • Controls:

      • Left Arrow: Move the piece left.
      • Right Arrow: Move the piece right.
      • Down Arrow: Accelerate the piece downward.
      • Up Arrow: Rotate the piece clockwise.
    • Objective: Arrange the falling Tetriminoes to complete horizontal lines without gaps. Completed lines will disappear, and you earn points.

    • Game Over: The game ends when new pieces cannot enter the playfield. Your score is displayed upon losing.

    Customization

    • Colors: You can change the colors of the Tetriminoes by modifying the shape_colors list.

    • Difficulty: Adjust the fall_speed variable to make the game faster or slower initially. The game currently increases speed every 5 seconds.

    • Grid Size: Modify play_width, play_height, and block_size to change the game's dimensions.

    Additional Features to Implement

    If you're interested in enhancing the game further, consider implementing the following features:

    1. Next Piece Preview: Display the next Tetrimino that will appear after the current one.

    2. Pause Functionality: Allow the player to pause and resume the game.

    3. High Score Tracking: Save and display the highest scores achieved.

    4. Sound Effects and Music: Add background music and sound effects for actions like moving pieces or clearing lines.

    5. Different Levels: Introduce levels that change the speed and complexity as the player progresses.

    6. Hold Piece Mechanic: Allow players to hold a piece for later use.

    Conclusion

    This script provides a basic but functional Tetris game using Python and pygame. It's a great starting point for learning game development concepts and can be expanded with additional features to enhance gameplay. Happy coding!

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