pygame库实现俄罗斯方块小游戏

本文实例为大家分享了pygame库实现俄罗斯方块小游戏的具体代码,供大家参考,具体内容如下

import random,time,pygame,sys
from pygame.locals import *#导pygame内定义的一些常量
FPS=25#每秒传输帧数(刷新率),此处一秒内在屏幕上连续投射出24张静止画面
WINDOWWIDTH=640#窗口宽
WINDOWHEIGHT=480#窗口高
BOXSIZE=20#游戏框大小
BOARDWIDTH=10#游戏框宽度
BOARDHEIGHT=20#游戏框高度
BLANK='.'#定义方块形状模板时,填补空白处的字符

MOVESIDEWAYSFREQ=0.15#玩家一直按下左或右方向键,方块仍是每0.15s才会移动一次
MOVEDOWNFREQ=0.1#玩家一直按下下方向键,方块仍是每0.1s移动一次

XMARGIN=(WINDOWWIDTH-BOARDWIDTH*BOXSIZE)/2#游戏界面的宽度
TOPMARGIN=WINDOWHEIGHT-(BOARDHEIGHT*BOXSIZE)-5#游戏界面的高度

#定义RGB颜色变量
WHITE=(255,255,255)#设置字体颜色
BLACK=(0,0,0)#整个窗口背景为黑色
GRAY=(185,185,185)#字体阴影灰色
#以下的颜色分别被COLORS和LIGHTCOLORS所引用
RED=(155,0,0)
LIGHTRED=(175, 20, 20)#浅红
GREEN=(0,155,0)
LIGHTGREEN=(20,175,20)#浅绿
BLUE=(0,0,155)
LIGHTBLUE=(20,20,175)#浅蓝
YELLOW=(155,155,0)
LIGHTYELLOW=(175,175,20)#浅黄

BORDERCOLOR=BLUE#游戏边框颜色为蓝色
BGCOLOR=BLACK#背景颜色为黑色
TEXTCOLOR=WHITE#字体为白色,被showTextScreen()引用,用来设置暂停时的"Pause"文本字体颜色
TEXTSHADOWCOLOR=GRAY#字体阴影为灰色,被showTextScreen()引用,用来设置暂停时的"Pause"文本阴影字体颜色
COLORS=(BLUE,GREEN,RED,YELLOW)#组成方块的小方块颜色
LIGHTCOLORS=(LIGHTBLUE,LIGHTGREEN,LIGHTRED,LIGHTYELLOW)#围绕在小方块周边颜色,强调轮廓

assert len(COLORS)==len(LIGHTCOLORS)#每个颜色对应其浅色

TEMPLATEWIDTH=5#模板宽
TEMPLATEHEIGHT=5#模板高

#定义方块形状模板(顺时针旋转变换),在列表中嵌入了含有字符串的列表来构成这个模板,模板包含了这个方块可能变换的所有形状
S_SHAPE_TEMPLATE=[['.....',
          '.....',
          '..00.',
          '.00..',
          '.....'],
         ['.....',
          '..0..',
          '..00.',
          '...0.',
          '.....']]
Z_SHAPE_TEMPLATE=[['.....',
          '.....',
          '.00..',
          '..00.',
          '.....'],
         ['.....',
          '..0..',
          '.00..',
          '.0...',
          '.....']]
I_SHAPE_TEMPLATE=[['..0..',
          '..0..',
          '..0..',
          '..0..',
          '.....'],
         ['.....',
          '.....',
          '0000.',
          '.....',
          '.....']]
O_SHAPE_TEMPLATE=[['.....',
          '.....',
          '.00..',
          '.00..',
          '.....']]
J_SHAPE_TEMPLATE=[['.....',
          '.0...',
          '.000.',
          '.....',
          '.....'],
         ['.....',
          '..00.',
          '..0..',
          '..0..',
          '.....'],
         ['.....',
          '.....',
          '.000.',
          '...0.',
          '.....'],
         ['.....',
          '..0..',
          '..0..',
          '.00..',
          '.....']]
