在本文中，我们将用Python代码构建一个令人惊叹的项目：俄罗斯方块游戏。在这个项目中，我们将使用pygame库来构建游戏。要创建此项目，请确保您的系统中安装了最新版本的Python。让我们开始吧！
Pygame是一组跨平台的Python模块，用于创建视频游戏。它由设计用于Python编程语言的计算机图形和声音库组成。Pygame适合创建客户端应用程序，这些应用程序可能被封装在独立的可执行文件中。要学习pygame，需要具备Python的基本知识。
要安装pygame，请在终端中执行以下代码：
python
pip install pygame我们已经完成了项目的先决条件。让我们来看看这个项目中的一些重要功能。
这种update_graphics方法用于设计游戏界面，并在游戏执行过程中进行必要的更新。该函数设置背景颜色和要显示的文本，并设置边框和宽度。它显示当前分数和时间。它绘制一个小屏幕来显示下一个块。为块设置瓷砖，每行20个瓷砖/平方，即19条水平线，每列10个瓷砖/广场，即9条垂直线。
draw_small_screen方法用于设计在游戏执行期间显示下一个块的相同屏幕界面。它设置背景、边框和文本，并显示下一个块。
manage_events函数用于在游戏执行期间处理块。
Python中俄罗斯方块游戏的完整代码：
我们可以在Pygame的帮助下用Python构建俄罗斯方块游戏，因为它有很多功能。现在，让我们从实现部分开始。在注释的帮助下，您可以逐行理解代码。
现在创建两个python文件，并将它们保存为util.py和tetris.py：
util.py文件：
python
#Import libraries
import pygame
import sys
import random
import time
# Define important global variables
pygame.init()
clock = pygame.time.Clock()
best_score = 0
longest_time = 0
width = 700
height = 750
DISPLAY_SCREEN = pygame.display.set_mode((width, height))
pygame.display.set_caption(" Tetris")
off_set_x = 10
off_set_y = 80
playing_field_width = 330 #330 / 10 = 33 width per tile
playing_field_height = 660 #600 / 20 = 33 height per tile
tile_length = 33 # tile is a square
#colors
blue = (0, 0, 255)
white = (255, 255, 255)
black = (0, 0, 0)
gray = (95, 95, 96)
orange = (249, 87, 0)
cobalt_blue = (3, 65, 174)
green_apple = (114, 203, 59)
cyber_yellow= (255, 213, 0)
beer = (255, 151, 28)
ryb_red = (255, 50, 19)
purple = (128, 0, 128)
# colors of Tetris blocks
block_colors = (cobalt_blue, blue, green_apple, purple, cyber_yellow, beer, ryb_red)
# shapes of Tetris blocks
shapes = ("i_block", "l_block", "j_block", "o_block", "s_block", "t_block", "z_block")
directions = ("vertical_1", "vertical_2", "horizontal_1", "horizontal_2")
background_img = pygame.image.load("resources/images/background_img.jpg")
instructions_img = pygame.image.load("resources/images/instructions_img.jpg")
icon_img = pygame.image.load("resources/images/icon.png")
pygame.display.set_icon(icon_img)
class Button:
def __init__(self, button_color, button_hover_over_color, x, y, width, height, text_size, text_color, text_hover_over_color = None, text_str=""):
self.button_color = button_color
self.button_hover_over_color = button_hover_over_color
self.x = x
self.y = y
self.width = width
self.height = height
self.text_size = text_size
self.text_color = text_color
if text_hover_over_color:
self.text_hover_over_color = text_hover_over_color
else:
self.text_hover_over_color = text_color
self.text_str = text_str
def blit(self, display_screen, outline_color=None):
if outline_color:
pygame.draw.rect(display_screen, outline_color, (self.x-3, self.y-3, self.width+6, self.height+6))
pygame.draw.rect(display_screen, self.button_color, (self.x, self.y, self.width, self.height))
if self.text_str != "":
font = pygame.font.Font("freesansbold.ttf", self.text_size)
text = font.render(self.text_str, True, self.text_color)
# to center the text in the middle of the button based on the size of the button
text_position = (self.x + (self.width/2 - text.get_width()/2), self.y + (self.height/2 - text.get_height()/2))
display_screen.blit(text, text_position)
def is_hovered_over(self, mouse_position):
if self.x < mouse_position[0] < self.x+self.width and self.y < mouse_position[1] < self.y+self.height:
return True
return False
def blit_hovered_over(self, display_screen):
pygame.draw.rect(display_screen, self.button_hover_over_color, (self.x, self.y, self.width, self.height))
if self.text_str != "":
font = pygame.font.Font("freesansbold.ttf", self.text_size)
text = font.render(self.text_str, True, self.text_hover_over_color)
# to center the text in the middle of the button based on the size of the button
text_position = (self.x + (self.width/2 - text.get_width()/2), self.y + (self.height/2 - text.get_height()/2))
display_screen.blit(text, text_position)
def is_clicked(self, mouse_position, event):
if self.is_hovered_over(mouse_position):
if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
return True
return False
class Tile:
def __init__(self, x, y, color = black):
self.x = x
self.y = y
self.color = color
self.empty = True
def draw_tile(self):
pygame.draw.rect(DISPLAY_SCREEN , self.color, (self.x, self.y, tile_length, tile_length) )
class PlayingField():
def __init__(self):
#y coordinate of first row = (80) off_set_y
self.tiles = {
"row1": {80: []},
"row2": {113: []},
"row3": {146: []},
"row4": {179: []},
"row5": {212: []},
"row6": {245: []},
"row7": {278: []},
"row8": {311: []},
"row9": {344: []},
"row10": {377: []},
"row11": {410: []},
"row12": {443: []},
"row13": {476: []},
"row14": {509: []},
"row15": {542: []},
"row16": {575: []},
"row17": {608: []},
"row18": {641: []},
"row19": {674: []},
"row20": {707: []},
}
self.__init_field()
def __init_field(self):
y = off_set_y
for i in range(20): #rows
x = off_set_x
for j in range(10): #cols
tile_to_add = Tile(x, y)
self.tiles["row"+str(i+1)][y].append(tile_to_add)
x += tile_length
y += tile_length
def destory_full_row(self, player):
times = 0
y = off_set_y
for i in range(20):
for tile in self.tiles["row"+str(i+1)][y]:
if tile.empty: break
elif tile.x == off_set_x+playing_field_width-tile_length:
times += 1
for j in range(800): #just for flashing the row
if j%2 == 0:
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) )
else:
for tile in self.tiles["row"+str(i+1)][y]:
pygame.draw.rect(DISPLAY_SCREEN , tile.color, (tile.x, tile.y, tile_length, tile_length) )
pygame.draw.line(DISPLAY_SCREEN , white, (off_set_x, y), (playing_field_width+off_set_x-1, y)) # horizontal line
pygame.display.update()
# let's destory this full row
self.destroy_and_replace(i+1, y)
player.score += 10*times
y += tile_length
def destroy_and_replace(self, row_number, row_y):
for i in range (row_number, 1, -1):
prev_row_number = i-1
prev_y = row_y-tile_length
self.tiles["row"+str(i)][row_y].clear() #current_row.clear()
temp_x = off_set_x
for j in range(10):
empty_tile = Tile(temp_x, row_y)
temp_x += tile_length
self.tiles["row"+str(i)][row_y].append(empty_tile)
if prev_y < 80:
break
for j in range(10):
old_tile = self.tiles["row"+str(i)][row_y][j]
new_tile = self.tiles["row"+str(prev_row_number)][prev_y][j]
old_tile.x = new_tile.x
old_tile.color = new_tile.color
old_tile.empty = new_tile.empty
row_y -= tile_length
class Block:
def __init__(self, shape:str, color = black):
self.shape = shape
self.color = color
self.direction = directions[0] #vertical_1
# tile1 , tile2 , tile3 , tile4
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)]
self.__init_shape()
for tile in self.tiles:
tile.empty = False
def __init_shape(self):
if self.shape == "i_block":
self.tiles[1] = Tile(self.tiles[0].x, self.tiles[0].y-tile_length, self.color)
self.tiles[2] = Tile(self.tiles[0].x, self.tiles[1].y-tile_length, self.color)
self.tiles[3] = Tile(self.tiles[0].x, self.tiles[2].y-tile_length, self.color)
elif self.shape == "l_block":
self.tiles[1] = Tile(self.tiles[0].x+tile_length, self.tiles[0].y, self.color)
self.tiles[2] = Tile(self.tiles[0].x-tile_length, self.tiles[0].y, self.color)
self.tiles[3] = Tile(self.tiles[2].x, self.tiles[2].y-tile_length, self.color)
elif self.shape == "j_block":
self.tiles[1] = Tile(self.tiles[0].x+tile_length, self.tiles[0].y, self.color)
self.tiles[2] = Tile(self.tiles[0].x-tile_length, self.tiles[0].y, self.color)
self.tiles[3] = Tile(self.tiles[1].x, self.tiles[1].y-tile_length, self.color)
elif self.shape == "o_block":
self.tiles[1] = Tile(self.tiles[0].x+tile_length, self.tiles[0].y, self.color)
self.tiles[2] = Tile(self.tiles[0].x, self.tiles[0].y-tile_length, self.color)
self.tiles[3] = Tile(self.tiles[1].x, self.tiles[1].y-tile_length, self.color)
elif self.shape == "s_block":
self.tiles[1] = Tile(self.tiles[0].x-tile_length, self.tiles[0].y, self.color)
self.tiles[2] = Tile(self.tiles[0].x, self.tiles[0].y-tile_length, self.color)
self.tiles[3] = Tile(self.tiles[2].x+tile_length, self.tiles[2].y, self.color)
elif self.shape == "t_block":
self.tiles[1] = Tile(self.tiles[0].x+tile_length, self.tiles[0].y, self.color)
self.tiles[2] = Tile(self.tiles[0].x-tile_length, self.tiles[0].y, self.color)
self.tiles[3] = Tile(self.tiles[0].x, self.tiles[0].y-tile_length, self.color)
elif self.shape == "z_block":
self.tiles[1] = Tile(self.tiles[0].x+tile_length, self.tiles[0].y, self.color)
self.tiles[2] = Tile(self.tiles[0].x, self.tiles[0].y-tile_length, self.color)
self.tiles[3] = Tile(self.tiles[2].x-tile_length, self.tiles[2].y, self.color)
else:
print("Error: wrong block name.")
pygame.quit()
sys.exit()
def complete_block(self):
self.__init_shape()
def can_fall(self, next_block, playing_field, player):
from tetris import manage_events, update_graphics
manage_events(self, next_block, playing_field, player)
#check borders
for block_tile in self.tiles:
if block_tile.y >= playing_field_height+off_set_y-tile_length:
return False
#check already existed tiles
for block_tile in self.tiles:
y = off_set_y
for i in range(20):
for tile in playing_field.tiles["row"+str(i+1)][y]:
if not tile.empty and block_tile.y+tile_length == tile.y and block_tile.x == tile.x:
return False
y += tile_length
return True
def block_is_falling(self, next_block, playing_field, player, faster=None):
from tetris import manage_events, update_graphics
manage_events(self,next_block, playing_field, player)
if self.can_fall(next_block, playing_field, player):
for tile in self.tiles:
tile.y += tile_length
manage_events(self, next_block, playing_field, player)
update_graphics(self, next_block, playing_field, player)
if faster:
clock.tick(40)
self.block_is_falling( next_block, playing_field, player)
else:
clock.tick(5)
manage_events(self, next_block, playing_field, player)
update_graphics(self, next_block, playing_field, player)
def get_new_block(self, next_block, playing_field, player):
if self.can_fall(next_block, playing_field, player): return (self, next_block, False)
#if the block has falled completely
for block_tile in self.tiles:
found = False
y = off_set_y
for i in range(20):
if not found:
for j in range(10):
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:
playing_field.tiles["row"+str(i+1)][y][j].color = block_tile.color
playing_field.tiles["row"+str(i+1)][y][j].empty = False
found = True
break
y += tile_length
else:
break
new_block = next_block
next_rand_index1 = random.randint(0, 6)
next_rand_index2 = random.randint(0, 6)
new_next_block = Block(shapes[next_rand_index1], block_colors[next_rand_index2])
clock.tick(2)
return (new_block, new_next_block, True)
def move_left(self, playing_field):
if self.can_move_left(playing_field):
for tile in self.tiles:
tile.x -= tile_length
def move_right(self, playing_field):
if self.can_move_right(playing_field):
for tile in self.tiles:
tile.x += tile_length
def can_move_left(self, playing_field):
# whether inside the playing field or not
for tile in self.tiles:
if tile.x <= off_set_x:
return False
# whether adjacent field_tiles are occupied or not
for block_tile in self.tiles:
y = off_set_y
for i in range(20):
for tile in playing_field.tiles["row"+str(i+1)][y]:
if not tile.empty and block_tile.x-tile_length == tile.x and block_tile.y == tile.y:
return False
y += tile_length
return True
def can_move_right(self, playing_field):
# whether inside the playing field or not
for tile in self.tiles:
if tile.x + tile_length >= off_set_x+playing_field_width:
return False
# whether adjacent field_tiles are occupied or not
for block_tile in self.tiles:
y = off_set_y
for i in range(20):
for tile in playing_field.tiles["row"+str(i+1)][y]:
if not tile.empty and block_tile.x+tile_length == tile.x and block_tile.y == tile.y:
return False
y += tile_length
return True
def rotate(self, next_block, playing_field, player):
from tetris import manage_events, update_graphics
manage_events(self, next_block, playing_field, player)
if self.shape == "i_block":
self.rotate_i_block(playing_field)
elif self.shape == "l_block":
self.rotate_l_block(playing_field)
elif self.shape == "j_block":
self.rotate_j_block(playing_field)
elif self.shape == "o_block":
return
#no rotation for o_block.
elif self.shape == "s_block":
self.rotate_s_block(playing_field)
elif self.shape == "t_block":
self.rotate_t_block(playing_field)
elif self.shape == "z_block":
self.rotate_z_block(playing_field)
else:
print("Error: wrong block name.")
pygame.quit()
sys.exit()
manage_events(self, next_block, playing_field, player)
update_graphics(self, next_block, playing_field, player)
def rotate_i_block(self, playing_field): #done
temp_rotated_i = Block("i_block", self.color)
temp_rotated_i.tiles = self.tiles.copy()
if self.direction == directions[0] or self.direction == directions[1]:
# ----
temp_rotated_i.tiles[0] = Tile(temp_rotated_i.tiles[1].x, temp_rotated_i.tiles[0].y, temp_rotated_i.color)
temp_rotated_i.tiles[1] = Tile(temp_rotated_i.tiles[0].x-tile_length, temp_rotated_i.tiles[0].y, temp_rotated_i.color)
temp_rotated_i.tiles[2] = Tile(temp_rotated_i.tiles[0].x+tile_length, temp_rotated_i.tiles[0].y, temp_rotated_i.color)
temp_rotated_i.tiles[3] = Tile(temp_rotated_i.tiles[2].x+tile_length, temp_rotated_i.tiles[0].y, temp_rotated_i.color)
temp_rotated_i.direction = directions[2] # "horizontal_1"
elif self.direction == directions[2] or self.direction == directions[3]:
# |
# |
# |
# |
temp_rotated_i.tiles[1] = Tile(temp_rotated_i.tiles[0].x, temp_rotated_i.tiles[0].y-tile_length, temp_rotated_i.color)
temp_rotated_i.tiles[2] = Tile(temp_rotated_i.tiles[1].x, temp_rotated_i.tiles[1].y-tile_length, temp_rotated_i.color)
temp_rotated_i.tiles[3] = Tile(temp_rotated_i.tiles[2].x, temp_rotated_i.tiles[2].y-tile_length, temp_rotated_i.color)
temp_rotated_i.direction = directions[0] #"vertical_1"
for block_tile in temp_rotated_i.tiles:
if block_tile.x <= off_set_x or block_tile.x >= playing_field_width:
return
y = off_set_y
for i in range(20):
for tile in playing_field.tiles["row"+str(i+1)][y]:
if not tile.empty and block_tile.x == tile.x and block_tile.y == tile.y:
return
y += tile_length
self.direction = temp_rotated_i.direction
self.tiles = temp_rotated_i.tiles
def rotate_l_block(self, playing_field): #done
temp_rotated_l = Block("l_block", self.color)
temp_rotated_l.tiles = self.tiles.copy()
if self.direction == directions[0]:
# after rotating, the block should look like this ↓
# _
# |
# |
# |
temp_rotated_l.tiles[0] = Tile(temp_rotated_l.tiles[0].x, temp_rotated_l.tiles[0].y, temp_rotated_l.color)
temp_rotated_l.tiles[1] = Tile(temp_rotated_l.tiles[0].x, temp_rotated_l.tiles[0].y-tile_length, temp_rotated_l.color)
temp_rotated_l.tiles[2] = Tile(temp_rotated_l.tiles[1].x, temp_rotated_l.tiles[1].y-tile_length, temp_rotated_l.color)
temp_rotated_l.tiles[3] = Tile(temp_rotated_l.tiles[2].x+tile_length, temp_rotated_l.tiles[2].y, temp_rotated_l.color)
temp_rotated_l.direction = directions[2] # "horizontal_1"
elif self.direction == directions[2]:
# after rotating, the block should look like this ↓
# ---
# |
temp_rotated_l.tiles[0] = Tile(temp_rotated_l.tiles[3].x, temp_rotated_l.tiles[0].y, temp_rotated_l.color)
temp_rotated_l.tiles[1] = Tile(temp_rotated_l.tiles[0].x, temp_rotated_l.tiles[0].y-tile_length, temp_rotated_l.color)
temp_rotated_l.tiles[2] = Tile(temp_rotated_l.tiles[1].x-tile_length, temp_rotated_l.tiles[1].y, temp_rotated_l.color)
temp_rotated_l.tiles[3] = Tile(temp_rotated_l.tiles[2].x-tile_length, temp_rotated_l.tiles[2].y, temp_rotated_l.color)
temp_rotated_l.direction = directions[1] #"vertical_2"
elif self.direction == directions[1]:
# after rotating, the block should look like this ↓
# |
# |
# _|
temp_rotated_l.tiles[0] = Tile(temp_rotated_l.tiles[3].x, temp_rotated_l.tiles[0].y, temp_rotated_l.color)
temp_rotated_l.tiles[1] = Tile(temp_rotated_l.tiles[0].x+tile_length, temp_rotated_l.tiles[0].y, temp_rotated_l.color)
temp_rotated_l.tiles[2] = Tile(temp_rotated_l.tiles[1].x, temp_rotated_l.tiles[1].y-tile_length, temp_rotated_l.color)
temp_rotated_l.tiles[3] = Tile(temp_rotated_l.tiles[2].x, temp_rotated_l.tiles[2].y-tile_length, temp_rotated_l.color)
temp_rotated_l.direction = directions[3] #"horizontal_2"
elif self.direction == directions[3]:
# after rotating, the block should look like this ↓
# |
# ---
temp_rotated_l.tiles[0] = Tile(temp_rotated_l.tiles[1].x, temp_rotated_l.tiles[0].y, temp_rotated_l.color)
temp_rotated_l.tiles[1] = Tile(temp_rotated_l.tiles[0].x+tile_length, temp_rotated_l.tiles[0].y, temp_rotated_l.color)
temp_rotated_l.tiles[2] = Tile(temp_rotated_l.tiles[0].x-tile_length, temp_rotated_l.tiles[1].y, temp_rotated_l.color)
temp_rotated_l.tiles[3] = Tile(temp_rotated_l.tiles[2].x, temp_rotated_l.tiles[2].y-tile_length, temp_rotated_l.color)
temp_rotated_l.direction = directions[0] #"vertical_1"
for block_tile in temp_rotated_l.tiles:
if block_tile.x <= off_set_x or block_tile.x >= playing_field_width:
return
y = off_set_y
for i in range(20):
for tile in playing_field.tiles["row"+str(i+1)][y]:
if not tile.empty and block_tile.x == tile.x and block_tile.y == tile.y:
return
y += tile_length
self.direction = temp_rotated_l.direction
self.tiles = temp_rotated_l.tiles
def rotate_j_block(self, playing_field): #done
temp_rotated_j = Block("j_block", self.color)
temp_rotated_j.tiles = self.tiles.copy()
if self.direction == directions[0]:
temp_rotated_j.tiles[0] = Tile(temp_rotated_j.tiles[1].x, temp_rotated_j.tiles[0].y, temp_rotated_j.color)
temp_rotated_j.tiles[1] = Tile(temp_rotated_j.tiles[0].x-tile_length, temp_rotated_j.tiles[0].y, temp_rotated_j.color)
temp_rotated_j.tiles[2] = Tile(temp_rotated_j.tiles[1].x, temp_rotated_j.tiles[1].y-tile_length, temp_rotated_j.color)
temp_rotated_j.tiles[3] = Tile(temp_rotated_j.tiles[2].x, temp_rotated_j.tiles[2].y-tile_length, temp_rotated_j.color)
temp_rotated_j.direction = directions[2] # "horizontal_1"
elif self.direction == directions[2]:
temp_rotated_j.tiles[0] = Tile(temp_rotated_j.tiles[1].x-tile_length, temp_rotated_j.tiles[0].y, temp_rotated_j.color)
temp_rotated_j.tiles[1] = Tile(temp_rotated_j.tiles[0].x, temp_rotated_j.tiles[0].y-tile_length, temp_rotated_j.color)
temp_rotated_j.tiles[2] = Tile(temp_rotated_j.tiles[1].x+tile_length, temp_rotated_j.tiles[1].y, temp_rotated_j.color)
temp_rotated_j.tiles[3] = Tile(temp_rotated_j.tiles[2].x+tile_length, temp_rotated_j.tiles[2].y, temp_rotated_j.color)
temp_rotated_j.direction = directions[1] #"vertical_2"
elif self.direction == directions[1]:
temp_rotated_j.tiles[0] = Tile(temp_rotated_j.tiles[2].x, temp_rotated_j.tiles[0].y, temp_rotated_j.color)
temp_rotated_j.tiles[1] = Tile(temp_rotated_j.tiles[0].x, temp_rotated_j.tiles[0].y-tile_length, temp_rotated_j.color)
temp_rotated_j.tiles[2] = Tile(temp_rotated_j.tiles[1].x, temp_rotated_j.tiles[1].y-tile_length, temp_rotated_j.color)
temp_rotated_j.tiles[3] = Tile(temp_rotated_j.tiles[2].x-tile_length, temp_rotated_j.tiles[2].y, temp_rotated_j.color)
temp_rotated_j.direction = directions[3] #"horizontal_2"
elif self.direction == directions[3]: #back to normal:
temp_rotated_j.tiles[0] = Tile(temp_rotated_j.tiles[0].x, temp_rotated_j.tiles[0].y, temp_rotated_j.color)
temp_rotated_j.tiles[1] = Tile(temp_rotated_j.tiles[0].x+tile_length, temp_rotated_j.tiles[0].y, temp_rotated_j.color)
temp_rotated_j.tiles[2] = Tile(temp_rotated_j.tiles[0].x-tile_length, temp_rotated_j.tiles[0].y, temp_rotated_j.color)
temp_rotated_j.tiles[3] = Tile(temp_rotated_j.tiles[1].x, temp_rotated_j.tiles[1].y-tile_length, temp_rotated_j.color)
temp_rotated_j.direction = directions[0] #"vertical_1"
for block_tile in temp_rotated_j.tiles:
if block_tile.x <= off_set_x or block_tile.x >= playing_field_width:
return
y = off_set_y
for i in range(20):
for tile in playing_field.tiles["row"+str(i+1)][y]:
if not tile.empty and block_tile.x == tile.x and block_tile.y == tile.y:
return
y += tile_length
self.direction = temp_rotated_j.direction
self.tiles = temp_rotated_j.tiles
def rotate_s_block(self, playing_field): #done
temp_rotated_s = Block("s_block", self.color)
temp_rotated_s.tiles = self.tiles.copy()
if self.direction == directions[0] or self.direction == directions[1]:
temp_rotated_s.tiles[0] = Tile(temp_rotated_s.tiles[3].x, temp_rotated_s.tiles[0].y, temp_rotated_s.color)
temp_rotated_s.tiles[1] = Tile(temp_rotated_s.tiles[0].x, temp_rotated_s.tiles[0].y-tile_length, temp_rotated_s.color)
temp_rotated_s.tiles[2] = Tile(temp_rotated_s.tiles[1].x-tile_length, temp_rotated_s.tiles[1].y, temp_rotated_s.color)
temp_rotated_s.tiles[3] = Tile(temp_rotated_s.tiles[2].x, temp_rotated_s.tiles[2].y-tile_length, temp_rotated_s.color)
temp_rotated_s.direction = directions[2] # "horizontal_1"
elif self.direction == directions[2] or self.direction == directions[3]
temp_rotated_s.tiles[0] = Tile(temp_rotated_s.tiles[2].x, temp_rotated_s.tiles[0].y, temp_rotated_s.color)
temp_rotated_s.tiles[1] = Tile(temp_rotated_s.tiles[0].x-tile_length, temp_rotated_s.tiles[0].y, temp_rotated_s.color)
temp_rotated_s.tiles[2] = Tile(temp_rotated_s.tiles[0].x, temp_rotated_s.tiles[0].y-tile_length, temp_rotated_s.color)
temp_rotated_s.tiles[3] = Tile(temp_rotated_s.tiles[2].x+tile_length, temp_rotated_s.tiles[2].y, temp_rotated_s.color)
temp_rotated_s.direction = directions[0] #"vertical_1"
for block_tile in temp_rotated_s.tiles:
if block_tile.x <= off_set_x or block_tile.x >= playing_field_width:
return
y = off_set_y
for i in range(20):
for tile in playing_field.tiles["row"+str(i+1)][y]:
if not tile.empty and block_tile.x == tile.x and block_tile.y == tile.y:
return
y += tile_length
self.direction = temp_rotated_s.direction
self.tiles = temp_rotated_s.tiles
def rotate_t_block(self, playing_field): #done
temp_rotated_t = Block("j_block", self.color)
temp_rotated_t.tiles = self.tiles.copy()
if self.direction == directions[0]:
temp_rotated_t.tiles[0] = Tile(temp_rotated_t.tiles[0].x, temp_rotated_t.tiles[0].y, temp_rotated_t.color)
temp_rotated_t.tiles[1] = Tile(temp_rotated_t.tiles[0].x, temp_rotated_t.tiles[0].y-tile_length, temp_rotated_t.color)
temp_rotated_t.tiles[2] = Tile(temp_rotated_t.tiles[1].x, temp_rotated_t.tiles[1].y-tile_length, temp_rotated_t.color)
temp_rotated_t.tiles[3] = Tile(temp_rotated_t.tiles[1].x+tile_length, temp_rotated_t.tiles[1].y, temp_rotated_t.color)
temp_rotated_t.direction = directions[2] # "horizontal_1"
elif self.direction == directions[2]:
temp_rotated_t.tiles[0] = Tile(temp_rotated_t.tiles[0].x, temp_rotated_t.tiles[0].y, temp_rotated_t.color)
temp_rotated_t.tiles[1] = Tile(temp_rotated_t.tiles[0].x, temp_rotated_t.tiles[0].y-tile_length, temp_rotated_t.color)
temp_rotated_t.tiles[2] = Tile(temp_rotated_t.tiles[1].x-tile_length, temp_rotated_t.tiles[1].y, temp_rotated_t.color)
temp_rotated_t.tiles[3] = Tile(temp_rotated_t.tiles[1].x+tile_length, temp_rotated_t.tiles[2].y, temp_rotated_t.color)
temp_rotated_t.direction = directions[1] #"vertical_2"
elif self.direction == directions[1]:
temp_rotated_t.tiles[0] = Tile(temp_rotated_t.tiles[0].x, temp_rotated_t.tiles[0].y, temp_rotated_t.color)
temp_rotated_t.tiles[1] = Tile(temp_rotated_t.tiles[0].x, temp_rotated_t.tiles[0].y-tile_length, temp_rotated_t.color)
temp_rotated_t.tiles[2] = Tile(temp_rotated_t.tiles[1].x, temp_rotated_t.tiles[1].y-tile_length, temp_rotated_t.color)
temp_rotated_t.tiles[3] = Tile(temp_rotated_t.tiles[1].x-tile_length, temp_rotated_t.tiles[1].y, temp_rotated_t.color)
temp_rotated_t.direction = directions[3] #"horizontal_2"
elif self.direction == directions[3]: #back to normal:
temp_rotated_t.tiles[0] = Tile(temp_rotated_t.tiles[0].x, temp_rotated_t.tiles[0].y, temp_rotated_t.color)
temp_rotated_t.tiles[1] = Tile(temp_rotated_t.tiles[0].x+tile_length, temp_rotated_t.tiles[0].y, temp_rotated_t.color)
temp_rotated_t.tiles[2] = Tile(temp_rotated_t.tiles[0].x-tile_length, temp_rotated_t.tiles[0].y, temp_rotated_t.color)
temp_rotated_t.tiles[3] = Tile(temp_rotated_t.tiles[0].x, temp_rotated_t.tiles[0].y-tile_length, temp_rotated_t.color)
temp_rotated_t.direction = directions[0] #"vertical_1"
for block_tile in temp_rotated_t.tiles:
if block_tile.x <= off_set_x or block_tile.x >= playing_field_width:
return
y = off_set_y
for i in range(20):
for tile in playing_field.tiles["row"+str(i+1)][y]:
if not tile.empty and block_tile.x == tile.x and block_tile.y == tile.y:
return
y += tile_length
self.direction = temp_rotated_t.direction
self.tiles = temp_rotated_t.tiles
def rotate_z_block(self, playing_field): #done
temp_rotated_z = Block("z_block", self.color)
temp_rotated_z.tiles = self.tiles.copy()
if self.direction == directions[0] or self.direction == directions[1]:
temp_rotated_z.tiles[0] = Tile(temp_rotated_z.tiles[3].x, temp_rotated_z.tiles[0].y, temp_rotated_z.color)
temp_rotated_z.tiles[1] = Tile(temp_rotated_z.tiles[0].x, temp_rotated_z.tiles[0].y-tile_length, temp_rotated_z.color)
temp_rotated_z.tiles[2] = Tile(temp_rotated_z.tiles[1].x+tile_length, temp_rotated_z.tiles[1].y, temp_rotated_z.color)
temp_rotated_z.tiles[3] = Tile(temp_rotated_z.tiles[2].x, temp_rotated_z.tiles[2].y-tile_length, temp_rotated_z.color)
temp_rotated_z.direction = directions[2] # "horizontal_1"
elif self.direction == directions[2] or self.direction == directions[3]:
temp_rotated_z.tiles[0] = Tile(temp_rotated_z.tiles[3].x, temp_rotated_z.tiles[0].y, temp_rotated_z.color)
temp_rotated_z.tiles[1] = Tile(temp_rotated_z.tiles[0].x+tile_length, temp_rotated_z.tiles[0].y, temp_rotated_z.color)
temp_rotated_z.tiles[2] = Tile(temp_rotated_z.tiles[0].x, temp_rotated_z.tiles[0].y-tile_length, temp_rotated_z.color)
temp_rotated_z.tiles[3] = Tile(temp_rotated_z.tiles[2].x-tile_length, temp_rotated_z.tiles[2].y, temp_rotated_z.color)
temp_rotated_z.direction = directions[0] #"vertical_1"
for block_tile in temp_rotated_z.tiles:
if block_tile.x <= off_set_x or block_tile.x >= playing_field_width:
return
y = off_set_y
for i in range(20):
for tile in playing_field.tiles["row"+str(i+1)][y]:
if not tile.empty and block_tile.x == tile.x and block_tile.y == tile.y:
return
y += tile_length
self.direction = temp_rotated_z.direction
self.tiles = temp_rotated_z.tiles
def fall_completely(self, next_block, playing_field, player):
from tetris import update_graphics
fall= True
while fall:
for block_tile in self.tiles:
if block_tile.y >= playing_field_height+off_set_y-tile_length:
fall = False
break
#check already existed tiles
for block_tile in self.tiles:
y = off_set_y
for i in range(20):
for tile in playing_field.tiles["row"+str(i+1)][y]:
if not tile.empty and block_tile.y+tile_length == tile.y and block_tile.x == tile.x:
fall = False
break
y += tile_length
if not fall:
break
for tile in self.tiles:
tile.y += tile_length
update_graphics(self, next_block, playing_field, player)
clock.get_rawtime()
clock.tick(50)
class Player:
def __init__(self, start_time):
self.start_time = start_time
self.time_since_start = 0
self.score = 0 tetris.py文件：
python
#import libraries
import pygame
from util import *
def update_graphics(block, next_block, playing_field, player):
#Sets black background and text
DISPLAY_SCREEN.blit(background_img, (0, 0))
pygame.draw.rect(DISPLAY_SCREEN , black, (off_set_x, off_set_y, playing_field_width, playing_field_height) )
font = pygame.font.SysFont("comicsansms", 48)
rendered_text = font.render("Tetris", 1, orange)
DISPLAY_SCREEN.blit(rendered_text, (width/2-80, 10))
#Displays Current score and time
player.time_since_start = pygame.time.get_ticks() - player.start_time
font = pygame.font.SysFont("comicsansms", 20)
rendered_text_time = font.render("Time: " + str(player.time_since_start), 1, orange)
DISPLAY_SCREEN.blit(rendered_text_time, (playing_field_width+tile_length*2, playing_field_height-80))
rendered_text_score = font.render("Score: " + str(player.score), 1, orange)
DISPLAY_SCREEN.blit(rendered_text_score, (playing_field_width+tile_length*2, playing_field_height-50))
#Draw the small screen for the next block
draw_small_screen(next_block)
#Set tiles
y = off_set_y
for i in range(20):
for tile in playing_field.tiles["row"+str(i+1)][y]:
tile.draw_tile()
y += tile_length
#Blocks while falling
for tile in block.tiles:
if tile.y >= off_set_y:
tile.draw_tile()
#Sets borders
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
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
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
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
#Sets Grid
current_y_horizontal_lines = off_set_y
current_x_vertical_lines = off_set_x
for i in range(19):
current_y_horizontal_lines += 33
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
for j in range(9):
current_x_vertical_lines += 33
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
pygame.display.update()
def draw_small_screen(next_block):
#Sets background
pygame.draw.rect(DISPLAY_SCREEN , black, (playing_field_width+tile_length*2, height/2-20, 6*tile_length, 6*tile_length) )
#Sets borders
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
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
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
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
#Sets text
font = pygame.font.SysFont("comicsansms", 30)
rendered_text = font.render("Next Block", 1, orange)
DISPLAY_SCREEN.blit(rendered_text, (playing_field_width+tile_length*2, height/2-70))
#Displays next block
temp_block = Block(next_block.shape, next_block.color)
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)]
temp_block.complete_block()
for tile in temp_block.tiles:
tile.draw_tile()
def is_game_over(playing_field, player):
y = off_set_y
for i in range(20):
for tile in playing_field.tiles["row"+str(i+1)][y]:
if not tile.empty and tile.y <= off_set_y:
temp_y = off_set_y
for j in range(20):
for tile in playing_field.tiles["row"+str(j+1)][temp_y]:
tile.draw_tile()
temp_y += tile_length
font = pygame.font.SysFont("comicsansms", 48)
rendered_text = font.render("GAME OVER", 1, white)
DISPLAY_SCREEN.blit(rendered_text, (off_set_x+20, playing_field_height/2))
pygame.display.update()
time.sleep(2)
introduction(player)
y += tile_length
def start_game():
global best_score
global longest_time
rand_index = random.randint(0, 6)
block = Block(shapes[rand_index], block_colors[rand_index])
next_rand_index = random.randint(0, 6)
next_block = Block(shapes[next_rand_index], block_colors[next_rand_index])
playing_field = PlayingField()
start_time = pygame.time.get_ticks()
player = Player(start_time)
while True:
update_graphics(block, next_block, playing_field, player)
(block, next_block, is_new) = block.get_new_block(next_block, playing_field, player)
if is_new:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
pygame.event.clear()
manage_events(block, next_block, playing_field, player)
update_graphics(block, next_block, playing_field, player)
block.block_is_falling(next_block, playing_field, player)
update_graphics(block, next_block, playing_field, player)
playing_field.destory_full_row(player)
update_graphics(block, next_block, playing_field, player)
if player.score > best_score:
best_score = player.score
if player.time_since_start > longest_time:
longest_time = player.time_since_start
is_game_over(playing_field, player)
update_graphics(block, next_block, playing_field, player)
pygame.display.update()
clock.tick(60)
def manage_events(block, next_block, playing_field, player):
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT:
#move the block to the left
block.move_left(playing_field)
elif event.key == pygame.K_RIGHT:
#move the block to the right
block.move_right(playing_field)
elif event.key == pygame.K_UP:
# rotate block
block.rotate(next_block, playing_field, player)
if event.key == pygame.K_SPACE:
# let the block fall completely
block.fall_completely(next_block, playing_field, player)
if event.key == pygame.K_DOWN:
# let the block fall down faster
block.block_is_falling(next_block, playing_field, player, "faster")
update_graphics(block, next_block, playing_field, player)
def introduction(player = None):
button_width = 300
button_height = 90
#start_x_button = width/2-button_width/2
play_button = Button(blue, orange, -400, height/2, button_width, button_height, 32, black, white, "PLAY")
instructions_button = Button(blue, orange, width+150, height/2+button_height+10, button_width,button_height, 32, black, white, "INSTRUCTIONS")
quit_button = Button(blue, orange, -400, height/2+button_height*2+20, button_width,button_height, 32, black, white, "QUIT")
font = pygame.font.SysFont("comicsansms", 48)
rendered_text = font.render("Tetris", 1, black)
rendered_text_y = height
#To draw the Tetris text in an animated way
while rendered_text_y > 10:
DISPLAY_SCREEN.blit(background_img, (0, 0))
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
rendered_text_y -= 1.5
DISPLAY_SCREEN.blit(rendered_text, (width/2-80, rendered_text_y))
pygame.display.update()
#To draw the score and time texts in an animated way
if player:
font_small = pygame.font.SysFont("comicsansms", 30)
rendered_current_score = font_small.render("Current Score: " + str(player.score), 1, orange)
rendered_best_score = font_small.render("Best Score: " + str(best_score), 1, orange)
rendered_current_time = font_small.render("Current Time: " + str(player.time_since_start), 1, orange)
rendered_longest_time = font_small.render("Longest Time: " + str(longest_time), 1, orange)
rendered_current_score_y = height
rendered_best_score_y = height+40
rendered_current_time_y = height+80
rendered_longest_time_y = height+120
while rendered_current_score_y > 150:
DISPLAY_SCREEN.blit(background_img, (0, 0))
DISPLAY_SCREEN.blit(rendered_text, (width/2-80, rendered_text_y))
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
rendered_current_score_y -= 1.5
rendered_best_score_y -= 1.5
rendered_current_time_y -= 1.5
rendered_longest_time_y -= 1.5
DISPLAY_SCREEN.blit(rendered_current_score, (off_set_x, rendered_current_score_y))
DISPLAY_SCREEN.blit(rendered_best_score, (off_set_x+45, rendered_best_score_y))
DISPLAY_SCREEN.blit(rendered_current_time, (off_set_x+15, rendered_current_time_y))
DISPLAY_SCREEN.blit(rendered_longest_time, (off_set_x+15, rendered_longest_time_y))
pygame.display.update()
#To draw the buttons in an animated way
while play_button.x < width/2-button_width/2 or instructions_button.x > width/2-button_width/2:
DISPLAY_SCREEN.blit(background_img, (0, 0))
DISPLAY_SCREEN.blit(rendered_text, (width/2-80, rendered_text_y))
if player:
DISPLAY_SCREEN.blit(rendered_current_score, (off_set_x, rendered_current_score_y))
DISPLAY_SCREEN.blit(rendered_best_score, (off_set_x+45, rendered_best_score_y))
DISPLAY_SCREEN.blit(rendered_current_time, (off_set_x+15, rendered_current_time_y))
DISPLAY_SCREEN.blit(rendered_longest_time, (off_set_x+15, rendered_longest_time_y))
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
if play_button.x < width/2-button_width/2:
play_button.x += 3
quit_button.x += 3
if instructions_button.x > width/2-button_width/2 :
instructions_button.x -= 3
play_button.blit(DISPLAY_SCREEN)
instructions_button.blit(DISPLAY_SCREEN)
quit_button.blit(DISPLAY_SCREEN)
pygame.display.update()
run = True
while run:
DISPLAY_SCREEN.blit(background_img, (0, 0))
DISPLAY_SCREEN.blit(rendered_text, (width/2-80, rendered_text_y))
if player:
DISPLAY_SCREEN.blit(rendered_current_score, (off_set_x, rendered_current_score_y))
DISPLAY_SCREEN.blit(rendered_best_score, (off_set_x+45, rendered_best_score_y))
DISPLAY_SCREEN.blit(rendered_current_time, (off_set_x+15, rendered_current_time_y))
DISPLAY_SCREEN.blit(rendered_longest_time, (off_set_x+15, rendered_longest_time_y))
# Get the position of the mouse
mouse_position = pygame.mouse.get_pos()
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
if event.type == pygame.MOUSEBUTTONDOWN:
if play_button.is_clicked(mouse_position, event):
start_game()
run = False
elif instructions_button.is_clicked(mouse_position, event):
instructions(player)
run = False
elif quit_button.is_clicked(mouse_position, event):
pygame.quit()
sys.exit()
if play_button.is_hovered_over(mouse_position):
play_button.blit_hovered_over(DISPLAY_SCREEN)
else:
play_button.blit(DISPLAY_SCREEN, gray)
if instructions_button.is_hovered_over(mouse_position):
instructions_button.blit_hovered_over(DISPLAY_SCREEN)
else:
instructions_button.blit(DISPLAY_SCREEN, gray)
if quit_button.is_hovered_over(mouse_position):
quit_button.blit_hovered_over(DISPLAY_SCREEN)
else:
quit_button.blit(DISPLAY_SCREEN, gray)
clock.tick(60)
pygame.display.update()
def instructions(player = None):
button_width = 150
button_height = 60
play_button = Button(blue, orange, width-150-10, height-80, button_width, button_height, 32, black, white, "PLAY >>")
back_button = Button(blue, orange, 10, height-80, button_width, button_height, 32, black, white, "<< BACK")
run = True
while run:
DISPLAY_SCREEN.blit(instructions_img, (0, 0))
font = pygame.font.SysFont("comicsansms", 48)
rendered_text = font.render("Tetris", 1, orange)
DISPLAY_SCREEN.blit(rendered_text, (width/2-80, 10))
# Get the position of the mouse
mouse_position = pygame.mouse.get_pos()
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
if event.type == pygame.MOUSEBUTTONDOWN:
if play_button.is_clicked(mouse_position, event):
start_game()
run = False
elif back_button.is_clicked(mouse_position, event):
introduction(player)
run = False
instructions_label = "Instructions"
font = pygame.font.SysFont("comicsansms", 40)
rendered_text = font.render(instructions_label, 1, orange)
DISPLAY_SCREEN.blit(rendered_text, (width/2 - rendered_text.get_width()/2, 100))
instructions1 = " Move Right: right arrow >"
instructions2 = " Move Left: left arrow <"
instructions3 = " Rotate: up arrow ^"
instructions4 = " Soft Drop: down arrow"
instructions5 = " Hard Drop: space"
font = pygame.font.SysFont("comicsansms", 20)
rendered_text1 = font.render(instructions1, 1, orange)
rendered_text2 = font.render(instructions2, 1, orange)
rendered_text3 = font.render(instructions3, 1, orange)
rendered_text4 = font.render(instructions4, 1, orange)
rendered_text5 = font.render(instructions5, 1, orange)
DISPLAY_SCREEN.blit(rendered_text1, (20, 200))
DISPLAY_SCREEN.blit(rendered_text2, (20, 240))
DISPLAY_SCREEN.blit(rendered_text3, (20, 280))
DISPLAY_SCREEN.blit(rendered_text4, (20, 320))
DISPLAY_SCREEN.blit(rendered_text5, (20, 360))
if play_button.is_hovered_over(mouse_position):
play_button.blit_hovered_over(DISPLAY_SCREEN)
else:
play_button.blit(DISPLAY_SCREEN, gray)
if back_button.is_hovered_over(mouse_position):
back_button.blit_hovered_over(DISPLAY_SCREEN)
else:
back_button.blit(DISPLAY_SCREEN, gray)
clock.tick(60)
pygame.display.update()
if __name__ == "__main__":
introduction()
Python俄罗斯方块Tetris源文件本站下载：
https://download.csdn.net/download/mufenglaoshi/88612722