使用pygame怎么實現俄羅斯方塊游戲

本篇文章給大家分享的是有關使用pygame怎么實現俄羅斯方塊游戲，小編覺得挺實用的，因此分享給大家學習，希望大家閱讀完這篇文章后可以有所收獲，話不多說，跟著小編一起來看看吧。

具體內容如下

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

FPS = 25
WINDOWWIDTH = 640#整個游戲屏幕的寬
WINDOWHEIGHT = 480#整個游戲屏幕的高
BOXSIZE = 20#每個小格子的寬和高
BOARDWIDTH = 10#游戲窗口本身有10個方塊的寬度
BOARDHEIGHT = 20#游戲窗口本身有20個方塊的高度
BLANK = '.'#表示空白空格

#每當玩家按下向左或向右箭頭鍵的時候，下落的磚塊都應該分別向左或向右移動一個方塊。然而，玩家也可以保持按住了向左箭頭鍵或向右箭頭鍵以使得下落的磚塊持續移動。
MOVESIDEWAYSFREQ = 0.15 #按向左箭頭鍵或向右箭頭鍵每次持續按下超過0.15秒的時候，磚塊相應的移動一個空格
MOVEDOWNFREQ = 0.1  #按向下頭鍵每次持續按下超過0.1秒的時候，磚塊向下一個空格
XMARGIN = int((WINDOWWIDTH - BOARDWIDTH * BOXSIZE) / 2)#(0INDOWWIDTH是總窗口的寬度-游戲界面一行上的方塊個數*每個方塊的寬度)/2窗口左邊或右邊剩下的像素數
TOPMARGIN = WINDOWHEIGHT - (BOARDHEIGHT * BOXSIZE) - 5#TOPMARGIN：游戲窗口上面剩下的像素數=總窗口的高度-（游戲界面一列上的方塊個數*每個方塊的高度）-5
#    R G B
WHITE  = (255, 255, 255)#白色
GRAY  = (185, 185, 185)#灰色
BLACK  = ( 0, 0, 0)#黑色
RED   = (155, 0, 0)#紅色
GREEN  = ( 0, 155, 0)#綠色
BLUE  = ( 0, 0, 155)#藍色
YELLOW  = (155, 155, 0)#黃色
BORDERCOLOR = BLUE#邊界顏色
BGCOLOR = BLACK#背景顏色
TEXTCOLOR = WHITE#文字顏色
COLORS  = (BLUE,GREEN,RED,YELLOW) #方塊四種顏色，存于COLORS元組中
TEMPLATEWIDTH = 5#磚塊模板寬 
TEMPLATEHEIGHT = 5#磚塊模板高

S_SHAPE_TEMPLATE = [['.....', #S形狀的模板
      '.....',
      '..OO.',
      '.OO..',
      '.....'],
     ['.....', #S逆時針變化的形狀
      '..O..',
      '..OO.',
      '...O.',
      '.....']]

Z_SHAPE_TEMPLATE = [['.....', #Z形模板
      '.....',
      '.OO..',
      '..OO.',
      '.....'],
     ['.....',
      '..O..',
      '.OO..',
      '.O...',
      '.....']]

I_SHAPE_TEMPLATE = [['..O..', #I型模板
      '..O..',
      '..O..',
      '..O..',
      '.....'],
     ['.....',
      '.....',
      'OOOO.',
      '.....',
      '.....']]

O_SHAPE_TEMPLATE = [['.....', #O型模板
      '.....',
      '.OO..',
      '.OO..',
      '.....']]

J_SHAPE_TEMPLATE = [['.....', #J型模板
      '.O...',
      '.OOO.',
      '.....',
      '.....'],
     ['.....',
      '..OO.',
      '..O..',
      '..O..',
      '.....'],
     ['.....',
      '.....',
      '.OOO.',
      '...O.',
      '.....'],
     ['.....',
      '..O..',
      '..O..',
      '.OO..',
      '.....']]

L_SHAPE_TEMPLATE = [['.....', #L型模板
      '...O.',
      '.OOO.',
      '.....',
      '.....'],
     ['.....',
      '..O..',
      '..O..',
      '..OO.',
      '.....'],
     ['.....',
      '.....',
      '.OOO.',
      '.O...',
      '.....'],
     ['.....',
      '.OO..',
      '..O..',
      '..O..',
      '.....']]