L_SHAPE_TEMPLATE=[['.....',
          '...0.',
          '.000.',
          '.....',
          '.....'],
         ['.....',
          '..0..',
          '..0..',
          '..00.',
          '.....'],
         ['.....',
          '.....',
          '.000.',
          '.0...',
          '.....'],
         ['.....',
          '.00..',
          '..0..',
          '..0..',
          '.....']]
T_SHAPE_TEMPLATE=[['.....',
          '..0..',
          '.000.',
          '.....',
          '.....'],
         ['.....',
          '..0..',
          '..00.',
          '..0..',
          '.....'],
         ['.....',
          '.....',
          '.000.',
          '..0..',
          '.....'],
         ['.....',
          '..0..',
          '.00..',
          '..0..',
          '.....']]
#定义字典变量PIECES来存储所有的不同形状模板(重点是所有),即字典变量PIECES包含了每个类型的方块和所有的变换形状
PIECES={'S':S_SHAPE_TEMPLATE,
    'Z':Z_SHAPE_TEMPLATE,
    'I':I_SHAPE_TEMPLATE,
    'O':O_SHAPE_TEMPLATE,
    'J':J_SHAPE_TEMPLATE,
    'L':L_SHAPE_TEMPLATE,
    'T':T_SHAPE_TEMPLATE}
#主函数用于创建一些全局变量并在游戏开始之前显示一个初始画面
def main():
  global FPSCLOCK,DISPLAYSURF,BASICFONT,BIGFONT
  pygame.init()#初始化pygame相关模块,为使用硬件做准备
  FPSCLOCK=pygame.time.Clock()#创建一个新对象,可以使用时钟跟踪的时间量。该时钟还提供多种功能以帮助控制游戏的帧率。返回一个Clock对象
  DISPLAYSURF=pygame.display.set_mode((WINDOWWIDTH,WINDOWHEIGHT))#显示窗口(返回一个Surface对象)
  BASICFONT=pygame.font.Font('freesansbold.ttf',18)#用来设置暂停时"Press a key to play."字体颜色,被showTextScreen()引用
  BIGFONT=pygame.font.Font('freesansbold.ttf',100)#用来设置暂停时"Pause"文本及其阴影文本字体大小,被showTextScreen()引用
  pygame.display.set_caption('俄罗斯方块')
  while True:
    #随机播放背景音乐,mid音乐格式由MIDI继承而来。MID文件并不是一段录制好的音乐,而是记录
    #声音的信息,然后告诉声卡如何再现音乐的一组指令,所以音乐播放的好坏因不同机器的声卡而不同
    if random.randint(0,1)==0:#加入异常语句,没有mid音乐也可直接运行
      try:
        pygame.mixer.music.load('QQ火拼泡泡龙复原BGM---无损[游戏中].mid')
      except:
        pass
    else:
      try:
        pygame.mixer.music.load('蛇蛇争霸.mid')
      except:
        pass
    try:
      pygame.mixer.music.play(-1,0.0)#参数依次为无限循环播放,从音乐开头播放
    except:
      pass
    runGame()
    try:
      pygame.mixer.music.stop()
    except:
      pass
    showTextScreen('Game Over')

