Tetris with python and pygame source

-


 Backgroud image file 640*480:


# tetris
import pygame, sys, random, time
from pygame.locals import *

SCREEN_WIDTH = 640
SCREEN_HEIGHT = 480

BOARD_WIDTH = 10
BOARD_HEIGHT = 20
SQUARE_SIZE = 20

# coordinates of the board's top-left corner
START_POS = (218, 78)

# fps
FPS = 30

# color set up
WHITE = (255,255,255)
BLACK = (0,0,0)
RED = (255,0,0)
GREEN = (0,255,0)
BLUE = (0,0,255)
LIGHT_BLUE = (125,125,255)
LIGHT_GREEN = (144,238,144)


# define shapes
# T shape data structure
t_shape = [[
      '     ',
      '  *  ',
      ' *** ',
      '     ',
      '     ',
      ],
           [
      '     ',
      ' *** ',
      '  *  ',
      '     ',
      '     ',
      ],
           [
      '     ',
      '  *  ',
      ' **  ',
      '  *  ',
      '     ',
      ],
           [
      '     ',
      '  *  ',
      '  ** ',
      '  *  ',
      '     ',
      ],
           ]

s_shape = [[
      '     ',
      '     ',
      '  ** ',
      ' **  ',
      '     ',
      ],
           [
      '     ',
      '  *  ',
      '  ** ',
      '   * ',
      '     ',
      ],
           ]

z_shape = [[
      '     ',
      '     ',
      ' **  ',
      '  ** ',
      '     ',
      ],
           [
      '     ',
      '  *  ',
      ' **  ',
      ' *   ',
      '     ',
      ],
           ]

i_shape = [[
      '  *  ',
      '  *  ',
      '  *  ',
      '  *  ',
      '     ',
      ],
           [
      '     ',
      '     ',
      '**** ',
      '     ',
      '     ',
      ],
           ]

o_shape = [[
      '     ',
      '     ',
      '  ** ',
      '  ** ',
      '     ',
      ],
           ]

l_shape = [[
      '     ',
      '   * ',
      ' *** ',
      '     ',
      '     ',
      ],
           [
      '     ',
      '  *  ',
      '  *  ',
      '  ** ',
      '     ',
      ],
           [
      '     ',
      '     ',
      ' *** ',
      ' *   ',
      '     ',
      ],
           [
      '     ',
      ' **  ',
      '  *  ',
      '  *  ',
      '     ',
      ],
           ]

j_shape = [[
      '     ',
      ' *   ',
      ' *** ',
      '     ',
      '     ',
      ],
           [
      '     ',
      '  *  ',
      '  *  ',
      ' **  ',
      '     ',
      ],
           [
      '     ',
      ' *   ',
      ' *** ',
      '     ',
      '     ',
      ],
           [
      '     ',
      '  ** ',
      '  *  ',
      '  *  ',
      '     ',
      ],
           ]

shapes = {
      'T': t_shape,
      'S': s_shape,
      'Z': z_shape,
      'J': j_shape,
      'L': l_shape,
      'I': i_shape,
      'O': o_shape,
      }
# generate the data structure of the pattern
# it is a dictionary, contains all the information about the pattern
# shape: the shape of the pattern, 'T', 'S', 'Z','J','L','I', 'O'
# state: the state of the shape, 'T' has four states...
# x: the starting x of the pattern, default 3
# y: the starting y of the pattern, default 0
def get_random_pattern():
      # select a shape randomly
      shape_name = random.choice('TSZJLIO')
      shape = shapes[shape_name]
      pattern = {
                  'shape': shape_name,
                  'state': random.randint(0, len(shape)-1),
                  'x': 3,
                  'y': 0,
            }
      return pattern