T_SHAPE_TEMPLATE = [['.....', #T型模板
      '..O..',
      '.OOO.',
      '.....',
      '.....'],
     ['.....',
      '..O..',
      '..OO.',
      '..O..',
      '.....'],
     ['.....',
      '.....',
      '.OOO.',
      '..O..',
      '.....'],
     ['.....',
      '..O..',
      '.OO..',
      '..O..',
      '.....']]

PIECES = {'S': S_SHAPE_TEMPLATE, #PIECES是一個字典，它儲存了所有不同的模板(列表)。每個模板都擁有一個形狀所有可能的旋轉(列表)。
   'Z': Z_SHAPE_TEMPLATE,
   'J': J_SHAPE_TEMPLATE,
   'L': L_SHAPE_TEMPLATE,
   'I': I_SHAPE_TEMPLATE,
   'O': O_SHAPE_TEMPLATE,
   'T': T_SHAPE_TEMPLATE}

def main(): #main()函數還負責創建了一些其他的全局常量，并且顯示了在游戲運行的時候出現的初始屏幕。
 global FPSCLOCK, DISPLAYSURF, BASICFONT, BIGFONT
 pygame.init()#在inport pygame之后 調用其他函數之前總要調用這個函數
 FPSCLOCK = pygame.time.Clock()#pygame.time.Clock()創建pygame.time.Clock對象
 DISPLAYSURF = pygame.display.set_mode((WINDOWWIDTH, WINDOWHEIGHT)) #pygame.display.set_mode()的參數是一個元組,該元祖中有兩個參數，
 #即：創建窗口的寬和高，單位是像素，該函數返回pygame.Surface對象
 BASICFONT = pygame.font.Font('freesansbold.ttf', 18)#字體
 BIGFONT = pygame.font.Font('freesansbold.ttf', 100)#字體
 pygame.display.set_caption('Tetromino')#設置窗口標題
 showTextScreen('Tetromino')#設置在開始界面顯示的文字

 while True: #游戲循環，該游戲循壞會在一秒之內多次檢查是否發生了任何新的事件，例如：點擊鼠標或按下鍵盤
  pygame.mixer.music.load('tetrisc.mp3')#加載音樂 
  pygame.mixer.music.play(-1, 0.0)#播放音樂
  runGame()#調用runGame()開始游戲，當游戲失敗的時候,runGame()將返回main(),
  pygame.mixer.music.stop()#然后main()會停止背景音樂
  showTextScreen('Game Over')#并顯示游戲結束屏幕。當玩家按下一個鍵，showTextScreen()函數將返回，程序回到main()中的的第一行，重新開始游戲