def runGame():
  """启动运行游戏函数"""
  board=getBlankBoard()#返回一个新的空白板数据结构
  lastMoveDownTime=time.time()
  lastMoveSidewaysTime=time.time()
  lastFallTime=time.time()
  #按下方向键会将以下三个变量设置为None,上移变量用于翻转方块,故没有上移变量
  movingDown=False
  movingLeft=False
  movingRight=False
  score=0
  level,fallFreq=calculateLevelAndFallFreq(score)
  fallingPiece=getNewPiece()#当前掉落的方块
  nextPiece=getNewPiece()#游戏玩家可以在屏幕的NEXT区域看见的下一个方块

  while True:#开始游戏循环
    if fallingPiece==None:
      fallingPiece=nextPiece#没有下降的一块在运动,所以开始一个新的一块在顶部,把nextPiece变量中的下一个方块赋值给fallingPiece变量
      nextPiece=getNewPiece()
      lastFallTime=time.time()#重置lastFallTime变量,赋值为当前时间,这样就可以通过变量fallFreq控制方块下落频率
      if not isValidPosition(board, fallingPiece):#不能在游戏框中放下新的方块,游戏结束,Valid:有效的,Position:位置
        return#返回runGame函数调用处
    checkForQuit()#不断检查是否要退出
    for event in pygame.event.get():#事件处理循环
      if event.type==KEYUP:
        if event.key==K_p:#暂停游戏
          DISPLAYSURF.fill(BGCOLOR)#将DISPLAYSURF(窗口Surface对象)重新填充为黑色
          showTextScreen('Paused')#DISPLAYSURF(窗口Surface对象)显示暂停字样
          lastMoveDownTime = time.time()
          lastMoveSidewaysTime = time.time()
          lastFallTime = time.time()
        elif event.key==K_LEFT or event.key==K_a:
          movingLeft=False
        elif event.key==K_RIGHT or event.key==K_d:
          movingRight=False
        elif event.key==K_DOWN or event.key==K_s:
          movingDown=False
      elif event.type==KEYDOWN:#将方块侧向移动
        if event.key==K_LEFT or event.key==K_a and isValidPosition(board,fallingPiece,adjX=-1):
          fallingPiece['x']-=1
          movingLeft=True
          movingRight=False
          lastMoveSidewaysTime=time.time()
        elif event.key==K_RIGHT or event.key==K_d and isValidPosition(board,fallingPiece,adjX=1):
          fallingPiece['x']+=1
          movingRight=True
          movingLeft=False
          lastMoveSidewaysTime=time.time()
        elif event.key==K_UP or event.key==K_w:#按向上键,旋转方块(如果有空间的话)
          fallingPiece['rotation']=(fallingPiece['rotation']+1)%len(PIECES[fallingPiece['shape']])
          if not isValidPosition(board,fallingPiece):
            fallingPiece['rotation']=(fallingPiece['rotation']-1)%len(PIECES[fallingPiece['shape']])
        elif event.key==K_q:#按q键,按相反方向旋转
          fallingPiece['rotation']=(fallingPiece['rotation']-1)%len(PIECES[fallingPiece['shape']])
          if not isValidPosition(board,fallingPiece):
            fallingPiece['rotation'] = (fallingPiece['rotation'] + 1) % len(PIECES[fallingPiece['shape']])
        elif event.key==K_DOWN or event.key==K_s:#按下向下键,使得方块下落得更快,fallingPiece['y']+=1使方块下落一个格子,
                             #前提是这是一个有效下落,把movingDown设置为True,把lastMoveDownTime变量
                             #设置为当前时间.当向下方向键一直pp按下时,以后将会检查这个变量保证方块以一个较快速率下降
          movingDown=True
          if isValidPosition(board,fallingPiece,adjY=1):
            fallingPiece['y']+=1
          lastMoveDownTime=time.time()
        elif event.key==K_SPACE:#如果按下的是空格,则将方块一步到底部。程序首先需要找出它着落需要下降多少个格子,有关moving的3个变量都要
                    #设置为False,用以保证程序后面部分代码知道游戏玩家已经按下所有方向键。
          movingDown=False
          movingLeft=False
          movingRight=False
          for i in range(1,BOARDHEIGHT):
            if not isValidPosition(board,fallingPiece,adjY=i):
              break
          fallingPiece['y']+=i-1
    if (movingLeft or movingRight) and (time.time()-lastMoveSidewaysTime) > MOVESIDEWAYSFREQ:#如果用户按住按键超过0.15s,那么该表达式返回True,便可使得方块左或右移一个格子
                                               #因为如果用户重复按下方向键让方块移动多个格子是很烦人的。好的做法便是用户按下
                                               #方向键让方块保持移动,直到松开键为止
      if movingLeft and isValidPosition(board,fallingPiece,adjX=-1):
        fallingPiece['x']-=1
      elif movingRight and isValidPosition(board,fallingPiece,adjX=1):
        fallingPiece['x']+=1
      lastMoveSidewaysTime=time.time()
    if movingDown and time.time()-lastMoveDownTime>MOVEDOWNFREQ and isValidPosition(board,fallingPiece,adjY=1):
      fallingPiece['y']+=1
      lastMoveDownTime=time.time()

    if time.time()-lastFallTime>fallFreq:#让方块自动落下如果它到了下落的时候
      #判断方块是否落地
      if not isValidPosition(board,fallingPiece,adjY=1):#方块已落地
        addToBoard(board,fallingPiece)#将落地的方块添加到游戏框中
        score+=removeCompleteLines(board)#判断游戏框中的每一行是否填满,删除填满的一行,返回填满数
        level,fallFreq=calculateLevelAndFallFreq(score)#计算游戏等级以及下落频率
        fallingPiece=None#将当前下落的方块设置为空对象,然后在函数开头重新赋值nextPiece
      else:#方块没有落地,只是把方块移下来
        fallingPiece['y']+=1
        lastFallTime=time.time()
    #把所有东西画在屏幕上
    DISPLAYSURF.fill(BGCOLOR)#设置窗口背景颜色
    drawBoard(board)#将空白数据模板绘画到窗口
    drawStatus(score,level)#将状态栏绘画到窗口
    drawNextPiece(nextPiece)#将下一个方块显示栏画到窗口
    if fallingPiece != None:
      drawPiece(fallingPiece)
    pygame.display.update()
    FPSCLOCK.tick(FPS) 

