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

Create a full tetris game and tell me how to run it.

  1. User

    Create a full tetris game and tell me how to run it.

  2. Assistant

    Certainly! Below is a complete Tetris game implemented in Python using the Pygame library. I'll guide you through the steps to set it up and run it on your system.


    Prerequisites

    • Python 3.x installed on your system. You can download it from python.org.
    • Pygame library installed. We'll install this using pip.

    Step 1: Install Pygame

    Open your command prompt (Windows) or terminal (macOS/Linux) and run the following command to install Pygame:

    pip install pygame
    

    Step 2: Create the Game Script

    1. Create a new file named tetris.py in a directory of your choice.

    2. Copy and paste the following code into tetris.py:

      import pygame
      import random
      
      # Initialize Pygame
      pygame.init()
      
      # Screen dimensions
      SCREEN_WIDTH = 300
      SCREEN_HEIGHT = 600
      BLOCK_SIZE = 30  # Size of the grid block
      
      # Playable grid dimensions
      GRID_WIDTH = SCREEN_WIDTH // BLOCK_SIZE
      GRID_HEIGHT = SCREEN_HEIGHT // BLOCK_SIZE
      
      # Define shapes and their rotations
      SHAPES = [
          [['.....',
            '..0..',
            '..0..',
            '..0..',
            '..0..'],
           ['.....',
            '0000.',
            '.....',
            '.....',
            '.....']],
      
          [['.....',
            '..00.',
            '..00.',
            '.....',
            '.....']],
      
          [['.....',
            '...0.',
            '.000.',
            '.....',
            '.....'],
           ['.....',
            '..0..',
            '..0..',
            '..00.',
            '.....'],
           ['.....',
            '.....',
            '.000.',
            '.0...',
            '.....'],
           ['.....',
            '.00..',
            '..0..',
            '..0..',
            '.....']],
      
          [['.....',
            '.0...',
            '.000.',
            '.....',
            '.....'],
           ['.....',
            '..00.',
            '..0..',
            '..0..',
            '.....'],
           ['.....',
            '.....',
            '.000.',
            '...0.',
            '.....'],
           ['.....',
            '..0..',
            '..0..',
            '.00..',
            '.....']],
      
          [['.....',
            '..0..',
            '.000.',
            '.....',
            '.....'],
           ['.....',
            '..0..',
            '..00.',
            '..0..',
            '.....'],
           ['.....',
            '.....',
            '.000.',
            '..0..',
            '.....'],
           ['.....',
            '..0..',
            '.00..',
            '..0..',
            '.....']],
      
          [['.....',
            '..0..',
            '..00.',
            '...0.',
            '.....'],
           ['.....',
            '...00',
            '..00.',
            '.....',
            '.....']],
      
          [['.....',
            '...0.',
            '..00.',
            '..0..',
            '.....'],
           ['.....',
            '..00.',
            '...00',
            '.....',
            '.....']]
      ]
      
      # Define colors for each shape
      SHAPE_COLORS = [
          (0, 255, 255),   # Cyan
          (255, 255, 0),   # Yellow
          (255, 165, 0),   # Orange
          (0, 0, 255),     # Blue
          (128, 0, 128),   # Purple
          (0, 255, 0),     # Green
          (255, 0, 0)      # Red
      ]
      
      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(GRID_WIDTH)] for _ in range(GRID_HEIGHT)]
      
          for i in range(GRID_HEIGHT):
              for j in range(GRID_WIDTH):
                  if (j, i) in locked_positions:
                      c = locked_positions[(j, i)]
                      grid[i][j] = c
          return grid
      
      def convert_shape_format(piece):
          positions = []
          shape = piece.shape[piece.rotation % len(piece.shape)]
      
          for i, line in enumerate(shape):
              row = list(line)
              for j, column in enumerate(row):
                  if column == '0':
                      positions.append((piece.x + j - 2, piece.y + i - 4))
      
          return positions
      
      def valid_space(piece, grid):
          accepted_positions = [[(j, i) for j in range(GRID_WIDTH) if grid[i][j] == (0, 0, 0)] for i in range(GRID_HEIGHT)]
          accepted_positions = [j for sub in accepted_positions for j in sub]
      
          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(GRID_WIDTH // 2, 0, random.choice(SHAPES))
      
      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, (SCREEN_WIDTH / 2 - label.get_width() / 2, SCREEN_HEIGHT / 2 - label.get_height() / 2))
      
      def draw_grid(surface, grid):
          for i in range(GRID_HEIGHT):
              pygame.draw.line(surface, (128, 128, 128), (0, i * BLOCK_SIZE), (SCREEN_WIDTH, i * BLOCK_SIZE))
              for j in range(GRID_WIDTH):
                  pygame.draw.line(surface, (128, 128, 128), (j * BLOCK_SIZE, 0), (j * BLOCK_SIZE, SCREEN_HEIGHT))
      
      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:
              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)
      
      def draw_next_shape(piece, surface):
          font = pygame.font.SysFont('comicsans', 30)
          label = font.render('Next Shape', 1, (255, 255, 255))
      
          sx = SCREEN_WIDTH + 10
          sy = SCREEN_HEIGHT / 2 - 100
          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':
                      pygame.draw.rect(surface, piece.color, (sx + j * BLOCK_SIZE, sy + i * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE), 0)
      
          surface.blit(label, (sx + 10, sy - 30))
      
      def draw_window(surface, grid):
          surface.fill((0, 0, 0))
          font = pygame.font.SysFont('comicsans', 60)
          label = font.render('Tetris', 1, (255, 255, 255))
      
          surface.blit(label, (SCREEN_WIDTH / 2 - label.get_width() / 2, 30))
      
          for i in range(len(grid)):
              for j in range(len(grid[i])):
                  pygame.draw.rect(surface, grid[i][j], (j * BLOCK_SIZE, i * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE), 0)
      
          draw_grid(surface, grid)
          pygame.display.update()
      
      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  # Adjust to make pieces fall faster or slower
      
          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
                      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 += 1
                          if not valid_space(current_piece, grid):
                              current_piece.rotation -= 1
      
              shape_pos = convert_shape_format(current_piece)
      
              for i in range(len(shape_pos)):
                  x, y = shape_pos[i]
                  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
      
                  clear_rows(grid, locked_positions)
      
              draw_window(win, grid)
              draw_next_shape(next_piece, win)
              pygame.display.update()
      
              if check_lost(locked_positions):
                  draw_text_middle("YOU LOST!", 80, (255, 255, 255), win)
                  pygame.display.update()
                  pygame.time.delay(2000)
                  run = False
      
      def main_menu():
          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()
          pygame.quit()
      
      win = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
      pygame.display.set_caption('Tetris')
      
      if __name__ == '__main__':
          main_menu()
      

    Step 3: Run the Game

    1. Save the tetris.py file after copying the code.

    2. Open your terminal or command prompt, navigate to the directory containing tetris.py, and run the game with the following command:

      python tetris.py
      

      Note: If you have multiple versions of Python installed, you might need to use python3 instead of python.


    How to Play

    • Start the Game: After running the script, a window will appear. Press any key to start.

    • Controls:

      • Left Arrow (←): Move the piece left.
      • Right Arrow (→): Move the piece right.
      • Down Arrow (↓): Move the piece down faster.
      • Up Arrow (↑): Rotate the piece.
    • Objective: Complete horizontal lines to clear them and score points. The game ends when the pieces stack up to the top of the grid.


    Enjoy the Game!

    Feel free to modify the code to enhance the game or adjust the settings (like fall_speed) to change the difficulty level. If you encounter any issues or have questions, don't hesitate to ask!