def runGame():#實際的游戲代碼都在runGame中
#在游戲開始并且磚塊開始下落前，我們需要將一些變量初始化為游戲開始時候的值。
 board = getBlankBoard()#創建一個空白游戲板數據結構
 lastMoveDownTime = time.time()#lastMoveDownTime最后按向下方向鍵的時間
 lastMoveSidewaysTime = time.time()#lastMoveSidewaysTime最后按左右向鍵的時間
 lastFallTime = time.time()#最后下落磚塊的時間
 movingDown = False #沒有按下向下方向鍵
 movingLeft = False #沒有按下向左方向鍵
 movingRight = False #沒有按下向右方向鍵
 score = 0 #得分
 level, fallFreq = calculateLevelAndFallFreq(score)#計算關卡數和下落頻率，因為此時score=0，所以經計算后level=1,fallFreq=0.25
 fallingPiece = getNewPiece() #fallingPiece變量將設置為能夠被玩家操作的當前下落的磚塊
 nextPiece = getNewPiece() #nextPice為在屏幕的Next部分出現的磚塊，即下一個將要下落的磚塊

 while True: # 游戲主循環，它負責磚塊在落向底部的過程中，游戲主要部分的代碼
  if fallingPiece == None:#在下落的磚塊已經著陸之后，fallingPiece變量設置為None
   fallingPiece = nextPiece#這意味著nextPiece中的磚塊將會復制到fallingPiece中。
   nextPiece = getNewPiece()#生成新的新的nextPiece磚塊，磚塊可以通過getNewPiece()函數生成。
   lastFallTime = time.time() #該變量也重新設置為當前時間，以便磚塊能夠在fallFreq中所設置的那么多秒之內下落。
   if not isValidPosition(board, fallingPiece):
     #但是，如果游戲板已經填滿了，isValidPosition()將返回False，導致這是一個無效的位置，那么，我們知道游戲板已經填滿了，玩家失敗了。
    return #在這種情況下 runGame()函數將被返回。

  for event in pygame.event.get(): #事件處理循環負責玩家旋轉下落的磚塊，移動下落的磚塊。
    #松開一個剪頭鍵將會把movingLeft或movingRight或movingDown變量設置為False,表示玩家不再想
    #要讓磚塊朝著該方向移動。隨后的代碼將會根據這些“moving”變量中的Boolean值來確定做什么。
   if event.type == KEYUP:#當按鍵彈起的時候響應KEYUP事件
    if (event.key == K_LEFT):#判斷當前彈起的按鍵是否為左方向鍵
     movingLeft = False #是的話置為False,表示玩家不再想要讓磚塊朝著該方向移動。
    elif (event.key == K_RIGHT):#同上
     movingRight = False
    elif (event.key == K_DOWN):#同上
     movingDown = False

   elif event.type == KEYDOWN:#當按鍵按下的時候響應KEYDOWN事件
    if (event.key == K_LEFT) and isValidPosition(board, fallingPiece, adjX=-1):
    #當按下的按鍵為向左方向鍵，并且向左移動一個位置有效
     fallingPiece['x'] = fallingPiece['x'] -1 #左移
     movingLeft = True #將movingLeft變量設置為True，并且為了確保落下的磚塊不會既向左又向右移動
     movingRight = False #將 movingRight設置為False
     lastMoveSidewaysTime = time.time() #lastMoveSidewaysTime更改為當前時間