def getBlankBoard():
  """创建并返回一个新的空白板数据结构,board列表为如下形式:
  [['.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.']
  ,['.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.']
  ,['.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.']
  ,['.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.']
  ,['.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.']
  ,['.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.']
  ,['.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.']
  ,['.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.']
  ,['.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.']
  ,['.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.', '.']]

  与BOARDWIDTH=10#游戏框宽度,BOARDHEIGHT=20#游戏框高度对应
  """
  board=[]
  for i in range(BOARDWIDTH):
    board.append([BLANK]*BOARDHEIGHT)
  return board
def calculateLevelAndFallFreq(score):
  """根据分数,返回玩家所处的关卡,以及掉落的棋子掉落到一个空格前的时间间隔。"""
  level=int(score/10)+1#等级
  fallFreq=0.27-(level*0.02)#下落频率(frequence)
  return level,fallFreq
def getNewPiece():
  """以随机旋转和颜色返回随机的新块"""
  shape=random.choice(list(PIECES.keys()))#shape为S,Z,I....
  newPiece={'shape':shape,
       'rotation':random.randint(0,len(PIECES[shape])-1),#PIECES[shape]为S_SHAPE_TEMPLATE,Z_SHAPE_TEMPLATE,I_SHAPE_TEMPLATE.此处指一类方块的可旋转次数
       'x':int(BOARDWIDTH/2)-int(TEMPLATEWIDTH/2),
       'y':-2,
       'color':random.randint(0,len(COLORS)-1)}
  return newPiece
def checkForQuit():
  """检查退出事件"""
  for event in pygame.event.get(QUIT):#获取所有退出事件
    terminate()#如果存在任何退出事件,则调用终止函数
  for event in pygame.event.get(KEYUP):#获取所有的放开键事件
    if event.key==K_ESCAPE:#如果KEYUP事件是针对Esc键的
      terminate()#终止
    pygame.event.post(event)#将其他KEYUP(非Esc键放开)事件对象放回事件队列

def terminate():
  """退出函数"""
  pygame.quit()
  sys.exit()
def showTextScreen(text):
  """在窗口Surface对象的中央显示大文本,直到按下一个键。用于绘制文本投影,注意:pygame没有提供直接在现有
  表面绘制文本的方法:相反,您必须使用Font.render()来创建文本的图像(表面),然后将此图像blit到另一个表面。

  """
  #做出阴影效果
  titleSurf,titleRect=makeTextObjs(text,BIGFONT,TEXTSHADOWCOLOR)#BIGFONT为main函数中定义,TEXTSHADOWCOLOR为模块中定义,此处文本颜色TEXTSHADOWCOLOR(灰色),下面是TEXTCOLOR(白色)
  titleRect.center=(int(WINDOWWIDTH/2),int(WINDOWHEIGHT / 2))#设置矩形容器的位置,此处需要注意titleRect指的是每个文本Surface对象与其对应的全覆盖矩形容器,此容器在这里不可见
  DISPLAYSURF.blit(titleSurf,titleRect)#在窗口Surface对象画文本Surface对象和与其对应的矩形Surface对象,做出blit这个动作的人是一个Surface类的实例
  #实体文本整体向左上移动3个单位,与上面的阴影效果唯一不同的就是传入的颜色参数
  titleSurf,titleRect=makeTextObjs(text,BIGFONT,TEXTCOLOR)
  titleRect.center=(int(WINDOWWIDTH/2)-3,int(WINDOWHEIGHT/2)-3)
  DISPLAYSURF.blit(titleSurf,titleRect)
  #绘制"Paused"文本下附加的"Press a key to play."文本
  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()#这种方法应该被调用一次。它将计算多少毫秒被调用。如果可选的帧率参数的函数以将延迟保持在低于给
            #定游戏运行时每秒滴答。这有助于限制运行游戏的速度。通过调用clock.tick每帧一次地(40),该程序不会运行超过40帧/秒。
