devbox
IT小白
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

如何用Python编写俄罗斯方块Tetris游戏？_pygame tetris

作者：IT小白 | 2024-07-16 05:44:27

赞

踩

pygame tetris

在本文中，我们将用Python代码构建一个令人惊叹的项目：俄罗斯方块游戏。在这个项目中，我们将使用pygame库来构建游戏。要创建此项目，请确保您的系统中安装了最新版本的Python。让我们开始吧！

Pygame是一组跨平台的Python模块，用于创建视频游戏。它由设计用于Python编程语言的计算机图形和声音库组成。Pygame适合创建客户端应用程序，这些应用程序可能被封装在独立的可执行文件中。要学习pygame，需要具备Python的基本知识。

要安装pygame，请在终端中执行以下代码：

pip install pygame

我们已经完成了项目的先决条件。让我们来看看这个项目中的一些重要功能。

这种update_graphics方法用于设计游戏界面，并在游戏执行过程中进行必要的更新。该函数设置背景颜色和要显示的文本，并设置边框和宽度。它显示当前分数和时间。它绘制一个小屏幕来显示下一个块。为块设置瓷砖，每行20个瓷砖/平方，即19条水平线，每列10个瓷砖/广场，即9条垂直线。

draw_small_screen方法用于设计在游戏执行期间显示下一个块的相同屏幕界面。它设置背景、边框和文本，并显示下一个块。

manage_events函数用于在游戏执行期间处理块。

Python中俄罗斯方块游戏的完整代码：

我们可以在Pygame的帮助下用Python构建俄罗斯方块游戏，因为它有很多功能。现在，让我们从实现部分开始。在注释的帮助下，您可以逐行理解代码。

现在创建两个python文件，并将它们保存为util.py和tetris.py：