#設置了 movingLeft，movingRigh以便玩家能夠只是按住方向鍵以保持磚塊移動。如果movingLeft變量設置為True，程序就知道已經按下了向左箭頭鍵并且沒有松開它。

    elif (event.key == K_RIGHT ) and isValidPosition(board, fallingPiece, adjX=1): #同上
     fallingPiece['x'] =fallingPiece['x'] + 1
     movingRight = True
     movingLeft = False
     lastMoveSidewaysTime = time.time()

    #按向上箭頭將會把磚塊為其下一個旋轉狀態。代碼所需要做的只是fallingPiece字典中的'rotation'鍵的值增加1。然而，如果增加'rotation'鍵的值
    #大于旋轉的總數目，那么用該形狀可能旋轉的總數目(這就是len(PIECES[fallingPiece['shape']的含義)來模除它，然后，這個值將回滾到從0開始。
    elif event.key == K_UP :
     fallingPiece['rotation'] = (fallingPiece['rotation'] + 1) % len(PIECES[fallingPiece['shape']])
     if not isValidPosition(board, fallingPiece):
     #由于新的旋轉位置與游戲板上已有的一些方塊重疊而導致新的旋轉位置無效，那么，
     #我們想要通過從fallingPiece['rotation']減去1而切換回最初的旋轉。我們也可以使用len(PIECES[fallingPiece['shape']])來模除
     #它，以便如果新的值為-1，模除將其改為列表中的最后一次旋轉。????
      fallingPiece['rotation'] = (fallingPiece['rotation'] - 1) % len(PIECES[fallingPiece['shape']])

    #如果按下了向下鍵，說明玩家想要磚塊下落得比正常速度更快一些。
    elif (event.key == K_DOWN ):
     movingDown = True # movingDown設置為True
     if isValidPosition(board, fallingPiece, adjY=1):#下一個位置有效
      fallingPiece['y'] = fallingPiece['y'] +1 #移動
     lastMoveDownTime = time.time() #lastMoveDownTime重新設置為當前時間。隨后將檢查這些變量，以確保只要按下向下箭頭鍵的時候，磚塊就
     #會以較快的速率下降

  if (movingLeft or movingRight) and time.time() - lastMoveSidewaysTime > MOVESIDEWAYSFREQ:#MOVESIDEWAYSFREQ = 0.15 按向左或向右超過0.15秒
   if movingLeft and isValidPosition(board, fallingPiece, adjX=-1):#如果是向左方向鍵，并且向左一個位置有效
    fallingPiece['x'] =fallingPiece['x'] - 1#左移動一個位置
   elif movingRight and isValidPosition(board, fallingPiece, adjX=1):#如果是向右方向鍵，并且向左一個位置有效
    fallingPiece['x'] =fallingPiece['x'] + 1#右移動一個位置
   lastMoveSidewaysTime = time.time() #將lastMoveSidewaysTime更新為當前時間。

  if movingDown and time.time() - lastMoveDownTime > MOVEDOWNFREQ and isValidPosition(board, fallingPiece, adjY=1):
  #MOVEDOWNFREQ = 0.1 按向下方向鍵超過0.1秒，并且向下一個位置有效
   fallingPiece['y'] = fallingPiece['y'] + 1#向下移動一個位置
   lastMoveDownTime = time.time()#將laslastMoveDownTime更新為當前時間。

  #讓磚塊自然落下
  if time.time() - lastFallTime > fallFreq:#fallFreq向下移動的速率
   if not isValidPosition(board, fallingPiece, adjY=1):#當磚塊下一個位置無效時，即表示磚塊當前已經著陸了。
    addToBoard(board, fallingPiece) #在游戲板數據結構中記錄這個著陸的磚塊
    score=score + removeCompleteLines(board)# removeCompleteLines()將負責刪除掉游戲板上任何已經填充完整的行，并且將方塊向下推動。
    #removeCompleteLines()函數還會返回一個整數值，表明消除了多少行，以便我們將這個數字加到得分上。
    level, fallFreq = calculateLevelAndFallFreq(score)#由于分數已經修改了，我們調用calculateLevelAndFallFreq()函數來更新當前的關卡以及磚塊下落得頻率。
    fallingPiece = None#最后我們將fallingPiece變量設置為None,以表示下一個磚塊應該變為新的下落磚塊，并且應該生成一個隨機的新磚塊作為下一個磚塊。？？？？？？
   else:
    # 如果磚塊沒有著陸，我們直接將其Y位置向下設置一個空格，并且將lastFallTime重置為當前時間
    fallingPiece['y'] = fallingPiece['y'] +1
    lastFallTime = time.time()

  # drawing everything on the screen
  DISPLAYSURF.fill(BGCOLOR)
  drawBoard(board)
  drawStatus(score, level)
  drawNextPiece(nextPiece)
  if fallingPiece != None:#磚塊沒有下落到底部
   drawPiece(fallingPiece)
  pygame.display.update()
  FPSCLOCK.tick(FPS)

def makeTextObjs(text, font, color):
 surf = font.render(text, True, color)
 return surf, surf.get_rect()

def checkForKeyPress():
 # checkForKeyPress()函數和它在Wormy游戲中所做的事件相同。首先，它調用checkForQuit()來處理任何的QUIT事件(或者是專門針對Esc鍵的KEYUP事件)，如果有任何這樣的事件
 #就會終止程序。然后，它從事件隊列中提取出所有的KEYDOWN, KEYUP事件。它會忽略掉任何的KEYDOWN事件(針對pygame.event.get()指定了KEYDOWN,從而從事件隊列中清除掉該類事件)。
 #如果事件隊列中沒有KEYUP事件，那么該函數返回None。
 for event in pygame.event.get([KEYDOWN, KEYUP]):
  if event.type == KEYDOWN:
   continue
  return event.key
 return None