def makeTextObjs(text,font,color):
  """这将创建一个新Surface对象,并在其上呈现指定的文本。"""
  surf=font.render(text,True,color)#参数依次为:要写的文本,布尔值(是否开启抗锯齿功能,True字体较为平滑,),字体颜色,背景色
  return surf,surf.get_rect()#返回一个覆盖整个表面的新矩形(Rect对象,一个矩形的灵活容器)
def isValidPosition(board,piece,adjX=0,adjY=0):
  """如果块在板内且没有碰撞,则返回True,该函数我暂时不理解"""
  for x in range(TEMPLATEWIDTH):
    for y in range(TEMPLATEHEIGHT):
      isAboveBoard=y+piece['y']+adjY<0
      if isAboveBoard or PIECES[piece['shape']][piece['rotation']][y][x]==BLANK:
        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 isOnBoard(x,y):
  return x>=0 and x<BOARDWIDTH and y<BOARDHEIGHT
def addToBoard(board,piece):
  """根据方块的位置,形状,旋转填充的游戏框中"""
  for x in range(TEMPLATEWIDTH):
    for y in range(TEMPLATEHEIGHT):
      if PIECES[piece['shape']][piece['rotation']][y][x]!=BLANK:
        board[x+piece['x']][y+piece['y']]=piece['color']
def removeCompleteLines(board):
  """删除游戏框中所有已完成(Completed)的行,将上面的所有内容向下移动,并返回完整行数。"""
  numLinesRemoved=0#记录删除的行数
  y=BOARDHEIGHT-1#从游戏框底部开始
  while y>=0:
    if isCompleteLine(board,y):#如果填充了这一行,则移开这条线,把所有方块往下一拉
      for pullDownY in range(y,0,-1):
        for x in range(BOARDWIDTH):
          board[x][pullDownY]=board[x][pullDownY-1]
      for x in range(BOARDWIDTH):#将最上面一行设置为空白
        board[x][0]=BLANK
      numLinesRemoved+=1
    else:
      y-=1#继续查看下一行
  return numLinesRemoved

def isCompleteLine(board,y):
  """如果行中填充了没有空格的框,则返回True"""
  for x in range(BOARDWIDTH):
    if board[x][y]==BLANK:
      return False
  return True
def calculateLevelAndFallFreq(score):
  """基于分数,返回玩家所在的关卡。"""
  level=int(score/10)+1
  fallFreq=0.27-(level*0.02)#根据level变量计算方块每下落一个空间所需要的秒数
  return level,fallFreq

def drawBoard(board):
 """将空白数据模板画到窗口Surface对象上"""
 pygame.draw.rect(DISPLAYSURF, BORDERCOLOR, (XMARGIN - 3, TOPMARGIN - 7, (BOARDWIDTH * BOXSIZE) + 8, (BOARDHEIGHT * BOXSIZE) + 8), 5) 

 # fill the background of the board #填充空白数据模板背景颜色
 pygame.draw.rect(DISPLAYSURF, BGCOLOR, (XMARGIN, TOPMARGIN, BOXSIZE * BOARDWIDTH, BOXSIZE * BOARDHEIGHT))
 # draw the individual boxes on the board #在空白数据模板上画出各个盒子
 for x in range(BOARDWIDTH):
 for y in range(BOARDHEIGHT):
  drawBox(x, y, board[x][y]) 