util.py文件：

  1. #Import libraries
  2. import pygame
  3. import sys
  4. import random
  5. import time
  6.  
  7. # Define important global variables
  8. pygame.init()
  9. clock = pygame.time.Clock()
  10.  
  11. best_score = 0
  12. longest_time = 0
  13.  
  14. width = 700
  15. height = 750
  16. DISPLAY_SCREEN = pygame.display.set_mode((width, height))
  17. pygame.display.set_caption(" Tetris")
  18.  
  19. off_set_x = 10
  20. off_set_y = 80
  21. playing_field_width = 330  #330 / 10 = 33 width per tile
  22. playing_field_height = 660  #600 / 20 = 33 height per tile
  23. tile_length = 33 # tile is a square
  24.  
  25. #colors
  26. blue = (0, 0, 255)
  27. white = (255, 255, 255) 
  28. black = (0, 0, 0)
  29. gray = (95, 95, 96) 
  30. orange  = (249, 87, 0)  
  31. cobalt_blue = (3, 65, 174)
  32. green_apple  = (114, 203, 59)
  33. cyber_yellow= (255, 213, 0)
  34. beer = (255, 151, 28)
  35. ryb_red = (255, 50, 19)
  36. purple = (128, 0, 128)
  37.  
  38. # colors of Tetris blocks
  39. block_colors = (cobalt_blue, blue, green_apple, purple, cyber_yellow, beer, ryb_red)
  40. # shapes of Tetris blocks
  41. shapes = ("i_block", "l_block", "j_block", "o_block", "s_block", "t_block", "z_block")
  42. directions = ("vertical_1", "vertical_2", "horizontal_1", "horizontal_2")
  43.  
  44. background_img = pygame.image.load("resources/images/background_img.jpg")      
  45. instructions_img = pygame.image.load("resources/images/instructions_img.jpg")  
  46. icon_img = pygame.image.load("resources/images/icon.png")
  47. pygame.display.set_icon(icon_img)
  48.  
  49. class Button:
  50.     def __init__(self, button_color, button_hover_over_color, x, y, width, height, text_size,  text_color, text_hover_over_color = None, text_str=""):
  51.         self.button_color = button_color
  52.         self.button_hover_over_color = button_hover_over_color
  53.         self.x = x
  54.         self.y = y
  55.         self.width = width
  56.         self.height = height
  57.         self.text_size = text_size
  58.         self.text_color = text_color
  59.  
  60.         if text_hover_over_color:
  61.             self.text_hover_over_color = text_hover_over_color
  62.         else:
  63.             self.text_hover_over_color =  text_color
  64.  
  65.         self.text_str = text_str
  66.  
  67.  
  68.     def blit(self, display_screen, outline_color=None):
  69.         if outline_color: 
  70.             pygame.draw.rect(display_screen, outline_color, (self.x-3, self.y-3, self.width+6, self.height+6))
  71.         
  72.         pygame.draw.rect(display_screen, self.button_color, (self.x, self.y, self.width, self.height))
  73.  
  74.         if self.text_str != "": 
  75.             font = pygame.font.Font("freesansbold.ttf", self.text_size)
  76.             text = font.render(self.text_str, True, self.text_color)
  77.             # to center the text in the middle of the button based on the size of the button
  78.             text_position = (self.x + (self.width/2 - text.get_width()/2), self.y + (self.height/2 - text.get_height()/2))
  79.             display_screen.blit(text, text_position)
  80.  
  81.  
  82.     def is_hovered_over(self, mouse_position):
  83.         if self.x < mouse_position[0] < self.x+self.width and self.y < mouse_position[1] < self.y+self.height:
  84.             return True
  85.         return False
  86.  
  87.  
  88.     def blit_hovered_over(self, display_screen):
  89.         pygame.draw.rect(display_screen, self.button_hover_over_color, (self.x, self.y, self.width, self.height))
  90.  
  91.         if self.text_str != "":
  92.             font = pygame.font.Font("freesansbold.ttf", self.text_size)
  93.             text = font.render(self.text_str, True, self.text_hover_over_color)
  94.             # to center the text in the middle of the button based on the size of the button
  95.             text_position = (self.x + (self.width/2 - text.get_width()/2), self.y + (self.height/2 - text.get_height()/2))
  96.             display_screen.blit(text, text_position)
  97.  
  98.  
  99.     def is_clicked(self, mouse_position, event):
  100.         if self.is_hovered_over(mouse_position):
  101.             if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
  102.                 return True
  103.         return False
  104.  
  105. class Tile:
  106.     def __init__(self, x, y, color = black):
  107.         self.x = x
  108.         self.y = y
  109.         self.color = color
  110.         self.empty = True
  111.  
  112.  
  113.     def draw_tile(self):
  114.         pygame.draw.rect(DISPLAY_SCREEN , self.color, (self.x, self.y, tile_length, tile_length) )
  115.  
  116.  
  117. class PlayingField():
  118.     def __init__(self):
  119.         #y coordinate of first row = (80) off_set_y 
  120.         self.tiles = {
  121.             "row1":  {80:  []},
  122.             "row2":  {113: []},
  123.             "row3":  {146: []},
  124.             "row4":  {179: []},
  125.             "row5":  {212: []},
  126.             "row6":  {245: []},
  127.             "row7":  {278: []},
  128.             "row8":  {311: []},
  129.             "row9":  {344: []},
  130.             "row10": {377: []},
  131.             "row11": {410: []},
  132.             "row12": {443: []},
  133.             "row13": {476: []},
  134.             "row14": {509: []},
  135.             "row15": {542: []},
  136.             "row16": {575: []},
  137.             "row17": {608: []},
  138.             "row18": {641: []},
  139.             "row19": {674: []},
  140.             "row20": {707: []},
  141.         }
  142.         self.__init_field()
  143.  
  144.  
  145.     def __init_field(self):    
  146.         y = off_set_y
  147.         for i in range(20): #rows
  148.             x = off_set_x
  149.             for j in range(10): #cols
  150.                 tile_to_add = Tile(x, y) 
  151.                 self.tiles["row"+str(i+1)][y].append(tile_to_add)
  152.                 x += tile_length
  153.             y += tile_length
  154.     
  155.  
  156.     def destory_full_row(self, player):
  157.         times = 0
  158.         y = off_set_y        
  159.         for i in range(20):
  160.             for tile in self.tiles["row"+str(i+1)][y]:
  161.                 if tile.empty: break
  162.  
  163.                 elif tile.x == off_set_x+playing_field_width-tile_length:
  164.                     times += 1
  165.                     for j in range(800): #just for flashing the row
  166.                         if j%2 == 0:
  167.                             pygame.draw.rect(DISPLAY_SCREEN , black, (self.tiles["row"+str(i+1)][y][0].x+1, self.tiles["row"+str(i+1)][y][0].y+1, playing_field_width-2, tile_length-2) )
  168.                         else:
  169.                             for tile in self.tiles["row"+str(i+1)][y]:
  170.                                 pygame.draw.rect(DISPLAY_SCREEN , tile.color, (tile.x, tile.y, tile_length, tile_length) )
  171.                         pygame.draw.line(DISPLAY_SCREEN , white, (off_set_x, y), (playing_field_width+off_set_x-1, y)) # horizontal line
  172.                         pygame.display.update()
  173.  
  174.                     # let's destory this full row
  175.                     self.destroy_and_replace(i+1, y)
  176.                     player.score += 10*times
  177.  
  178.             y += tile_length 
  179.  
  180.  
  181.     def destroy_and_replace(self, row_number, row_y):
  182.         for i in range (row_number, 1, -1):
  183.             prev_row_number = i-1
  184.             prev_y = row_y-tile_length
  185.             
  186.             self.tiles["row"+str(i)][row_y].clear() #current_row.clear()
  187.             temp_x = off_set_x
  188.             for j in range(10):
  189.                 empty_tile = Tile(temp_x, row_y)
  190.                 temp_x += tile_length
  191.                 self.tiles["row"+str(i)][row_y].append(empty_tile)
  192.             if prev_y < 80: 
  193.                 break
  194.  
  195.             
  196.             for j in range(10):
  197.                 old_tile = self.tiles["row"+str(i)][row_y][j]
  198.                 new_tile = self.tiles["row"+str(prev_row_number)][prev_y][j] 
  199.                 old_tile.x = new_tile.x
  200.                 old_tile.color = new_tile.color 
  201.                 old_tile.empty = new_tile.empty
  202.  
  203.             row_y -= tile_length
  204.  
  205.  
  206. class Block:
  207.     def __init__(self, shape:str, color = black):
  208.         self.shape = shape
  209.         self.color = color
  210.  
  211.         self.direction = directions[0] #vertical_1
  212.  
  213.         #                         tile1                                                        , tile2            , tile3            , tile4
  214.         self.tiles = [ Tile(off_set_x+playing_field_width/2-tile_length, off_set_y, self.color), Tile(0, 0, color), Tile(0, 0, color), Tile(0, 0, color)]
  215.         
  216.         self.__init_shape() 
  217.         for tile in self.tiles:
  218.             tile.empty = False
  219.  
  220.  
  221.     def __init_shape(self):
  222.         if self.shape == "i_block":
  223.             self.tiles[1] = Tile(self.tiles[0].x, self.tiles[0].y-tile_length, self.color)
  224.             self.tiles[2] = Tile(self.tiles[0].x, self.tiles[1].y-tile_length, self.color)
  225.             self.tiles[3] = Tile(self.tiles[0].x, self.tiles[2].y-tile_length, self.color)
  226.         elif self.shape == "l_block":
  227.             self.tiles[1] = Tile(self.tiles[0].x+tile_length, self.tiles[0].y, self.color)
  228.             self.tiles[2] = Tile(self.tiles[0].x-tile_length, self.tiles[0].y, self.color)
  229.             self.tiles[3] = Tile(self.tiles[2].x, self.tiles[2].y-tile_length, self.color)
  230.         elif self.shape == "j_block":
  231.             self.tiles[1] = Tile(self.tiles[0].x+tile_length, self.tiles[0].y, self.color)
  232.             self.tiles[2] = Tile(self.tiles[0].x-tile_length, self.tiles[0].y, self.color)
  233.             self.tiles[3] = Tile(self.tiles[1].x, self.tiles[1].y-tile_length, self.color)
  234.         elif self.shape == "o_block":
  235.             self.tiles[1] = Tile(self.tiles[0].x+tile_length,  self.tiles[0].y, self.color)
  236.             self.tiles[2] = Tile(self.tiles[0].x, self.tiles[0].y-tile_length, self.color)
  237.             self.tiles[3] = Tile(self.tiles[1].x, self.tiles[1].y-tile_length, self.color)
  238.         elif self.shape == "s_block":
  239.             self.tiles[1] = Tile(self.tiles[0].x-tile_length, self.tiles[0].y, self.color)
  240.             self.tiles[2] = Tile(self.tiles[0].x, self.tiles[0].y-tile_length, self.color)
  241.             self.tiles[3] = Tile(self.tiles[2].x+tile_length, self.tiles[2].y, self.color)
  242.         elif self.shape == "t_block":
  243.             self.tiles[1] = Tile(self.tiles[0].x+tile_length,  self.tiles[0].y, self.color)
  244.             self.tiles[2] = Tile(self.tiles[0].x-tile_length, self.tiles[0].y, self.color)
  245.             self.tiles[3] = Tile(self.tiles[0].x, self.tiles[0].y-tile_length, self.color)
  246.         elif self.shape == "z_block":
  247.             self.tiles[1] = Tile(self.tiles[0].x+tile_length,  self.tiles[0].y, self.color)
  248.             self.tiles[2] = Tile(self.tiles[0].x, self.tiles[0].y-tile_length, self.color)
  249.             self.tiles[3] = Tile(self.tiles[2].x-tile_length, self.tiles[2].y, self.color)
  250.         else:
  251.             print("Error: wrong block name.")
  252.             pygame.quit()
  253.             sys.exit()
  254.  
  255.     
  256.     def complete_block(self):
  257.         self.__init_shape()
  258.  
  259.  
  260.     def can_fall(self, next_block, playing_field, player):
  261.         from tetris import manage_events, update_graphics
  262.         manage_events(self, next_block, playing_field, player)
  263.         #check borders
  264.         for block_tile in self.tiles:
  265.             if block_tile.y >= playing_field_height+off_set_y-tile_length:
  266.                 return False  
  267.  
  268.         #check already existed tiles
  269.         for block_tile in self.tiles:
  270.             y = off_set_y
  271.             for i in range(20):
  272.                 for tile in playing_field.tiles["row"+str(i+1)][y]:
  273.                     if not tile.empty and block_tile.y+tile_length == tile.y and block_tile.x == tile.x: 
  274.                         return False  
  275.                 y += tile_length
  276.     
  277.         return True
  278.  
  279.  
  280.     def block_is_falling(self, next_block, playing_field, player, faster=None):
  281.         from tetris import manage_events, update_graphics
  282.         manage_events(self,next_block, playing_field, player)
  283.  
  284.         if self.can_fall(next_block, playing_field, player):
  285.             for tile in self.tiles:
  286.                 tile.y += tile_length
  287.  
  288.             manage_events(self, next_block, playing_field, player)             
  289.             update_graphics(self, next_block, playing_field, player)
  290.             if faster:                
  291.                 clock.tick(40)
  292.                 self.block_is_falling( next_block, playing_field, player)
  293.             else:                
  294.                 clock.tick(5)
  295.             manage_events(self, next_block, playing_field, player)             
  296.             update_graphics(self, next_block, playing_field, player)
  297.  
  298.  
  299.     def get_new_block(self, next_block, playing_field, player):
  300.         if self.can_fall(next_block, playing_field, player): return (self, next_block, False)
  301.         
  302.         #if the block has falled completely
  303.         for block_tile in self.tiles: 
  304.             found = False 
  305.             y = off_set_y
  306.             for i in range(20):
  307.                 if not found:
  308.                     for j in range(10):
  309.                         if block_tile.x == playing_field.tiles["row"+str(i+1)][y][j].x and block_tile.y == playing_field.tiles["row"+str(i+1)][y][j].y:
  310.                             playing_field.tiles["row"+str(i+1)][y][j].color = block_tile.color
  311.                             playing_field.tiles["row"+str(i+1)][y][j].empty = False
  312.                             found = True
  313.                             break
  314.                     y += tile_length
  315.                 else:
  316.                     break
  317.         
  318.         new_block = next_block
  319.  
  320.         next_rand_index1 = random.randint(0, 6)
  321.         next_rand_index2 = random.randint(0, 6)
  322.         new_next_block = Block(shapes[next_rand_index1], block_colors[next_rand_index2])
  323.  
  324.         clock.tick(2)
  325.         return (new_block, new_next_block, True)
  326.  
  327.  
  328.     def move_left(self, playing_field):
  329.         if self.can_move_left(playing_field):
  330.             for tile in self.tiles:
  331.                 tile.x -= tile_length
  332.  
  333.  
  334.     def move_right(self, playing_field):
  335.         if self.can_move_right(playing_field):
  336.             for tile in self.tiles:
  337.                 tile.x += tile_length
  338.  
  339.  
  340.     def can_move_left(self, playing_field):
  341.         # whether inside the playing field or not
  342.         for tile in self.tiles:
  343.             if tile.x <= off_set_x:
  344.                 return False
  345.         # whether adjacent field_tiles are occupied or not
  346.         for block_tile in self.tiles:
  347.             y = off_set_y
  348.             for i in range(20):
  349.                 for tile in playing_field.tiles["row"+str(i+1)][y]:
  350.                     if not tile.empty and block_tile.x-tile_length == tile.x and block_tile.y  == tile.y:
  351.                         return False  
  352.                 y += tile_length
  353.         return True
  354.         
  355.  
  356.     def can_move_right(self, playing_field):
  357.         # whether inside the playing field or not
  358.         for tile in self.tiles:
  359.             if tile.x + tile_length >= off_set_x+playing_field_width:
  360.                 return False
  361.         # whether adjacent field_tiles are occupied or not
  362.         for block_tile in self.tiles:
  363.             y = off_set_y
  364.             for i in range(20):
  365.                 for tile in playing_field.tiles["row"+str(i+1)][y]:
  366.                     if not tile.empty and block_tile.x+tile_length == tile.x and block_tile.y  == tile.y:
  367.                         return False  
  368.                 y += tile_length
  369.         return True
  370.  
  371.  
  372.     def rotate(self, next_block, playing_field, player):
  373.         from tetris import manage_events, update_graphics
  374.         manage_events(self, next_block, playing_field, player)
  375.  
  376.         if self.shape == "i_block":
  377.             self.rotate_i_block(playing_field)
  378.         elif self.shape == "l_block":
  379.             self.rotate_l_block(playing_field)
  380.         elif self.shape == "j_block":
  381.             self.rotate_j_block(playing_field)
  382.         elif self.shape == "o_block":
  383.             return
  384.             #no rotation for o_block.
  385.         elif self.shape == "s_block":
  386.             self.rotate_s_block(playing_field)
  387.         elif self.shape == "t_block":
  388.             self.rotate_t_block(playing_field)
  389.         elif self.shape == "z_block":
  390.             self.rotate_z_block(playing_field)
  391.         else:
  392.             print("Error: wrong block name.")
  393.             pygame.quit()
  394.             sys.exit()
  395.         manage_events(self, next_block, playing_field, player)
  396.         update_graphics(self, next_block, playing_field, player)
  397.  
  398.  
  399.     def rotate_i_block(self, playing_field): #done
  400.         temp_rotated_i = Block("i_block", self.color)
  401.         temp_rotated_i.tiles = self.tiles.copy()
  402.         
  403.         if self.direction == directions[0] or self.direction == directions[1]:
  404.             # ----
  405.             temp_rotated_i.tiles[0] = Tile(temp_rotated_i.tiles[1].x, temp_rotated_i.tiles[0].y, temp_rotated_i.color) 
  406.             temp_rotated_i.tiles[1] = Tile(temp_rotated_i.tiles[0].x-tile_length, temp_rotated_i.tiles[0].y, temp_rotated_i.color)
  407.             temp_rotated_i.tiles[2] = Tile(temp_rotated_i.tiles[0].x+tile_length, temp_rotated_i.tiles[0].y, temp_rotated_i.color)
  408.             temp_rotated_i.tiles[3] = Tile(temp_rotated_i.tiles[2].x+tile_length, temp_rotated_i.tiles[0].y, temp_rotated_i.color)
  409.             temp_rotated_i.direction = directions[2] # "horizontal_1"
  410.         elif self.direction == directions[2] or self.direction == directions[3]:
  411.             # |
  412.             # |
  413.             # |
  414.             # |
  415.             temp_rotated_i.tiles[1] = Tile(temp_rotated_i.tiles[0].x, temp_rotated_i.tiles[0].y-tile_length, temp_rotated_i.color)
  416.             temp_rotated_i.tiles[2] = Tile(temp_rotated_i.tiles[1].x, temp_rotated_i.tiles[1].y-tile_length, temp_rotated_i.color)
  417.             temp_rotated_i.tiles[3] = Tile(temp_rotated_i.tiles[2].x, temp_rotated_i.tiles[2].y-tile_length, temp_rotated_i.color)
  418.             temp_rotated_i.direction = directions[0] #"vertical_1"
  419.  
  420.         for block_tile in temp_rotated_i.tiles:
  421.             if block_tile.x <= off_set_x or block_tile.x >= playing_field_width:
  422.                 return 
  423.             y = off_set_y
  424.             for i in range(20):
  425.                 for tile in playing_field.tiles["row"+str(i+1)][y]:
  426.                     if not tile.empty and block_tile.x == tile.x and block_tile.y  == tile.y:
  427.                         return
  428.                 y += tile_length
  429.  
  430.         self.direction = temp_rotated_i.direction
  431.         self.tiles = temp_rotated_i.tiles
  432.  
  433.  
  434.     def rotate_l_block(self, playing_field): #done
  435.         temp_rotated_l = Block("l_block", self.color)
  436.         temp_rotated_l.tiles = self.tiles.copy()
  437.         
  438.         if self.direction == directions[0]:
  439.             # after rotating, the block should look like this ↓
  440.             #  _
  441.             # |
  442.             # |
  443.             # |
  444.             temp_rotated_l.tiles[0] = Tile(temp_rotated_l.tiles[0].x, temp_rotated_l.tiles[0].y, temp_rotated_l.color)
  445.             temp_rotated_l.tiles[1] = Tile(temp_rotated_l.tiles[0].x, temp_rotated_l.tiles[0].y-tile_length, temp_rotated_l.color)
  446.             temp_rotated_l.tiles[2] = Tile(temp_rotated_l.tiles[1].x, temp_rotated_l.tiles[1].y-tile_length, temp_rotated_l.color)
  447.             temp_rotated_l.tiles[3] = Tile(temp_rotated_l.tiles[2].x+tile_length, temp_rotated_l.tiles[2].y, temp_rotated_l.color)
  448.             temp_rotated_l.direction = directions[2] # "horizontal_1"
  449.         elif self.direction == directions[2]:
  450.             # after rotating, the block should look like this ↓
  451.             # ---
  452.             #   |
  453.             temp_rotated_l.tiles[0] = Tile(temp_rotated_l.tiles[3].x, temp_rotated_l.tiles[0].y, temp_rotated_l.color)
  454.             temp_rotated_l.tiles[1] = Tile(temp_rotated_l.tiles[0].x, temp_rotated_l.tiles[0].y-tile_length, temp_rotated_l.color)
  455.             temp_rotated_l.tiles[2] = Tile(temp_rotated_l.tiles[1].x-tile_length, temp_rotated_l.tiles[1].y, temp_rotated_l.color)
  456.             temp_rotated_l.tiles[3] = Tile(temp_rotated_l.tiles[2].x-tile_length, temp_rotated_l.tiles[2].y, temp_rotated_l.color)
  457.             temp_rotated_l.direction = directions[1] #"vertical_2"
  458.         elif self.direction == directions[1]: 
  459.             # after rotating, the block should look like this ↓
  460.             #  |
  461.             #  |
  462.             # _|
  463.             temp_rotated_l.tiles[0] = Tile(temp_rotated_l.tiles[3].x, temp_rotated_l.tiles[0].y, temp_rotated_l.color)
  464.             temp_rotated_l.tiles[1] = Tile(temp_rotated_l.tiles[0].x+tile_length, temp_rotated_l.tiles[0].y, temp_rotated_l.color)
  465.             temp_rotated_l.tiles[2] = Tile(temp_rotated_l.tiles[1].x, temp_rotated_l.tiles[1].y-tile_length, temp_rotated_l.color)
  466.             temp_rotated_l.tiles[3] = Tile(temp_rotated_l.tiles[2].x, temp_rotated_l.tiles[2].y-tile_length, temp_rotated_l.color)
  467.             temp_rotated_l.direction = directions[3] #"horizontal_2"
  468.         elif self.direction == directions[3]: 
  469.             # after rotating, the block should look like this ↓
  470.             # |
  471.             # ---
  472.             temp_rotated_l.tiles[0] = Tile(temp_rotated_l.tiles[1].x, temp_rotated_l.tiles[0].y, temp_rotated_l.color)
  473.             temp_rotated_l.tiles[1] = Tile(temp_rotated_l.tiles[0].x+tile_length, temp_rotated_l.tiles[0].y, temp_rotated_l.color)
  474.             temp_rotated_l.tiles[2] = Tile(temp_rotated_l.tiles[0].x-tile_length, temp_rotated_l.tiles[1].y, temp_rotated_l.color)
  475.             temp_rotated_l.tiles[3] = Tile(temp_rotated_l.tiles[2].x, temp_rotated_l.tiles[2].y-tile_length, temp_rotated_l.color) 
  476.             temp_rotated_l.direction = directions[0] #"vertical_1"
  477.  
  478.         for block_tile in temp_rotated_l.tiles:
  479.             if block_tile.x <= off_set_x or block_tile.x >= playing_field_width:
  480.                 return 
  481.             y = off_set_y
  482.             for i in range(20):
  483.                 for tile in playing_field.tiles["row"+str(i+1)][y]:
  484.                     if not tile.empty and block_tile.x == tile.x and block_tile.y  == tile.y:
  485.                         return
  486.                 y += tile_length
  487.  
  488.         self.direction = temp_rotated_l.direction
  489.         self.tiles = temp_rotated_l.tiles
  490.         
  491.  
  492.     def rotate_j_block(self, playing_field): #done
  493.         temp_rotated_j = Block("j_block", self.color)
  494.         temp_rotated_j.tiles = self.tiles.copy()
  495.         
  496.         if self.direction == directions[0]: 
  497.             temp_rotated_j.tiles[0] = Tile(temp_rotated_j.tiles[1].x, temp_rotated_j.tiles[0].y, temp_rotated_j.color)
  498.             temp_rotated_j.tiles[1] = Tile(temp_rotated_j.tiles[0].x-tile_length, temp_rotated_j.tiles[0].y, temp_rotated_j.color)
  499.             temp_rotated_j.tiles[2] = Tile(temp_rotated_j.tiles[1].x, temp_rotated_j.tiles[1].y-tile_length, temp_rotated_j.color)
  500.             temp_rotated_j.tiles[3] = Tile(temp_rotated_j.tiles[2].x, temp_rotated_j.tiles[2].y-tile_length, temp_rotated_j.color)
  501.             temp_rotated_j.direction = directions[2] # "horizontal_1"
  502.         elif self.direction == directions[2]:
  503.             temp_rotated_j.tiles[0] = Tile(temp_rotated_j.tiles[1].x-tile_length, temp_rotated_j.tiles[0].y, temp_rotated_j.color)
  504.             temp_rotated_j.tiles[1] = Tile(temp_rotated_j.tiles[0].x, temp_rotated_j.tiles[0].y-tile_length, temp_rotated_j.color)
  505.             temp_rotated_j.tiles[2] = Tile(temp_rotated_j.tiles[1].x+tile_length, temp_rotated_j.tiles[1].y, temp_rotated_j.color)
  506.             temp_rotated_j.tiles[3] = Tile(temp_rotated_j.tiles[2].x+tile_length, temp_rotated_j.tiles[2].y, temp_rotated_j.color)
  507.             temp_rotated_j.direction = directions[1] #"vertical_2"
  508.         elif self.direction == directions[1]: 
  509.             temp_rotated_j.tiles[0] = Tile(temp_rotated_j.tiles[2].x, temp_rotated_j.tiles[0].y, temp_rotated_j.color)
  510.             temp_rotated_j.tiles[1] = Tile(temp_rotated_j.tiles[0].x, temp_rotated_j.tiles[0].y-tile_length, temp_rotated_j.color)
  511.             temp_rotated_j.tiles[2] = Tile(temp_rotated_j.tiles[1].x, temp_rotated_j.tiles[1].y-tile_length, temp_rotated_j.color)
  512.             temp_rotated_j.tiles[3] = Tile(temp_rotated_j.tiles[2].x-tile_length, temp_rotated_j.tiles[2].y, temp_rotated_j.color)
  513.             temp_rotated_j.direction = directions[3] #"horizontal_2"
  514.         elif self.direction == directions[3]: #back to normal:
  515.             temp_rotated_j.tiles[0] = Tile(temp_rotated_j.tiles[0].x, temp_rotated_j.tiles[0].y, temp_rotated_j.color)
  516.             temp_rotated_j.tiles[1] = Tile(temp_rotated_j.tiles[0].x+tile_length, temp_rotated_j.tiles[0].y, temp_rotated_j.color)
  517.             temp_rotated_j.tiles[2] = Tile(temp_rotated_j.tiles[0].x-tile_length, temp_rotated_j.tiles[0].y, temp_rotated_j.color)
  518.             temp_rotated_j.tiles[3] = Tile(temp_rotated_j.tiles[1].x, temp_rotated_j.tiles[1].y-tile_length, temp_rotated_j.color) 
  519.             temp_rotated_j.direction = directions[0] #"vertical_1"
  520.  
  521.         for block_tile in temp_rotated_j.tiles:
  522.             if block_tile.x <= off_set_x or block_tile.x >= playing_field_width:
  523.                 return 
  524.             y = off_set_y
  525.             for i in range(20):
  526.                 for tile in playing_field.tiles["row"+str(i+1)][y]:
  527.                     if not tile.empty and block_tile.x == tile.x and block_tile.y  == tile.y:
  528.                         return 
  529.                 y += tile_length
  530.  
  531.         self.direction = temp_rotated_j.direction
  532.         self.tiles = temp_rotated_j.tiles
  533.  
  534.  
  535.     def rotate_s_block(self, playing_field): #done
  536.         temp_rotated_s = Block("s_block", self.color)
  537.         temp_rotated_s.tiles = self.tiles.copy()
  538.         
  539.         if self.direction == directions[0] or self.direction == directions[1]:
  540.             temp_rotated_s.tiles[0] = Tile(temp_rotated_s.tiles[3].x, temp_rotated_s.tiles[0].y, temp_rotated_s.color)
  541.             temp_rotated_s.tiles[1] = Tile(temp_rotated_s.tiles[0].x, temp_rotated_s.tiles[0].y-tile_length, temp_rotated_s.color)
  542.             temp_rotated_s.tiles[2] = Tile(temp_rotated_s.tiles[1].x-tile_length, temp_rotated_s.tiles[1].y, temp_rotated_s.color)
  543.             temp_rotated_s.tiles[3] = Tile(temp_rotated_s.tiles[2].x, temp_rotated_s.tiles[2].y-tile_length, temp_rotated_s.color)
  544.             temp_rotated_s.direction = directions[2] # "horizontal_1"
  545.         elif self.direction == directions[2] or self.direction == directions[3]
  546.             temp_rotated_s.tiles[0] = Tile(temp_rotated_s.tiles[2].x, temp_rotated_s.tiles[0].y, temp_rotated_s.color)
  547.             temp_rotated_s.tiles[1] = Tile(temp_rotated_s.tiles[0].x-tile_length, temp_rotated_s.tiles[0].y, temp_rotated_s.color)
  548.             temp_rotated_s.tiles[2] = Tile(temp_rotated_s.tiles[0].x, temp_rotated_s.tiles[0].y-tile_length, temp_rotated_s.color)
  549.             temp_rotated_s.tiles[3] = Tile(temp_rotated_s.tiles[2].x+tile_length, temp_rotated_s.tiles[2].y, temp_rotated_s.color)
  550.             temp_rotated_s.direction = directions[0] #"vertical_1"
  551.  
  552.         for block_tile in temp_rotated_s.tiles:
  553.             if block_tile.x <= off_set_x or block_tile.x >= playing_field_width:
  554.                 return 
  555.             y = off_set_y
  556.             for i in range(20):
  557.                 for tile in playing_field.tiles["row"+str(i+1)][y]:
  558.                     if not tile.empty and block_tile.x == tile.x and block_tile.y  == tile.y:
  559.                         return
  560.                 y += tile_length
  561.  
  562.         self.direction = temp_rotated_s.direction
  563.         self.tiles = temp_rotated_s.tiles   
  564.  
  565.  
  566.     def rotate_t_block(self, playing_field): #done
  567.         temp_rotated_t = Block("j_block", self.color)
  568.         temp_rotated_t.tiles = self.tiles.copy()
  569.         
  570.         if self.direction == directions[0]: 
  571.             temp_rotated_t.tiles[0] = Tile(temp_rotated_t.tiles[0].x, temp_rotated_t.tiles[0].y, temp_rotated_t.color)
  572.             temp_rotated_t.tiles[1] = Tile(temp_rotated_t.tiles[0].x, temp_rotated_t.tiles[0].y-tile_length, temp_rotated_t.color)
  573.             temp_rotated_t.tiles[2] = Tile(temp_rotated_t.tiles[1].x, temp_rotated_t.tiles[1].y-tile_length, temp_rotated_t.color)
  574.             temp_rotated_t.tiles[3] = Tile(temp_rotated_t.tiles[1].x+tile_length, temp_rotated_t.tiles[1].y, temp_rotated_t.color)
  575.             temp_rotated_t.direction = directions[2] # "horizontal_1"
  576.         elif self.direction == directions[2]:
  577.             temp_rotated_t.tiles[0] = Tile(temp_rotated_t.tiles[0].x, temp_rotated_t.tiles[0].y, temp_rotated_t.color)
  578.             temp_rotated_t.tiles[1] = Tile(temp_rotated_t.tiles[0].x, temp_rotated_t.tiles[0].y-tile_length, temp_rotated_t.color)
  579.             temp_rotated_t.tiles[2] = Tile(temp_rotated_t.tiles[1].x-tile_length, temp_rotated_t.tiles[1].y, temp_rotated_t.color)
  580.             temp_rotated_t.tiles[3] = Tile(temp_rotated_t.tiles[1].x+tile_length, temp_rotated_t.tiles[2].y, temp_rotated_t.color)
  581.             temp_rotated_t.direction = directions[1] #"vertical_2"
  582.         elif self.direction == directions[1]:
  583.             temp_rotated_t.tiles[0] = Tile(temp_rotated_t.tiles[0].x, temp_rotated_t.tiles[0].y, temp_rotated_t.color)
  584.             temp_rotated_t.tiles[1] = Tile(temp_rotated_t.tiles[0].x, temp_rotated_t.tiles[0].y-tile_length, temp_rotated_t.color)
  585.             temp_rotated_t.tiles[2] = Tile(temp_rotated_t.tiles[1].x, temp_rotated_t.tiles[1].y-tile_length, temp_rotated_t.color)
  586.             temp_rotated_t.tiles[3] = Tile(temp_rotated_t.tiles[1].x-tile_length, temp_rotated_t.tiles[1].y, temp_rotated_t.color)
  587.             temp_rotated_t.direction = directions[3] #"horizontal_2"
  588.         elif self.direction == directions[3]: #back to normal:
  589.             temp_rotated_t.tiles[0] = Tile(temp_rotated_t.tiles[0].x, temp_rotated_t.tiles[0].y, temp_rotated_t.color)
  590.             temp_rotated_t.tiles[1] = Tile(temp_rotated_t.tiles[0].x+tile_length, temp_rotated_t.tiles[0].y, temp_rotated_t.color)
  591.             temp_rotated_t.tiles[2] = Tile(temp_rotated_t.tiles[0].x-tile_length, temp_rotated_t.tiles[0].y, temp_rotated_t.color)
  592.             temp_rotated_t.tiles[3] = Tile(temp_rotated_t.tiles[0].x, temp_rotated_t.tiles[0].y-tile_length, temp_rotated_t.color) 
  593.             temp_rotated_t.direction = directions[0] #"vertical_1"
  594.  
  595.         for block_tile in temp_rotated_t.tiles:
  596.             if block_tile.x <= off_set_x or block_tile.x >= playing_field_width:
  597.                 return 
  598.             y = off_set_y
  599.             for i in range(20):
  600.                 for tile in playing_field.tiles["row"+str(i+1)][y]:
  601.                     if not tile.empty and block_tile.x == tile.x and block_tile.y  == tile.y:
  602.                         return
  603.                 y += tile_length
  604.  
  605.         self.direction = temp_rotated_t.direction
  606.         self.tiles = temp_rotated_t.tiles
  607.  
  608.  
  609.     def rotate_z_block(self, playing_field): #done
  610.         temp_rotated_z = Block("z_block", self.color)
  611.         temp_rotated_z.tiles = self.tiles.copy()
  612.         
  613.         if self.direction == directions[0] or self.direction == directions[1]:
  614.  
  615.             temp_rotated_z.tiles[0] = Tile(temp_rotated_z.tiles[3].x, temp_rotated_z.tiles[0].y, temp_rotated_z.color)
  616.             temp_rotated_z.tiles[1] = Tile(temp_rotated_z.tiles[0].x, temp_rotated_z.tiles[0].y-tile_length, temp_rotated_z.color)
  617.             temp_rotated_z.tiles[2] = Tile(temp_rotated_z.tiles[1].x+tile_length, temp_rotated_z.tiles[1].y, temp_rotated_z.color)
  618.             temp_rotated_z.tiles[3] = Tile(temp_rotated_z.tiles[2].x, temp_rotated_z.tiles[2].y-tile_length, temp_rotated_z.color)
  619.             temp_rotated_z.direction = directions[2] # "horizontal_1"
  620.         elif self.direction == directions[2] or self.direction == directions[3]:
  621.             temp_rotated_z.tiles[0] = Tile(temp_rotated_z.tiles[3].x, temp_rotated_z.tiles[0].y, temp_rotated_z.color)
  622.             temp_rotated_z.tiles[1] = Tile(temp_rotated_z.tiles[0].x+tile_length, temp_rotated_z.tiles[0].y, temp_rotated_z.color)
  623.             temp_rotated_z.tiles[2] = Tile(temp_rotated_z.tiles[0].x, temp_rotated_z.tiles[0].y-tile_length, temp_rotated_z.color)
  624.             temp_rotated_z.tiles[3] = Tile(temp_rotated_z.tiles[2].x-tile_length, temp_rotated_z.tiles[2].y, temp_rotated_z.color)
  625.             temp_rotated_z.direction = directions[0] #"vertical_1"
  626.  
  627.         for block_tile in temp_rotated_z.tiles:
  628.             if block_tile.x <= off_set_x or block_tile.x >= playing_field_width:
  629.                 return 
  630.             y = off_set_y
  631.             for i in range(20):
  632.                 for tile in playing_field.tiles["row"+str(i+1)][y]:
  633.                     if not tile.empty and block_tile.x == tile.x and block_tile.y  == tile.y:
  634.                         return
  635.                 y += tile_length
  636.  
  637.         self.direction = temp_rotated_z.direction
  638.         self.tiles = temp_rotated_z.tiles      
  639.  
  640.     def fall_completely(self, next_block, playing_field, player):
  641.         from tetris import update_graphics
  642.  
  643.         fall= True
  644.         while fall:
  645.             for block_tile in self.tiles:
  646.                 if block_tile.y >= playing_field_height+off_set_y-tile_length:
  647.                     fall = False  
  648.                     break 
  649.  
  650.             #check already existed tiles
  651.             for block_tile in self.tiles:
  652.                 y = off_set_y
  653.                 for i in range(20):
  654.                     for tile in playing_field.tiles["row"+str(i+1)][y]:
  655.                         if not tile.empty and block_tile.y+tile_length == tile.y and block_tile.x == tile.x: 
  656.                             fall = False   
  657.                             break
  658.                     y += tile_length
  659.             
  660.             if not fall:
  661.                 break
  662.             
  663.             for tile in self.tiles:
  664.                 tile.y += tile_length
  665.             
  666.             update_graphics(self, next_block, playing_field, player)
  667.             clock.get_rawtime()
  668.             clock.tick(50)
  669.             
  670.  
  671. class Player:
  672.     def __init__(self, start_time):
  673.         self.start_time = start_time
  674.  
  675.         self.time_since_start = 0
  676.         self.score = 0