def calculateLevelAndFallFreq(score):#每次玩家填滿一行，起分數都將增加1分。每增加10分，游戲就進入下一個關卡，磚塊下落得會更快。關卡和下落的頻率都是通過傳遞
 level = int(score / 10) + 1 #給該函數的分數來計算的。要計算關卡，我們使用int()來舍入除以10以后的分數。因此如果分數是0-9之間的任何數字，int()調用會將其
 fallFreq = 0.27 - (level * 0.02) #舍入到0。代碼這里的+1部分，是因為我們想要第一個關卡作為第一關，而不是第0關。當分數達到10分的時候，int(10/10)將會計算為1
 return level, fallFreq #并且+1將會使得關卡變為2
 #為了計算下落的頻率，我們首先有一個基準值0.27(這意味著每0.27秒，磚塊會自然地下落一次)。然后，我們將關卡值乘以0.02，并且從基準時間0.27中減去它。因此，對于關卡1，
 #我們從0.27中減去0.02*1得到0.25。在關卡2中我們減去0.02*2得到0.23。對于每一個關卡來說，磚塊下落的速度都比之前的關卡塊了0.02秒。

#getNewPiece()函數產生一個隨機的磚塊，放置于游戲板的頂部(設置'y'=-2)。
def getNewPiece():
 shape = random.choice(list(PIECES.keys()))#PIECES是一個字典，它的鍵為代表形狀的字母，值為一個形狀所有可能的旋轉(列表的列表)。
 #PIECES.keys()返回值是(['Z','J','L','I','O','T'])的元組，list(PIECES.keys())返回值是['Z','J','L','I','O','T']列表
 #這樣轉換是因為random.choice()函數只接受列表值作為其參數。 random.choice()函數隨機地返回列表中的一項的值，即可能是'Z'。
 newPiece = {'shape': shape,
    'rotation': random.randint(0, len(PIECES[shape]) - 1), #rotation：隨機出磚塊是多個旋轉形裝的哪個
    #PIECES['Z']的返回值為[[形狀],[形狀]]，len(PIECES['z'])的返回值為2 2-1=1 random.randint(0,1)隨機范圍是[0,1]
    'x': int(BOARDWIDTH / 2) - int(TEMPLATEWIDTH / 2), #'x'代表磚塊5x5數據結構左上角第一個方格的橫坐標，鍵的值總是要設置為游戲板的中間。
    'y': -2, #'x'代表磚塊5x5數據結構左上角第一個方格的縱坐標，'y'鍵的值總是要設置為-2以便將其放置到游戲板上面一點點(游戲板的首行是0行)
    'color': random.randint(0, len(COLORS) - 1)#COLORS：不同顏色的一個元組
    }
 return newPiece#getNewPiece()函數返回newPiece字典

#給游戲板數據結構添加磚塊
def addToBoard(board, piece): #游戲板數據結構用來記錄之前著陸的磚塊。該函數所做的事情是接受一個磚塊數據結構，并且將其上的有效磚塊添加到游戲板數據結構中
 for x in range(TEMPLATEWIDTH): #該函數這在一個磚塊著陸之后進行
  for y in range(TEMPLATEHEIGHT):#嵌套for遍歷了5x5磚塊數據結構,當找到一個有效磚塊時，將其添加到游戲板中
   if PIECES[piece['shape']][piece['rotation']][y][x] != BLANK:
    board[x + piece['x']][y + piece['y']] = piece['color'] #游戲板數據結構的值有兩種形式：數字(表示磚塊顏色)，'.'即空白，表示該處沒有有效磚塊

def getBlankBoard(): #創建一個新的游戲板數據結構。
 board = [] #創建一個空白的游戲板
 for i in range(BOARDWIDTH):# range(10)=[0,9] BOARDWIDTH=10 BLANK = '.' #表示空白空格
  board.append([BLANK] * BOARDHEIGHT)
 #board[0]-board[9]每一個變量的值都是20個.組成的列表 
 return board

def isOnBoard(x, y):#isOnBoard()函數檢查參數x,y坐標是否存在于游戲板上
 return x >= 0 and x < BOARDWIDTH and y < BOARDHEIGHT#BOARDWIDTH=10，BOARDHEIGHT=20