def drawStatus(score,level):
  """在Surface窗口对象上画在游戏框旁边的状态栏"""
  #绘制分数文本
  scoreSurf=BASICFONT.render("Score:%s"%score,True,TEXTCOLOR)#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 drawNextPiece(piece):
  #绘制"下一个"文本
  nextSurf=BASICFONT.render("Next:",True,TEXTCOLOR)
  nextRect=nextSurf.get_rect()
  nextRect.topleft=(WINDOWWIDTH-120,80)
  DISPLAYSURF.blit(nextSurf, nextRect)
  #绘制下一个"方块",pixel中文为像素
  drawPiece(piece,pixelx=WINDOWWIDTH-120, pixely=100)
def drawPiece(piece,pixelx=None, pixely=None):
  shapeToDraw=PIECES[piece['shape']][piece['rotation']]
  if pixelx==None and pixely==None:
    pixelx,pixely=convertToPixelCoords(piece['x'], piece['y'])#如果没有指定pixelx & pixely,则使用存储在片段数据结构中的位置
  #画出组成这个方块的每一个小方块
  for x in range(TEMPLATEWIDTH):
    for y in range(TEMPLATEHEIGHT):
      if shapeToDraw[y][x] != BLANK:
        drawBox(None,None,piece['color'],pixelx + (x * BOXSIZE), pixely + (y * BOXSIZE))

def convertToPixelCoords(boxx,boxy):
  """将board上给定的xy坐标转换为屏幕上位置的xy坐标,convert:转换,pixel:像素,coords:坐标"""
  return (XMARGIN+(boxx*BOXSIZE)),(TOPMARGIN+(boxy * BOXSIZE))

def drawBox(boxx,boxy,color,pixelx=None,pixely=None):
  """在黑板上的xy坐标处画一个盒子(每个四重奏有四个盒子)。或者,如果指定了pixelx & pixely,则绘制到存储在pixelx & pixely中的像素坐标(这用于“下一个”块)"""
  if color==BLANK:
    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))
  pygame.draw.rect(DISPLAYSURF, LIGHTCOLORS[color], (pixelx + 1, pixely + 1, BOXSIZE - 4, BOXSIZE - 4))

def checkForKeyPress():
  """遍历事件队列,寻找KEYUP事件,获取KEYDOWN事件,将它们从事件队列中删除"""
  checkForQuit()
  for event in pygame.event.get([KEYDOWN, KEYUP]):
    if event.type!=KEYDOWN:
      continue
    return event.key
  return None
if __name__=='__main__':
  main()

运行结果:

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们。

(0)