def draw_shape(pattern, next_pattern):
      global screen
      shape_pattern = shapes[pattern['shape']][pattern['state']]
      next_shape_pattern = shapes[next_pattern['shape']][next_pattern['state']]
      start_x, start_y = pattern['x'], pattern['y']
      next_start_x, next_start_y = next_pattern['x'], next_pattern['y']
      for i in range(5):
            for j in range(5):
                  if shape_pattern[j][i] == '*':
                        rect = pygame.Rect((START_POS[0]+1)+(start_x+i)*SQUARE_SIZE,
                                           (START_POS[1]+1)+(start_y+j)*SQUARE_SIZE,
                                           SQUARE_SIZE, SQUARE_SIZE)
                        light_rect = pygame.Rect((START_POS[0]+4)+(start_x+i)*SQUARE_SIZE,
                                           (START_POS[1]+4)+(start_y+j)*SQUARE_SIZE,
                                           SQUARE_SIZE-6, SQUARE_SIZE-6)
                        pygame.draw.rect(screen, BLUE, rect)
                        pygame.draw.rect(screen, LIGHT_BLUE, light_rect)
                        
                  if next_shape_pattern[j][i] == '*':
                        next_rect = pygame.Rect((430)+(next_start_x+i)*SQUARE_SIZE,
                                                (120)+(next_start_y+j)*SQUARE_SIZE,
                                                SQUARE_SIZE, SQUARE_SIZE)
                        light_next_rect = pygame.Rect((430+3)+(next_start_x+i)*SQUARE_SIZE,
                                                (120+3)+(next_start_y+j)*SQUARE_SIZE,
                                                SQUARE_SIZE-6, SQUARE_SIZE-6)
                        pygame.draw.rect(screen, BLUE, next_rect)
                        pygame.draw.rect(screen, LIGHT_BLUE, light_next_rect)
# generate the board data structure, namely a list of list or 2D list
def get_board():
      board = []
      for i in range(BOARD_WIDTH):
            board.append([])
            for j in range(BOARD_HEIGHT):
                  board[i].append('')
      return board

def draw_board(board):
      global screen
      screen.fill(WHITE)
      screen.blit(bg_surf, (0,0))
      # draw the board boarder
      #boarder_rect = pygame.Rect(START_POS[0]-2,START_POS[1]-2,SQUARE_SIZE*BOARD_WIDTH+2, SQUARE_SIZE*BOARD_HEIGHT+2)
      #pygame.draw.rect(screen, BLUE, boarder_rect, 2)
      # draw the board on the screen
      for i in range(BOARD_HEIGHT):
            for j in range(BOARD_WIDTH):
                  if board[j][i]: # if board cell is not empty string ''
                        rect = pygame.Rect(START_POS[0]+j*SQUARE_SIZE,START_POS[1]+i*SQUARE_SIZE,SQUARE_SIZE, SQUARE_SIZE)
                        light_rect = pygame.Rect(START_POS[0]+3+j*SQUARE_SIZE,
                                                 START_POS[1]+3+i*SQUARE_SIZE,
                                                 SQUARE_SIZE-6, SQUARE_SIZE-6)
                        pygame.draw.rect(screen, BLUE, rect)
                        pygame.draw.rect(screen, LIGHT_BLUE, light_rect)

def touch_bottom(pattern):
      shape_pattern = shapes[pattern['shape']][pattern['state']]
      y = pattern['y']
      for i in range(5):
            for j in range(5):
                  if shape_pattern[j][i] == '*':
                        if j + y == (BOARD_HEIGHT-1):
                              return True
      return False

def touch_others(pattern):
      shape_pattern = shapes[pattern['shape']][pattern['state']]
      x, y = pattern['x'], pattern['y']
      touch_pos = []
      for i in range(BOARD_WIDTH):
            for j in range(BOARD_HEIGHT):
                  if board[i][j] == '*' and board[i][j-1] == '':
                        touch_pos.append((i,j-1))
      if touch_pos:
            for i in range(5):
                  for j in range(5):
                        if shape_pattern[j][i] == '*':
                              if (x+i, y+j) in touch_pos:
                                    return True
      return False