def isValidPosition(board, piece, adjX=0, adjY=0):#board:游戲板 piece：磚塊 adjX,adjY表示5x5磚塊左上角方塊的坐標
#isValidPositio，n()如果磚塊中所有的方塊都在游戲板上并且沒有和游戲板上任何方塊重疊，那么返回True
#isValidPosition()函數還有名為adjX和adjY的可選參數。通常，isValidPosition()函數檢查作為第二個參數傳遞的磚塊對象所提供的位置數據(此時adjX=0, adjY=0)。
#然而，有時候我們不想要檢查磚塊的當前位置，而是要檢查該位置之上的一些空格
##如果給adjX遞-1.那么它不會檢查磚塊的數據結構中的位置的有效性，而是檢查磚塊所處的位置的左邊一個空格是否是有效的。
#給adjX傳遞1的話，將會檢查磚塊右邊的一個空格。還有一個可選的adjY參數。傳遞-1給adjY,將會檢查磚塊當前所處位置的上面一個空格，
#而給adjY傳遞值3將會檢查磚塊所在位置下面的3個空格。
 for x in range(TEMPLATEWIDTH): #TEMPLATEWIDTH=5 TEMPLATEWIDTH=5
  for y in range(TEMPLATEHEIGHT):# 遍歷磚塊模板的所有方塊
   isAboveBoard = y + piece['y'] + adjY < 0 #模板還沒完全進入游戲板
   if isAboveBoard or PIECES[piece['shape']][piece['rotation']][y][x] == BLANK:#在5x5模板中不等于'.'的方塊，即有效方塊
    continue
   if not isOnBoard(x + piece['x'] + adjX, y + piece['y'] + adjY):#有效磚塊不在游戲板上
    return False
   if board[x + piece['x'] + adjX][y + piece['y'] + adjY] != BLANK:#有效磚塊和游戲板上的方塊重疊
    return False
 return True

def isCompleteLine(board, y):#判斷y行是否填滿，填滿返回True
 for x in range(BOARDWIDTH):#遍歷該行的所有磚塊
  if board[x][y] == BLANK:#如果存在空白，則沒填滿
   return False
 return True

def removeCompleteLines(board):#刪除所有填滿行，每刪除一行要將游戲板上該行之上的所有方塊都下移一行。返回刪除的行數
 numLinesRemoved = 0
 y = BOARDHEIGHT - 1 # BOARDHEIGHT=20-1=19即從最低行開始
 while y >= 0:#注意當刪除一行時y沒有生變化，因為此時它的值已經更新為新的一行了
  if isCompleteLine(board, y):#如果該行填滿
   for pullDownY in range(y, 0, -1): #range(y, 0, -1)范圍[y,1]
    for x in range(BOARDWIDTH):
     board[x][pullDownY] = board[x][pullDownY-1]#將刪除的行之上的每一行的值都復制到下一行
   for x in range(BOARDWIDTH):#刪除第一行
    board[x][0]=BLANK
   numLinesRemoved=numLinesRemoved+1
  else:
   y =y- 1 #移到下一行
 return numLinesRemoved

def convertToPixelCoords(boxx, boxy):#將游戲板上方塊的坐標轉化成像素坐標
 return (XMARGIN + (boxx * BOXSIZE)), (TOPMARGIN + (boxy * BOXSIZE))#XMARGIN為游戲板左頂點的橫坐標，TOPMARGIN為游戲板左頂點的縱坐標

def drawBoard(board):#繪制游戲板邊界
 pygame.draw.rect(DISPLAYSURF, BORDERCOLOR, (XMARGIN - 3, TOPMARGIN - 7, (BOARDWIDTH * BOXSIZE) + 8, (BOARDHEIGHT * BOXSIZE) + 8), 5)
 #pygame.draw.rect(DISPLAYSURF對象,RED顏色,(x,y,width,height),線的寬度) rect:矩形 x,y表示左上角的坐標 width表示矩形的寬度 height表示高度
 #線的寬度為0(默認)表示全部填充，為1會畫很細的線
 pygame.draw.rect(DISPLAYSURF, BGCOLOR, (XMARGIN, TOPMARGIN, BOXSIZE * BOARDWIDTH, BOXSIZE * BOARDHEIGHT)) #填充游戲板的背景顏色
 for x in range(BOARDWIDTH):#遍歷游戲板
  for y in range(BOARDHEIGHT):
   drawBox(x, y, board[x][y])#這個函數會自動找出有效方塊并繪制