相关推荐

  • pygame实现俄罗斯方块游戏(基础篇3)

    上一章请点击查看:pygame实现俄罗斯方块游戏(基础篇2) 现在继续 一.给每个方块设置不同的颜色 根据代码这里可以判断正在下落的方块在那些Block子类里加一个属性最合适,而已经落下的方块颜色管理最合适的地方应该是修改在Panel类里的rect_arr Block子类里的修改比较简单,以TBlock类为例,在__init__函数加一行 self.color=(255,0,0) 在Panel的paint函数里将代码 # 绘制正在落下的方块 if self.move_block: for rec

  • pygame实现俄罗斯方块游戏(AI篇1)

    上次更新到pygame实现俄罗斯方块游戏(基础篇3) 现在继续 一.定义玩家类 定义玩家类是为了便于进行手动和机器模式或各种不同机器人模式的混合使用,增加代码扩展性. 可以先定义一个玩家基类 class Player(object): auto_mode=False # 是否是自动模式,自动模式应当不响应键盘操作 def __init__(self): pass def run(self): # 进行操作 pass 手动类和机器类继承自Player类 class HumanPlayer(Play

  • Python使用pygame模块编写俄罗斯方块游戏的代码实例

    文章先介绍了关于俄罗斯方块游戏的几个术语. 边框--由10*20个空格组成,方块就落在这里面. 盒子--组成方块的其中小方块,是组成方块的基本单元. 方块--从边框顶掉下的东西,游戏者可以翻转和改变位置.每个方块由4个盒子组成. 形状--不同类型的方块.这里形状的名字被叫做T, S, Z ,J, L, I , O.如下图所示: 模版--用一个列表存放形状被翻转后的所有可能样式.全部存放在变量里,变量名字如S_SHAPE_TEMPLATE or J_SHAPE_TEMPLATE 着陆--当一个方块

  • 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个方

  • python和pygame实现简单俄罗斯方块游戏

    本文为大家分享了python实现俄罗斯方块游戏的具体代码,供大家参考,具体内容如下 Github:Tetris 代码: # -*- coding:utf-8 -*- import pygame, sys, random, copy from pygame.locals import * pygame.init() CubeWidth = 40 CubeHeight = 40 Column = 10 Row = 20 ScreenWidth = CubeWidth * (Column + 5) S

  • pygame实现俄罗斯方块游戏(AI篇2)

    继续pygame实现俄罗斯方块游戏(AI篇1)的代码更新 一.消除后才做评价 上一篇我们是对方块落下的位置和落下后出来的空洞进行了评价,但是这些评价都是没有计算消除的,以至于机器人现在不会考虑去进行那些完全不会留下空洞的消除,比如下面这种消除. 但我们知道这种消除是不会产生空洞的. 所以我们要在计算评价的时候最好计算消除以后的评价. 我们只要在Matrix的函数里加一个do_clear函数来进行消除 def do_clear(self): for i in range(self.rows-1,-

  • pygame实现俄罗斯方块游戏(基础篇2)

    接上章<pygame实现俄罗斯方块游戏(基础篇1)>继续写俄罗斯方块游戏 五.计算方块之间的碰撞 在Panel类里增加函数 def check_overlap(self, diffx, diffy): for x,y in self.moving_block.get_rect_arr(): for rx,ry in self.rect_arr: if x+diffx==rx and y+diffy==ry: return True return False 修改move_block函数的判断,

  • pygame实现俄罗斯方块游戏(基础篇1)

    本文实例为大家分享了pygame实现俄罗斯方块游戏的具体代码,基础的第一篇,供大家参考,具体内容如下 一.初始界面 之前的游戏都比较简单,所以代码都是面向过程的写法,这次游戏后面可能会写比较复杂(比如人机对战.联机对战.使用道具对战等),这次面向对象一点来写这个项目. 游戏的窗口设计一个专门的Panel类便于负责单个游戏窗口的管理控制. 游戏主窗口按每个方块30像素,那么宽3010=300,高是3020=600 # -*- coding=utf-8 -*- import random impor

  • pygame实现俄罗斯方块游戏(对战篇1)

    上篇更新到pygame实现俄罗斯方块游戏(AI篇2),原本应该继续做优化,不过考虑到完成游戏完整性,这张就先把对战做好. 一.对战的方块管理 定义一个BlockManage管理对战的方块 class BlockManage(object): pnum=1 blocks = [] def __init__(self,pnum): self.pnum=pnum self.blocks=[[] for i in range(self.pnum)] def get_block(self, pid=0):

  • pygame库实现俄罗斯方块小游戏

    本文实例为大家分享了pygame库实现俄罗斯方块小游戏的具体代码,供大家参考,具体内容如下 import random,time,pygame,sys from pygame.locals import *#导pygame内定义的一些常量 FPS=25#每秒传输帧数(刷新率),此处一秒内在屏幕上连续投射出24张静止画面 WINDOWWIDTH=640#窗口宽 WINDOWHEIGHT=480#窗口高 BOXSIZE=20#游戏框大小 BOARDWIDTH=10#游戏框宽度 BOARDHEIGHT

  • 使用PyInstaller将Pygame库编写的小游戏程序打包为exe文件

    一.安装Pyinstaller 环境:python3.6.window10 注意事项: python64位版本打包的exe,只能在64位操作系统使用 打包文件夹和文件的名称不能用中文 pygame打包是里面的字体要改成"arial"格式. pygame.font.SysFont("宋体", 32) 32)  换成 pygame.font.SysFont('arial',32) 1.直接安装 pip命令安装:pip install Pyinstaller 安装成功后会

  • 使用PyInstaller将Pygame库编写的小游戏程序打包为exe文件及出现问题解决方法

    下面看下通过Pyinstaller打包Pygame库写的小游戏程序出现的问题解决方法 # -基于Python的Pygame库的GUI游戏 游戏内容是通过飞船发射子弹来射击外星人 空格键为开火,左右方向键移动,并设立了 不同关卡. 使用说明: 开发环境,游戏直接运行alien_invasion.exe即可,也可在具有Python3环境下运行alien_invasion.py 练习环境: Python:3.5.4 64位 pyinstall:3.3.1 pyinstall使用: pyinstalle

  • 详解使用PyInstaller将Pygame库编写的小游戏程序打包为exe文件

    一.安装Pyinstaller 环境:python3.6.window10 注意事项: python64位版本打包的exe,只能在64位操作系统使用 打包文件夹和文件的名称不能用中文 pygame打包是里面的字体要改成"arial"格式. pygame.font.SysFont("宋体", 32) 32)  换成 pygame.font.SysFont('arial',32) 1.直接安装 pip命令安装:pip install Pyinstaller 安装成功后会

  • 使用pygame编写Flappy bird小游戏

    0. 最终效果: 1. 搭建一个最小框架 1.1 需要的函数 初始化所有导入的pygame模块. pygame.init() 生成一个窗口.返回的是一个surface对象.通过resolution设置窗口大小,flags代表扩展选项,depth代表设置颜色,但不建议设置. pygame.display.set_mode((resolution =(0,0),flags = 0,depth = 0)) 设置窗口标题. pygame.display.set_caption("Flappy bird_

  • 如何利用pygame实现打飞机小游戏

    效果预览 最近上实训课,写了这么一个简单的小玩意.运行效果如下:(这个是有音效的,不过这个展示不了因为这里只能上传GIF) 项目结构 游戏对屏幕的适配 由于我使用的是笔记本所以对于屏幕来说是进行了缩放的,例如,我的笔记本缩放了125% 但是问题在于我们的pygame和其他的一些库例如selenium其实是按照100%显示的像素来算的.所以这个时候我们需要进行一个换算. 这个也好算: 当前显示像素比 = 100%显示像素比 X 缩放比 我们只需要换算一下就好了.这里我定义了一个类,来实现我们的需求

  • C语言实现俄罗斯方块小游戏

    C语言实现俄罗斯方块小游戏的制作代码,具体内容如下 #include <stdio.h> #include <stdlib.h> #include <unistd.h> #define TTY_PATH "/dev/tty" #define STTY_ON "stty raw -echo -F" #define STTY_OFF "stty -raw echo -F" int map[21][14]; char

  • python+pygame实现坦克大战小游戏的示例代码(可以自定义子弹速度)

    python+pygame实现坦克大战小游戏-可以自定义子弹速度: 运行环境–python3.7.pycharm: 源码需要请:点赞留言邮箱: 正常版子弹速度: 普通速度版 加速版子弹速度: 子弹加速版 另外还有多种道具,支持两人一起玩.main()方法如下: def main(): pygame.init() pygame.mixer.init() resolution = 630, 630 screen = pygame.display.set_mode(resolution) pygame

  • C++实现俄罗斯方块小游戏

    本文实例为大家分享了C++实现俄罗斯方块小游戏的具体代码,供大家参考,具体内容如下 操作说明: D F:左右旋转 J  L:左右移动 E(一堆键都行): 加快下落速度 空格: 开始游戏 与 一落到底 上代码! #include <cstdio> #include <cstdlib> #include <cstring> #include <windows.h> #include <ctime> #include <conio.h> #

  • 基于pygame实现贪吃蛇小游戏示例

    目录 游戏截图 引入库 初始化模型 获取键盘事件 移动贪吃蛇 吃食物逻辑 碰撞到自身逻辑 结束游戏 显示文字函数 完整代码 游戏截图 引入库 import copy import random import sys import pygame 初始化模型 # 蛇模型 snake_list = [[10, 10]] # 食物的模型 x = random.randint(10, 490) y = random.randint(10, 490) food_point = [x, y] food_r,

随机推荐