def add_pattern_to_board(pattern):
      shape_pattern = shapes[pattern['shape']][pattern['state']]
      x, y = pattern['x'], pattern['y']
      for i in range(5):
            for j in range(5):
                  if shape_pattern[j][i] == '*':
                        board[x+i][y+j] = '*'

def is_valid_pos(pattern):
      shape_pattern = shapes[pattern['shape']][pattern['state']]
      x, y = pattern['x'], pattern['y']
      for i in range(5):
            for j in range(5):
                  if shape_pattern[j][i] == '*':
                        if not (0 <= x+i <= 9):
                              return False
                        elif board[x+i][y+j] == '*':
                              return False
      return True

# covert between row-based data structure and column-based data structure
def convert_board(board, colomn_based=True):
      b = []
      if colomn_based:
            for i in range(len(board[0])):
                  b.append([])
                  for j in range(len(board)):
                        b[i].append(board[j][i])
            return b
      else:
            for i in range(len(board[0])):
                  b.append([])
                  for j in range(len(board)):
                        b[i].append(board[j][i])
            return b
                  
def check_board_update():
##      print('check_board_update')
##      print(board)
      # convert column-based board to row-based board
      global board, score
      b = convert_board(board.copy())
      for row in range(len(b)):
            if b[row] == ['*'] * BOARD_WIDTH:
                  score += 1
                  while row > 0:
                        b[row] = b[row-1]
                        row -= 1
      # convert row-based board to column-based board
      b = convert_board(b, False)
      # update the board with b
      board = b
      
##      print(board)             
def display_game_info():
      global info_font, score
      score_surf = info_font.render(f'{score}', True, BLUE)
      #next_surf = info_font.render('Next: ', True, WHITE)
      if score < 10:
            screen.blit(score_surf,(530, 55))
      elif 10 <= score < 100:
            screen.blit(score_surf, (520, 55))
      elif 100 <= score < 1000:
            screen.blit(score_surf, (510, 55))
      elif 1000 <= score < 10000:
            screen.blit(score_surf, (500, 55))
      else:
            screen.blit(score_surf, (490, 55))
      #screen.blit(next_surf,(450, 60))

def game_over(pattern):
      global board
      shape_pattern = shapes[pattern['shape']][pattern['state']]
      x, y = pattern['x'], pattern['y']
      for i in range(5):
            for j in range(5):
                  if shape_pattern[j][i] == '*':
                        if board[x+i][y+j] == '*':
                              return True
      return False

def show_game_over():
      global info_font, screen
      game_over_surf = info_font.render('GAME OVER', True, WHITE)
      screen.blit(game_over_surf, (240, 200))
pygame.init()

screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
pygame.display.set_caption('Tetris')


game_clock = pygame.time.Clock()

board = get_board()

pattern = get_random_pattern()
next_pattern = get_random_pattern()

# time before and after drop
# we use the difference between begin_drop_time and end_drop_time to control the drop frequency
begin_drop_time = time.time()
end_drop_time = time.time()
drop_interval = 1 # each drop will take roughly 1 second

# tetris background image
bg_surf = pygame.image.load('tetris_bg01.png').convert_alpha()

# score
score = 0
info_font = pygame.font.SysFont('arial', 30)