#繪制一個磚塊的一個有效方塊(每個磚塊有個有效方塊)
def drawBox(boxx, boxy, color, pixelx=None, pixely=None):#繪制一個有效方塊
 if color == BLANK: #如果這不是一個有效方塊，這是5x5一個空白
  return
 if pixelx == None and pixely == None:
  pixelx, pixely = convertToPixelCoords(boxx, boxy)#將游戲板上方塊的坐標轉化成像素坐標
 pygame.draw.rect(DISPLAYSURF, COLORS[color], (pixelx + 1, pixely + 1, BOXSIZE - 1, BOXSIZE - 1))#留出1像素的空白，這樣才能在磚塊中看到組成磚塊
 #的有效方塊，不然磚塊看起來就只有一片顏色。

#繪制一個磚塊
def drawPiece(piece, pixelx=None, pixely=None):#pixelx, pixely為5x5磚塊數據結構左上角在游戲板上的的坐標
 shapeToDraw = PIECES[piece['shape']][piece['rotation']]#PIECES[piece['shape']][piece['rotation']]為一個圖形的一種旋轉方式
 if pixelx == None and pixely == None: 
 #然而，'Next'磚塊并不會繪制到游戲板上。在這種情況下，我們忽略磚塊數據結構中包含的位置信息，而是讓drawPiece()函數的調用者
#為pixelx何pixely參數傳遞實參，以指定應該將磚塊確切地繪制到窗口上的什么位置。
  pixelx, pixely = convertToPixelCoords(piece['x'], piece['y'])#將磚塊坐標轉換為像素坐標。
 for x in range(TEMPLATEWIDTH): #遍歷5x5磚塊數據結構
  for y in range(TEMPLATEHEIGHT):
   if shapeToDraw[y][x] != BLANK:
    drawBox(None, None, piece['color'], pixelx+(x * BOXSIZE), pixely + (y * BOXSIZE))
    #還記得嗎？有效方塊左上角在游戲板中的坐標=有效方塊左上角在方塊板數據結構中的坐標+方塊數據額結構左上角在游戲板中的坐標，這里這不過換成了像素格式

def drawNextPiece(piece):
 nextSurf = BASICFONT.render('Next:', True, TEXTCOLOR)
 nextRect = nextSurf.get_rect()
 nextRect.topleft = (WINDOWWIDTH - 120, 80)
 DISPLAYSURF.blit(nextSurf, nextRect)
 drawPiece(piece, pixelx=WINDOWWIDTH-120, pixely=100)

def drawStatus(score, level):
 scoreSurf = BASICFONT.render('Score: %s' % score, True, TEXTCOLOR)
 scoreRect = scoreSurf.get_rect()
 scoreRect.topleft = (WINDOWWIDTH - 150, 20)
 DISPLAYSURF.blit(scoreSurf, scoreRect)
 levelSurf = BASICFONT.render('Level: %s' % level, True, TEXTCOLOR)
 levelRect = levelSurf.get_rect()
 levelRect.topleft = (WINDOWWIDTH - 150, 50)
 DISPLAYSURF.blit(levelSurf, levelRect)

def showTextScreen(text):
 titleSurf, titleRect = makeTextObjs(text, BIGFONT, TEXTCOLOR)
 titleRect.center = (int(WINDOWWIDTH / 2) - 3, int(WINDOWHEIGHT / 2) - 3)
 DISPLAYSURF.blit(titleSurf, titleRect)
 pressKeySurf, pressKeyRect = makeTextObjs('Press a key to play.', BASICFONT, TEXTCOLOR)
 pressKeyRect.center = (int(WINDOWWIDTH / 2), int(WINDOWHEIGHT / 2) + 100)
 DISPLAYSURF.blit(pressKeySurf, pressKeyRect)
 while checkForKeyPress() == None:
  pygame.display.update()
  FPSCLOCK.tick()

if __name__ == '__main__':
 main()

以上就是使用pygame怎么實現俄羅斯方塊游戲，小編相信有部分知識點可能是我們日常工作會見到或用到的。希望你能通過這篇文章學到更多知識。更多詳情敬請關注億速云行業資訊頻道。