tetris.py文件：

  1. #import libraries
  2. import pygame
  3. from util import *
  4.  
  5. def update_graphics(block, next_block, playing_field, player):
  6.     
  7.     #Sets black background and text
  8.     DISPLAY_SCREEN.blit(background_img, (0, 0))
  9.     pygame.draw.rect(DISPLAY_SCREEN , black, (off_set_x, off_set_y, playing_field_width, playing_field_height) )
  10.     font = pygame.font.SysFont("comicsansms", 48)
  11.     rendered_text = font.render("Tetris", 1, orange)
  12.     DISPLAY_SCREEN.blit(rendered_text, (width/2-80, 10))
  13.  
  14.     #Displays Current score and time
  15.     player.time_since_start = pygame.time.get_ticks() - player.start_time
  16.     font = pygame.font.SysFont("comicsansms", 20)
  17.     rendered_text_time =  font.render("Time: " + str(player.time_since_start), 1, orange)
  18.     DISPLAY_SCREEN.blit(rendered_text_time, (playing_field_width+tile_length*2, playing_field_height-80))  
  19.     rendered_text_score = font.render("Score: " + str(player.score), 1, orange)
  20.     DISPLAY_SCREEN.blit(rendered_text_score, (playing_field_width+tile_length*2, playing_field_height-50))
  21.     
  22.     #Draw the small screen for the next block
  23.     draw_small_screen(next_block)
  24.  
  25.     #Set tiles
  26.     y = off_set_y
  27.     for i in range(20):
  28.         for tile in playing_field.tiles["row"+str(i+1)][y]:
  29.             tile.draw_tile()
  30.         y += tile_length
  31.  
  32.     #Blocks while falling
  33.     for tile in block.tiles:
  34.         if tile.y >= off_set_y:
  35.             tile.draw_tile()
  36.  
  37.     #Sets borders
  38.     pygame.draw.line(DISPLAY_SCREEN , blue, (off_set_x-2, off_set_y-3), (playing_field_width+off_set_x+1, off_set_y-3), 4) # horizontal line top
  39.     pygame.draw.line(DISPLAY_SCREEN , blue, (off_set_x-2, off_set_y+playing_field_height+1), (playing_field_width+off_set_x+1, off_set_y+playing_field_height+1), 4) # horizontal line bottom
  40.     pygame.draw.line(DISPLAY_SCREEN , blue, (off_set_x-3, off_set_y-3), (off_set_x-3, off_set_y+playing_field_height+1), 4) # vertical line left
  41.     pygame.draw.line(DISPLAY_SCREEN , blue, (playing_field_width+off_set_x+1, off_set_y-3), (playing_field_width+off_set_x+1, off_set_y+playing_field_height+1), 4) # vertical line right
  42.  
  43.     #Sets Grid
  44.     current_y_horizontal_lines = off_set_y
  45.     current_x_vertical_lines = off_set_x
  46.     for i in range(19): 
  47.         current_y_horizontal_lines += 33
  48.         pygame.draw.line(DISPLAY_SCREEN , white, (off_set_x, current_y_horizontal_lines), (playing_field_width+off_set_x-1, current_y_horizontal_lines)) # horizontal line top
  49.     for j in range(9): 
  50.         current_x_vertical_lines += 33        
  51.         pygame.draw.line(DISPLAY_SCREEN , white, (current_x_vertical_lines-1, off_set_y), (current_x_vertical_lines-1, playing_field_height+off_set_y)) # horizontal line top
  52.  
  53.     pygame.display.update()
  54.  
  55. def draw_small_screen(next_block):
  56.     
  57.     #Sets background
  58.     pygame.draw.rect(DISPLAY_SCREEN , black, (playing_field_width+tile_length*2, height/2-20, 6*tile_length, 6*tile_length) )
  59.     
  60.     #Sets borders
  61.     pygame.draw.line(DISPLAY_SCREEN , blue, (playing_field_width+tile_length*2-2, height/2-20-2), ((6*tile_length)+(playing_field_width+tile_length*2), (height/2-20-2)), 3) # horizontal line top
  62.     pygame.draw.line(DISPLAY_SCREEN , blue, (playing_field_width+tile_length*2-2, height/2-20+(6*tile_length)), ((6*tile_length)+(playing_field_width+tile_length*2), height/2-20+(6*tile_length)), 3) # horizontal line bottom
  63.     pygame.draw.line(DISPLAY_SCREEN , blue, (playing_field_width+tile_length*2-2, height/2-20-2), (playing_field_width+tile_length*2-2, height/2-20+(6*tile_length)), 3) # vertical line left
  64.     pygame.draw.line(DISPLAY_SCREEN , blue, ((6*tile_length)+(playing_field_width+tile_length*2), height/2-20-2), ((6*tile_length)+(playing_field_width+tile_length*2), height/2-20+(6*tile_length)), 3) # vertical line right
  65.     
  66.     #Sets text
  67.     font = pygame.font.SysFont("comicsansms", 30)
  68.     rendered_text = font.render("Next Block", 1, orange)
  69.     DISPLAY_SCREEN.blit(rendered_text, (playing_field_width+tile_length*2,  height/2-70))
  70.     
  71.     #Displays next block
  72.     temp_block = Block(next_block.shape, next_block.color)  
  73.     temp_block.tiles = [Tile(playing_field_width+tile_length*2+2*tile_length, height/2-20+4*tile_length, next_block.color), Tile(0, 0, next_block.color), Tile(0, 0, next_block.color), Tile(0, 0, next_block.color)]
  74.     temp_block.complete_block()
  75.  
  76.     for tile in temp_block.tiles:
  77.         tile.draw_tile()
  78.  
  79. def is_game_over(playing_field, player): 
  80.     y = off_set_y
  81.     for i in range(20):
  82.         for tile in playing_field.tiles["row"+str(i+1)][y]:
  83.             if not tile.empty and tile.y <= off_set_y: 
  84.                 temp_y = off_set_y
  85.                 for j in range(20):
  86.                     for tile in playing_field.tiles["row"+str(j+1)][temp_y]:
  87.                         tile.draw_tile()
  88.                     temp_y += tile_length
  89.  
  90.                 font = pygame.font.SysFont("comicsansms", 48)
  91.                 rendered_text = font.render("GAME OVER", 1, white)
  92.                 DISPLAY_SCREEN.blit(rendered_text, (off_set_x+20, playing_field_height/2))
  93.                 pygame.display.update()
  94.  
  95.                 time.sleep(2)   
  96.                 introduction(player)
  97.         y += tile_length
  98.  
  99. def start_game():    
  100.     global best_score
  101.     global longest_time
  102.  
  103.     rand_index = random.randint(0, 6)
  104.     block = Block(shapes[rand_index], block_colors[rand_index])
  105.  
  106.     next_rand_index = random.randint(0, 6)
  107.     next_block = Block(shapes[next_rand_index], block_colors[next_rand_index]) 
  108.  
  109.     playing_field = PlayingField()
  110.     start_time = pygame.time.get_ticks()
  111.     player = Player(start_time)
  112.  
  113.     while True:
  114.         update_graphics(block, next_block, playing_field, player)
  115.  
  116.         (block, next_block, is_new) = block.get_new_block(next_block, playing_field, player)
  117.         if is_new:
  118.             for event in pygame.event.get():
  119.                 if event.type == pygame.QUIT:
  120.                     pygame.quit()
  121.                     sys.exit()
  122.             pygame.event.clear()
  123.  
  124.         manage_events(block, next_block, playing_field, player)
  125.         update_graphics(block, next_block, playing_field, player)
  126.  
  127.         block.block_is_falling(next_block, playing_field, player)
  128.         update_graphics(block, next_block, playing_field, player)
  129.         
  130.         playing_field.destory_full_row(player)
  131.         update_graphics(block, next_block, playing_field, player)
  132.  
  133.         if player.score > best_score:
  134.             best_score = player.score
  135.         if player.time_since_start > longest_time:
  136.             longest_time = player.time_since_start
  137.  
  138.         is_game_over(playing_field, player)
  139.         update_graphics(block, next_block, playing_field, player)
  140.  
  141.         pygame.display.update()
  142.         clock.tick(60)
  143.  
  144.  
  145. def manage_events(block, next_block, playing_field, player):
  146.     for event in pygame.event.get():
  147.         if event.type == pygame.QUIT:
  148.             pygame.quit()
  149.             sys.exit()
  150.         
  151.         if event.type == pygame.KEYDOWN:
  152.             if event.key == pygame.K_LEFT:
  153.                 #move the block to the left
  154.                 block.move_left(playing_field)
  155.             elif event.key == pygame.K_RIGHT:
  156.                 #move the block to the right
  157.                 block.move_right(playing_field)
  158.             elif event.key == pygame.K_UP:
  159.                 # rotate block
  160.                 block.rotate(next_block, playing_field, player)
  161.             if event.key == pygame.K_SPACE:
  162.                 # let the block fall completely
  163.                 block.fall_completely(next_block, playing_field, player)
  164.             if event.key == pygame.K_DOWN:
  165.                 # let the block fall down faster
  166.                 block.block_is_falling(next_block, playing_field, player, "faster")
  167.  
  168.     update_graphics(block, next_block, playing_field, player)
  169.  
  170.  
  171. def introduction(player = None):
  172.     button_width = 300
  173.     button_height = 90
  174.     
  175.     #start_x_button = width/2-button_width/2
  176.     play_button = Button(blue, orange, -400, height/2, button_width, button_height, 32, black, white, "PLAY")
  177.     instructions_button = Button(blue, orange, width+150, height/2+button_height+10, button_width,button_height, 32, black, white, "INSTRUCTIONS")
  178.     quit_button = Button(blue, orange, -400, height/2+button_height*2+20, button_width,button_height, 32, black, white, "QUIT")
  179.     
  180.     font = pygame.font.SysFont("comicsansms", 48)
  181.     rendered_text = font.render("Tetris", 1, black)
  182.     rendered_text_y = height
  183.  
  184.     #To draw the Tetris text in an animated way
  185.     while rendered_text_y > 10: 
  186.         DISPLAY_SCREEN.blit(background_img, (0, 0))
  187.  
  188.         for event in pygame.event.get():
  189.             if event.type == pygame.QUIT:
  190.                 pygame.quit()
  191.                 sys.exit()
  192.  
  193.         rendered_text_y -= 1.5
  194.         DISPLAY_SCREEN.blit(rendered_text, (width/2-80, rendered_text_y))
  195.         pygame.display.update()
  196.  
  197.     #To draw the score and time texts in an animated way
  198.     if player:
  199.         font_small = pygame.font.SysFont("comicsansms", 30)
  200.         rendered_current_score = font_small.render("Current Score: " + str(player.score), 1, orange)
  201.         rendered_best_score = font_small.render("Best Score: " + str(best_score), 1, orange)
  202.         rendered_current_time = font_small.render("Current Time: " + str(player.time_since_start), 1, orange)
  203.         rendered_longest_time = font_small.render("Longest Time: " + str(longest_time), 1, orange)
  204.  
  205.         rendered_current_score_y = height
  206.         rendered_best_score_y = height+40
  207.         rendered_current_time_y = height+80
  208.         rendered_longest_time_y = height+120
  209.  
  210.         while rendered_current_score_y > 150: 
  211.             DISPLAY_SCREEN.blit(background_img, (0, 0))
  212.             DISPLAY_SCREEN.blit(rendered_text, (width/2-80, rendered_text_y))
  213.  
  214.             for event in pygame.event.get():
  215.                 if event.type == pygame.QUIT:
  216.                     pygame.quit()
  217.                     sys.exit()
  218.  
  219.             rendered_current_score_y -= 1.5
  220.             rendered_best_score_y -= 1.5
  221.             rendered_current_time_y -= 1.5
  222.             rendered_longest_time_y -= 1.5
  223.  
  224.             DISPLAY_SCREEN.blit(rendered_current_score, (off_set_x, rendered_current_score_y))
  225.             DISPLAY_SCREEN.blit(rendered_best_score, (off_set_x+45, rendered_best_score_y))
  226.             DISPLAY_SCREEN.blit(rendered_current_time, (off_set_x+15, rendered_current_time_y))
  227.             DISPLAY_SCREEN.blit(rendered_longest_time, (off_set_x+15, rendered_longest_time_y))
  228.  
  229.             pygame.display.update()
  230.  
  231.     #To draw the buttons in an animated way
  232.     while play_button.x < width/2-button_width/2 or instructions_button.x > width/2-button_width/2:
  233.         DISPLAY_SCREEN.blit(background_img, (0, 0))
  234.         DISPLAY_SCREEN.blit(rendered_text, (width/2-80, rendered_text_y))
  235.         if player:
  236.             DISPLAY_SCREEN.blit(rendered_current_score, (off_set_x, rendered_current_score_y))
  237.             DISPLAY_SCREEN.blit(rendered_best_score, (off_set_x+45, rendered_best_score_y))
  238.             DISPLAY_SCREEN.blit(rendered_current_time, (off_set_x+15, rendered_current_time_y))
  239.             DISPLAY_SCREEN.blit(rendered_longest_time, (off_set_x+15, rendered_longest_time_y))
  240.  
  241.         for event in pygame.event.get():
  242.             if event.type == pygame.QUIT:
  243.                 pygame.quit()
  244.                 sys.exit()
  245.         
  246.         if play_button.x < width/2-button_width/2:
  247.             play_button.x += 3
  248.             quit_button.x += 3
  249.         if instructions_button.x > width/2-button_width/2 :    
  250.             instructions_button.x -= 3
  251.  
  252.         play_button.blit(DISPLAY_SCREEN)
  253.         instructions_button.blit(DISPLAY_SCREEN)
  254.         quit_button.blit(DISPLAY_SCREEN)
  255.         pygame.display.update()
  256.  
  257.     run = True
  258.     while run:
  259.         DISPLAY_SCREEN.blit(background_img, (0, 0))
  260.         DISPLAY_SCREEN.blit(rendered_text, (width/2-80, rendered_text_y))
  261.         if player:
  262.             DISPLAY_SCREEN.blit(rendered_current_score, (off_set_x, rendered_current_score_y))
  263.             DISPLAY_SCREEN.blit(rendered_best_score, (off_set_x+45, rendered_best_score_y))
  264.             DISPLAY_SCREEN.blit(rendered_current_time, (off_set_x+15, rendered_current_time_y))
  265.             DISPLAY_SCREEN.blit(rendered_longest_time, (off_set_x+15, rendered_longest_time_y))
  266.  
  267.         # Get the position of the mouse
  268.         mouse_position = pygame.mouse.get_pos() 
  269.         for event in pygame.event.get():
  270.             if event.type == pygame.QUIT:
  271.                 pygame.quit()
  272.                 sys.exit()
  273.             if event.type == pygame.MOUSEBUTTONDOWN:
  274.                 if play_button.is_clicked(mouse_position, event):
  275.                     start_game()
  276.                     run = False
  277.                 elif instructions_button.is_clicked(mouse_position, event):
  278.                     instructions(player)
  279.                     run = False
  280.                 elif quit_button.is_clicked(mouse_position, event):
  281.                     pygame.quit()
  282.                     sys.exit()
  283.         
  284.         if play_button.is_hovered_over(mouse_position):
  285.             play_button.blit_hovered_over(DISPLAY_SCREEN)
  286.         else:
  287.             play_button.blit(DISPLAY_SCREEN, gray)
  288.         if instructions_button.is_hovered_over(mouse_position):
  289.             instructions_button.blit_hovered_over(DISPLAY_SCREEN)
  290.         else:
  291.             instructions_button.blit(DISPLAY_SCREEN, gray)
  292.         if quit_button.is_hovered_over(mouse_position):
  293.             quit_button.blit_hovered_over(DISPLAY_SCREEN)
  294.         else:
  295.             quit_button.blit(DISPLAY_SCREEN, gray)
  296.  
  297.         clock.tick(60)
  298.         pygame.display.update()
  299.  
  300.  
  301. def instructions(player = None):
  302.     button_width = 150
  303.     button_height = 60
  304.  
  305.     play_button = Button(blue, orange, width-150-10, height-80, button_width, button_height, 32, black, white, "PLAY >>")
  306.     back_button = Button(blue, orange, 10, height-80, button_width, button_height, 32, black, white, "<< BACK")
  307.  
  308.     run = True
  309.     while run:
  310.         DISPLAY_SCREEN.blit(instructions_img, (0, 0))
  311.         font = pygame.font.SysFont("comicsansms", 48)
  312.         rendered_text = font.render("Tetris", 1, orange)
  313.         DISPLAY_SCREEN.blit(rendered_text, (width/2-80, 10))
  314.  
  315.         # Get the position of the mouse
  316.         mouse_position = pygame.mouse.get_pos() 
  317.         for event in pygame.event.get():
  318.             if event.type == pygame.QUIT:
  319.                 pygame.quit()
  320.                 sys.exit()
  321.             if event.type == pygame.MOUSEBUTTONDOWN:
  322.                 if play_button.is_clicked(mouse_position, event):
  323.                     start_game()
  324.                     run = False
  325.                 elif back_button.is_clicked(mouse_position, event):
  326.                     introduction(player)
  327.                     run = False
  328.  
  329.         instructions_label = "Instructions" 
  330.         font = pygame.font.SysFont("comicsansms", 40)
  331.         rendered_text = font.render(instructions_label, 1, orange)
  332.         DISPLAY_SCREEN.blit(rendered_text, (width/2 - rendered_text.get_width()/2, 100))
  333.     
  334.          
  335.         instructions1 = "   Move Right:                      right arrow >"  
  336.         instructions2 = "   Move   Left:                     left    arrow <" 
  337.         instructions3 = "          Rotate:                      up      arrow ^" 
  338.         instructions4 = "   Soft  Drop:                      down   arrow" 
  339.         instructions5 = "   Hard  Drop:                      space"
  340.  
  341.         font = pygame.font.SysFont("comicsansms", 20)
  342.         rendered_text1 = font.render(instructions1, 1, orange)
  343.         rendered_text2 = font.render(instructions2, 1, orange)
  344.         rendered_text3 = font.render(instructions3, 1, orange)
  345.         rendered_text4 = font.render(instructions4, 1, orange)
  346.         rendered_text5 = font.render(instructions5, 1, orange)
  347.  
  348.         DISPLAY_SCREEN.blit(rendered_text1, (20, 200))
  349.         DISPLAY_SCREEN.blit(rendered_text2, (20, 240))
  350.         DISPLAY_SCREEN.blit(rendered_text3, (20, 280))
  351.         DISPLAY_SCREEN.blit(rendered_text4, (20, 320))
  352.         DISPLAY_SCREEN.blit(rendered_text5, (20, 360))
  353.  
  354.         if play_button.is_hovered_over(mouse_position):
  355.             play_button.blit_hovered_over(DISPLAY_SCREEN)
  356.         else:
  357.             play_button.blit(DISPLAY_SCREEN, gray)
  358.         if back_button.is_hovered_over(mouse_position):
  359.             back_button.blit_hovered_over(DISPLAY_SCREEN)
  360.         else:
  361.             back_button.blit(DISPLAY_SCREEN, gray)
  362.         
  363.         clock.tick(60)
  364.         pygame.display.update()
  365.  
  366. if __name__ == "__main__":
  367.     introduction()
  368.

Python俄罗斯方块Tetris源文件本站下载：
https://download.csdn.net/download/mufenglaoshi/88612722

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/IT小白/article/detail/832526
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号