key_down_pressed = False
while True:
      
      for event in pygame.event.get():
            if event.type == QUIT:
                  pygame.quit()
                  sys.exit()
            elif event.type == KEYDOWN:
                  # handle left and right movement
                  if event.key == K_LEFT:
                        pattern['x'] -= 1
                        if not is_valid_pos(pattern):
                              pattern['x'] += 1
                  elif event.key == K_RIGHT:
                        pattern['x'] += 1
                        if not is_valid_pos(pattern):
                              pattern['x'] -= 1
                  elif event.key == K_DOWN:
                        # move the pattern to the bottom quickly
                        key_down_pressed = True
                  # handle state change
                  elif event.key == K_UP:
                        # print(pattern['shape'])
                        original_state = pattern['state']
                        # print(original_state)
                        pattern['state'] = (pattern['state'] + 1) % len(shapes[pattern['shape']])
                        if not is_valid_pos(pattern): # if there is no enough space to rotate
                              pattern['state'] = original_state # go back to the original state
           
      #print(end_drop_time - begin_drop_time)
      if end_drop_time - begin_drop_time > drop_interval or key_down_pressed:
            pattern['y'] += 1
            begin_drop_time = time.time()
            
            
      if touch_bottom(pattern) or touch_others(pattern):
            if key_down_pressed:
                  key_down_pressed = False
            # if pattern touches bottom, add the pattern to the board 
            add_pattern_to_board(pattern)
            # check_board for eliminate the full rows
            check_board_update()
            # get a new random pattern for next drop
            pattern = next_pattern
            next_pattern = get_random_pattern()

      if game_over(pattern):
            draw_board(board)
            draw_shape(pattern, next_pattern)
            show_game_over()
            pygame.display.update()
            break
                  
            
      end_drop_time = time.time()
      # draw everything on the screen
      draw_board(board)
      draw_shape(pattern, next_pattern)
      display_game_info()
      
      pygame.display.update()    
      game_clock.tick(FPS)

Comments

Post a Comment

Popular posts from this blog

How to create a memory puzzle game with Python and Pygame (#005)

-
First look at the following code: import time # create Font object text_font = pygame . font . SysFont( 'arial' , 50 ) # create a list that stores two pos that going to compare to each other pos_to_compare_list = [] # create a list that stores all the pos that matched pos_matched = [] # set backgroud color to white while True : for event in pygame . event . get(): if event . type == QUIT: pygame . quit() sys . exit() elif event . type == MOUSEBUTTONDOWN: (x,y) = pygame . mouse . get_pos() pos = check_click(x,y, square_pos) if pos: text_surface = text_font . render(board[pos[ 0 ]][pos[ 1 ]], True , WHITE) if len (pos_to_compare_list) < 2 : if pos not in pos_to_compare_list: pos_to_compare_list . append(pos) ...
Read more

How to write a slide puzzle game with Python and Pygame (2020 tutorial)

-
Image
Table of Contents Preparation Introduction Import modules and define contants Create the main game screen Creae the data structure of the board Let's draw the tiles The game logic Define the missing functions Preparation In this tutorial, we are gonna use Python 3.8 and Pygame v1.96.  For the installation of Python and Pygame, please follow the documents found on each webiste. Python: https://www.python.org/ Pygame: https://www.pygame.org/ Introduction As you can see from the picture above, we create a board with 15 green tiles and one white tile which represent a empty slot. Our gaol is to place all the 15 green tiles back into its sorted order, namely: A B C D E F G H I J K L  M N O If we click on the tile "F", the tile will slide down south. And if all the tiles are back into their sorted order, you won the game and quit the game. That's pretty much the gist of the game, later you could add other features to the game. Import modules and define contatnts impor...
Read more

Introduction to multitasking with Python #003 gevent (2020 tutorial)

-
Image
  1 . Review of Iterator In python, we could achieve multitasking through another way by using gevent module. Howerver before introducing gevent, we have to review the concept of iterator. You may have used python for loop millions of times: for i in Iterable:     print(i) We have learned several iterable objects, str, list, tuple, dict and set. Those iterable objects or sequences could be used with the for loop. And we take that for granted. But look at the following example: >>> for i in 100: print(i) Traceback (most recent call last):   File "<pyshell#2>", line 1, in <module>     for i in 100: TypeError: 'int' object is not iterable >>>   Why cannot int type be used with for loop in Python and how could you make an object iterable and be used with for loop? Now, let's make an iterable object that could be used with for loop. We could use isinstance() built-in method to check whether an object is iterable or not. ...
Read more