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

开心消消乐：Python_checkforgem在python中的作用

作者：羊村懒王 | 2024-06-06 04:37:42

赞

踩

checkforgem在python中的作用
  1. """
  2. 用到以下键:
  3.    “x”和“y”——游戏在棋盘上的位置。0,0是左上角。
  4.                    还有一个y可以设置的ROWABOVEBOARD行，表示它在棋盘上。
  5.                    
  6.            方向——四个常量变量之一，上、下、左、右，游戏前进的方向。
  7.            
  8.     'imageNum' —— GEMIMAGES的整数索引，用于表示这个游戏用哪个图像。
  9. """
  10. import random, time, pygame, sys, copy
  11. from pygame.locals import *
  12.  
  13. FPS = 30 # 每30秒更新屏幕
  14. WINDOWWIDTH = 600  # 窗口宽度
  15. WINDOWHEIGHT = 600 # 窗口高度
  16.  
  17. BOARDWIDTH = 8 # 8列
  18. BOARDHEIGHT = 8 # 8行
  19. GEMIMAGESIZE = 64 # 每小格的宽度和高度
  20.  
  21. NUMGEMIMAGES = 6    # 图片的类型，.png格式，从0开始命名 gem0.png
  22. assert NUMGEMIMAGES >= 5 # 最少5种图片
  23.  
  24. NUMMATCHSOUNDS = 6  # 音乐的类型，.wav格式,从0开始命名 match0.wav
  25.  
  26. MOVERATE = 25 #1到100，更大的num意味着更快的动作
  27. DEDUCTSPEED = 0.8 # 每减少1分扣减DEDUCTSPEED秒。
  28.  
  29. #             R    G    B
  30. PURPLE    = (255,   0, 255)
  31. LIGHTBLUE = (255, 202, 255)
  32. BLUE      = ( 77, 219, 255)
  33. RED       = (255, 100, 100)
  34. BLACK     = (  0,   0,   0)
  35. BROWN     = ( 85,  65,   0)
  36. HIGHLIGHTCOLOR = PURPLE # 游戏边界的颜色
  37. BGCOLOR = LIGHTBLUE # 屏幕上的背景色
  38. GRIDCOLOR = BLUE # 游戏板的颜色
  39. GAMEOVERCOLOR = RED #“游戏结束”文字的颜色
  40. GAMEOVERBGCOLOR = BLACK # “游戏结束”文字的颜色
  41. SCORECOLOR = BROWN # 得分文本的颜色
  42.  
  43. # 从线到边的距离
  44. # 它被多次使用，因此在这里计算一次并存储在变量中
  45. XMARGIN = int((WINDOWWIDTH - GEMIMAGESIZE * BOARDWIDTH) / 2)
  46. YMARGIN = int((WINDOWHEIGHT - GEMIMAGESIZE * BOARDHEIGHT) / 2)
  47.  
  48. # 方向常数
  49. UP = 'up'
  50. DOWN = 'down'
  51. LEFT = 'left'
  52. RIGHT = 'right'
  53.  
  54. EMPTY_SPACE = -1 # 一个任意的非正值
  55. ROWABOVEBOARD = 'row above board' # 一个任意的非整数值
  56.  
  57. def main():
  58.     global FPSCLOCK, DISPLAYSURF, GEMIMAGES, GAMESOUNDS, BASICFONT, BOARDRECTS
  59.  
  60.     # 初始设置
  61.     pygame.init()
  62.     FPSCLOCK = pygame.time.Clock()
  63.     DISPLAYSURF = pygame.display.set_mode((WINDOWWIDTH, WINDOWHEIGHT))
  64.     pygame.display.set_caption('Gemgem')
  65.     BASICFONT = pygame.font.Font('freesansbold.ttf', 36)
  66.     
  67.     # 加载图片
  68.     GEMIMAGES = []
  69.     for i in range(1, NUMGEMIMAGES+1):
  70.         gemImage = pygame.image.load('gem%s.png' % i)
  71.         if gemImage.get_size() != (GEMIMAGESIZE, GEMIMAGESIZE):
  72.             gemImage = pygame.transform.smoothscale(gemImage, (GEMIMAGESIZE, GEMIMAGESIZE))
  73.         GEMIMAGES.append(gemImage)
  74.  
  75.     # 加载声音
  76.     GAMESOUNDS = {}
  77.     GAMESOUNDS['bad swap'] = pygame.mixer.Sound('badswap.wav')
  78.     GAMESOUNDS['match'] = []
  79.     for i in range(NUMMATCHSOUNDS):
  80.         GAMESOUNDS['match'].append(pygame.mixer.Sound('match%s.wav' % i))
  81.  
  82.     
  83.     # 创建pygame，矩形对象，用于为每个板空间执行板坐标到像素坐标的转换
  84.     BOARDRECTS = []
  85.     for x in range(BOARDWIDTH):
  86.         BOARDRECTS.append([])
  87.         for y in range(BOARDHEIGHT):
  88.             r = pygame.Rect((XMARGIN + (x * GEMIMAGESIZE),
  89.                              YMARGIN + (y * GEMIMAGESIZE),
  90.                              GEMIMAGESIZE,
  91.                              GEMIMAGESIZE))
  92.             BOARDRECTS[x].append(r)
  93.  
  94.     while True:
  95.         runGame()
  96.  
  97.  
  98. def runGame():
  99.     # 运行游戏，当游戏结束时，这个函数返回
  100.  
  101.     # 初始化面板
  102.     gameBoard = getBlankBoard()
  103.     score = 0
  104.     fillBoardAndAnimate(gameBoard, [], score) # Drop the initial gems.
  105.  
  106.     # 初始化变量
  107.     firstSelectedGem = None
  108.     lastMouseDownX = None
  109.     lastMouseDownY = None
  110.     gameIsOver = False
  111.     lastScoreDeduction = time.time()
  112.     clickContinueTextSurf = None
  113.  
  114.     while True: # 主要游戏循环
  115.         clickedSpace = None
  116.         for event in pygame.event.get(): # 事件处理循环
  117.             if event.type == QUIT or (event.type == KEYUP and event.key == K_ESCAPE):
  118.                 pygame.quit()
  119.                 sys.exit()
  120.             elif event.type == KEYUP and event.key == K_BACKSPACE:
  121.                 return # start a new game
  122.  
  123.             elif event.type == MOUSEBUTTONUP:
  124.                 if gameIsOver:
  125.                     return # 游戏结束后，点击开始一个新的游戏
  126.  
  127.                 if event.pos == (lastMouseDownX, lastMouseDownY):
  128.                     # 此事件是鼠标单击，而不是鼠标拖动结束
  129.                     clickedSpace = checkForGemClick(event.pos)
  130.                 else:
  131.                     # 这是鼠标拖动结束
  132.                     firstSelectedGem = checkForGemClick((lastMouseDownX, lastMouseDownY))
  133.                     clickedSpace = checkForGemClick(event.pos)
  134.                     if not firstSelectedGem or not clickedSpace:
  135.                         # 如果不是有效拖动的一部分，取消选中这两个
  136.                         firstSelectedGem = None
  137.                         clickedSpace = None
  138.             elif event.type == MOUSEBUTTONDOWN:
  139.                 # 这是鼠标点击或拖动的开始
  140.                 lastMouseDownX, lastMouseDownY = event.pos
  141.  
  142.         if clickedSpace and not firstSelectedGem:
  143.             # 这是第一次点击宝石
  144.             firstSelectedGem = clickedSpace
  145.         elif clickedSpace and firstSelectedGem:
  146.             #点击并选择了两个宝石，交换。
  147.             firstSwappingGem, secondSwappingGem = getSwappingGems(gameBoard, firstSelectedGem, clickedSpace)
  148.             if firstSwappingGem == None and secondSwappingGem == None:
  149.                 # 如果两者都不是，那么宝石就不是相邻的
  150.                 firstSelectedGem = None # 取消选择第一块宝石
  151.                 continue
  152.  
  153.             # 在屏幕上显示交换动画
  154.             boardCopy = getBoardCopyMinusGems(gameBoard, (firstSwappingGem, secondSwappingGem))
  155.             animateMovingGems(boardCopy, [firstSwappingGem, secondSwappingGem], [], score)
  156.  
  157.             # 交换在面板上的数据结构上的宝石
  158.             gameBoard[firstSwappingGem['x']][firstSwappingGem['y']] = secondSwappingGem['imageNum']
  159.             gameBoard[secondSwappingGem['x']][secondSwappingGem['y']] = firstSwappingGem['imageNum']
  160.  
  161.             # 看看这是不是一个匹配的动作
  162.             matchedGems = findMatchingGems(gameBoard)
  163.             if matchedGems == []:
  164.                 # 不是一个匹配的移动;交换宝石
  165.                 GAMESOUNDS['bad swap'].play()
  166.                 animateMovingGems(boardCopy, [firstSwappingGem, secondSwappingGem], [], score)
  167.                 gameBoard[firstSwappingGem['x']][firstSwappingGem['y']] = firstSwappingGem['imageNum']
  168.                 gameBoard[secondSwappingGem['x']][secondSwappingGem['y']] = secondSwappingGem['imageNum']
  169.             else:
  170.                 # 是一个匹配的移动
  171.                 scoreAdd = 0
  172.                 while matchedGems != []:
  173.                     # 删除匹配的宝石，然后拉下板
  174.  
  175.                     # points是一个dicts列表，它告诉fillBoardAndAnimate()在屏幕上显示文本以显示玩家获得多少点数。
  176.                     # 点数是一个列表，因为如果玩家得到多个匹配，那么就会出现多个点数文本。
  177.                     
  178.                     points = []
  179.                     for gemSet in matchedGems:
  180.                         scoreAdd += (10 + (len(gemSet) - 3) * 10)
  181.                         for gem in gemSet:
  182.                             gameBoard[gem[0]][gem[1]] = EMPTY_SPACE
  183.                         points.append({'points': scoreAdd,
  184.                                        'x': gem[0] * GEMIMAGESIZE + XMARGIN,
  185.                                        'y': gem[1] * GEMIMAGESIZE + YMARGIN})
  186.                     random.choice(GAMESOUNDS['match']).play()
  187.                     score += scoreAdd
  188.  
  189.                     # 掉落新的宝石
  190.                     fillBoardAndAnimate(gameBoard, points, score)
  191.  
  192.                     # 检查是否有新的匹配
  193.                     matchedGems = findMatchingGems(gameBoard)
  194.             firstSelectedGem = None
  195.  
  196.             if not canMakeMove(gameBoard):
  197.                 gameIsOver = True
  198.  
  199.         # 画出面板
  200.         DISPLAYSURF.fill(BGCOLOR)
  201.         drawBoard(gameBoard)
  202.         if firstSelectedGem != None:
  203.             highlightSpace(firstSelectedGem['x'], firstSelectedGem['y'])
  204.         if gameIsOver:
  205.             if clickContinueTextSurf == None:
  206.                 #只呈现文本一次。在以后的迭代中，只需使用clickContinueTextSurf中已经存在的Surface对象
  207.                 clickContinueTextSurf = BASICFONT.render('Final Score: %s (Click to continue)' % (score), 1, GAMEOVERCOLOR, GAMEOVERBGCOLOR)
  208.                 clickContinueTextRect = clickContinueTextSurf.get_rect()
  209.                 clickContinueTextRect.center = int(WINDOWWIDTH / 2), int(WINDOWHEIGHT / 2)
  210.             DISPLAYSURF.blit(clickContinueTextSurf, clickContinueTextRect)
  211.         elif score > 0 and time.time() - lastScoreDeduction > DEDUCTSPEED:
  212.             # 分数随时间而下降
  213.             score -= 1
  214.             lastScoreDeduction = time.time()
  215.         drawScore(score)
  216.         pygame.display.update()
  217.         FPSCLOCK.tick(FPS)
  218.  
  219.  
  220. def getSwappingGems(board, firstXY, secondXY):
  221.     # 如果两个宝石在(X, Y)坐标处的宝石相邻，那么它们的“方向”键被设置为适当的方向值，以便彼此交换
  222.     # 否则，返回(None, None)
  223.     firstGem = {'imageNum': board[firstXY['x']][firstXY['y']],
  224.                 'x': firstXY['x'],
  225.                 'y': firstXY['y']}
  226.     secondGem = {'imageNum': board[secondXY['x']][secondXY['y']],
  227.                  'x': secondXY['x'],
  228.                  'y': secondXY['y']}
  229.     highlightedGem = None
  230.     if firstGem['x'] == secondGem['x'] + 1 and firstGem['y'] == secondGem['y']:
  231.         firstGem['direction'] = LEFT
  232.         secondGem['direction'] = RIGHT
  233.     elif firstGem['x'] == secondGem['x'] - 1 and firstGem['y'] == secondGem['y']:
  234.         firstGem['direction'] = RIGHT
  235.         secondGem['direction'] = LEFT
  236.     elif firstGem['y'] == secondGem['y'] + 1 and firstGem['x'] == secondGem['x']:
  237.         firstGem['direction'] = UP
  238.         secondGem['direction'] = DOWN
  239.     elif firstGem['y'] == secondGem['y'] - 1 and firstGem['x'] == secondGem['x']:
  240.         firstGem['direction'] = DOWN
  241.         secondGem['direction'] = UP
  242.     else:
  243.         # 这些宝石不相邻，不能交换
  244.         return None, None
  245.     return firstGem, secondGem
  246.  
  247.  
  248. def getBlankBoard():
  249.     # 创建并返回空白板数据结构
  250.     board = []
  251.     for x in range(BOARDWIDTH):
  252.         board.append([EMPTY_SPACE] * BOARDHEIGHT)
  253.     return board
  254.  
  255.  
  256. def canMakeMove(board):
  257.     # 如果棋盘处于可以对其进行匹配移动的状态，则返回True。否则返回假
  258.  
  259.     # oneOffPatterns中的模式表示gem，它们的配置方式是只需要移动一次就可以创建一个三元组
  260.     
  261.     oneOffPatterns = (((0,1), (1,0), (2,0)),
  262.                       ((0,1), (1,1), (2,0)),
  263.                       ((0,0), (1,1), (2,0)),
  264.                       ((0,1), (1,0), (2,1)),
  265.                       ((0,0), (1,0), (2,1)),
  266.                       ((0,0), (1,1), (2,1)),
  267.                       ((0,0), (0,2), (0,3)),
  268.                       ((0,0), (0,1), (0,3)))
  269.  
  270.     # x和y变量在黑板上的每个空间上迭代。如果我们使用+表示当前在黑板上迭代的空间，那么这个模式:(0,1)，(1,0)，(2,0))表示相同的
  271.     
  272.     # 宝石是这样设置的:
  273.     #
  274.     #     +A
  275.     #     B
  276.     #     C
  277.     #
  278.     # 即，gem A与+的偏移量为(0,1)，gem B与(1,0)的偏移量为(2,0)。在这种情况下，gem A可以被交换到左边以形成一个垂直的三排三连音
  279.     #
  280.     # 有八种可能的方式使宝石远离形成一个三元组，因此oneOffPattern有8种模式
  281.  
  282.     for x in range(BOARDWIDTH):
  283.         for y in range(BOARDHEIGHT):
  284.             for pat in oneOffPatterns:
  285.                 # 检查每个可能的模式“匹配在下一步”，看看是否可以做一个可能的行动
  286.                 
  287.                 if (getGemAt(board, x+pat[0][0], y+pat[0][1]) == \
  288.                     getGemAt(board, x+pat[1][0], y+pat[1][1]) == \
  289.                     getGemAt(board, x+pat[2][0], y+pat[2][1]) != None) or \
  290.                    (getGemAt(board, x+pat[0][1], y+pat[0][0]) == \
  291.                     getGemAt(board, x+pat[1][1], y+pat[1][0]) == \
  292.                     getGemAt(board, x+pat[2][1], y+pat[2][0]) != None):
  293.                     return True # return True the first time you find a pattern
  294.     return False
  295.  
  296.  
  297. def drawMovingGem(gem, progress):
  298.     # 画一个宝石沿着它的“方向”键指示的方向滑动。进度参数是从0(刚开始)到100(幻灯片完成)的数字
  299.     
  300.     movex = 0
  301.     movey = 0
  302.     progress *= 0.01
  303.  
  304.     if gem['direction'] == UP:
  305.         movey = -int(progress * GEMIMAGESIZE)
  306.     elif gem['direction'] == DOWN:
  307.         movey = int(progress * GEMIMAGESIZE)
  308.     elif gem['direction'] == RIGHT:
  309.         movex = int(progress * GEMIMAGESIZE)
  310.     elif gem['direction'] == LEFT:
  311.         movex = -int(progress * GEMIMAGESIZE)
  312.  
  313.     basex = gem['x']
  314.     basey = gem['y']
  315.     if basey == ROWABOVEBOARD:
  316.         basey = -1
  317.  
  318.     pixelx = XMARGIN + (basex * GEMIMAGESIZE)
  319.     pixely = YMARGIN + (basey * GEMIMAGESIZE)
  320.     r = pygame.Rect( (pixelx + movex, pixely + movey, GEMIMAGESIZE, GEMIMAGESIZE) )
  321.     DISPLAYSURF.blit(GEMIMAGES[gem['imageNum']], r)
  322.  
  323.  
  324. def pullDownAllGems(board):
  325.     # 将木板上的宝石拉到底部，以填补任何空缺
  326.     for x in range(BOARDWIDTH):
  327.         gemsInColumn = []
  328.         for y in range(BOARDHEIGHT):
  329.             if board[x][y] != EMPTY_SPACE:
  330.                 gemsInColumn.append(board[x][y])
  331.         board[x] = ([EMPTY_SPACE] * (BOARDHEIGHT - len(gemsInColumn))) + gemsInColumn
  332.  
  333.  
  334. def getGemAt(board, x, y):
  335.     if x < 0 or y < 0 or x >= BOARDWIDTH or y >= BOARDHEIGHT:
  336.         return None
  337.     else:
  338.         return board[x][y]
  339.  
  340.  
  341. def getDropSlots(board):
  342.     # 为每个列创建一个“drop slot”，并用该列缺少的一些gem填充该slot。这个函数假设宝石的重力已经下降
  343.     
  344.     boardCopy = copy.deepcopy(board)
  345.     pullDownAllGems(boardCopy)
  346.  
  347.     dropSlots = []
  348.     for i in range(BOARDWIDTH):
  349.         dropSlots.append([])
  350.  
  351.     # 计算黑板上每一列的空格数
  352.     for x in range(BOARDWIDTH):
  353.         for y in range(BOARDHEIGHT-1, -1, -1): # 从底部开始，向上
  354.             if boardCopy[x][y] == EMPTY_SPACE:
  355.                 possibleGems = list(range(len(GEMIMAGES)))
  356.                 for offsetX, offsetY in ((0, -1), (1, 0), (0, 1), (-1, 0)):
  357.                     # 缩小可能的宝石的范围，我们应该把它们放在空白的地方，这样当它们掉落的时候，我们就不会把两个相同的宝石放在一起
  358.                     neighborGem = getGemAt(boardCopy, x + offsetX, y + offsetY)
  359.                     if neighborGem != None and neighborGem in possibleGems:
  360.                         possibleGems.remove(neighborGem)
  361.  
  362.                 newGem = random.choice(possibleGems)
  363.                 boardCopy[x][y] = newGem
  364.                 dropSlots[x].append(newGem)
  365.     return dropSlots
  366.  
  367.  
  368. def findMatchingGems(board):
  369.     gemsToRemove = [] # a list of lists of gems in matching triplets that should be removed
  370.     boardCopy = copy.deepcopy(board)
  371.  
  372.     # 循环遍历每个空间，检查3个相邻的相同的宝石
  373.     for x in range(BOARDWIDTH):
  374.         for y in range(BOARDHEIGHT):
  375.             # 寻找水平匹配
  376.             if getGemAt(boardCopy, x, y) == getGemAt(boardCopy, x + 1, y) == getGemAt(boardCopy, x + 2, y) and getGemAt(boardCopy, x, y) != EMPTY_SPACE:
  377.                 targetGem = boardCopy[x][y]
  378.                 offset = 0
  379.                 removeSet = []
  380.                 while getGemAt(boardCopy, x + offset, y) == targetGem:
  381.                     #继续检查一行中是否有超过3个gem
  382.                     removeSet.append((x + offset, y))
  383.                     boardCopy[x + offset][y] = EMPTY_SPACE
  384.                     offset += 1
  385.                 gemsToRemove.append(removeSet)
  386.  
  387.             # 寻找垂直匹配
  388.             if getGemAt(boardCopy, x, y) == getGemAt(boardCopy, x, y + 1) == getGemAt(boardCopy, x, y + 2) and getGemAt(boardCopy, x, y) != EMPTY_SPACE:
  389.                 targetGem = boardCopy[x][y]
  390.                 offset = 0
  391.                 removeSet = []
  392.                 while getGemAt(boardCopy, x, y + offset) == targetGem:
  393.                     # 继续检查，以防一行中有超过3个gem
  394.                     removeSet.append((x, y + offset))
  395.                     boardCopy[x][y + offset] = EMPTY_SPACE
  396.                     offset += 1
  397.                 gemsToRemove.append(removeSet)
  398.  
  399.     return gemsToRemove
  400.  
  401.  
  402. def highlightSpace(x, y):
  403.     pygame.draw.rect(DISPLAYSURF, HIGHLIGHTCOLOR, BOARDRECTS[x][y], 4)
  404.  
  405.  
  406. def getDroppingGems(board):
  407.     #找到所有在他们下面有一个空空间的宝石
  408.     boardCopy = copy.deepcopy(board)
  409.     droppingGems = []
  410.     for x in range(BOARDWIDTH):
  411.         for y in range(BOARDHEIGHT - 2, -1, -1):
  412.             if boardCopy[x][y + 1] == EMPTY_SPACE and boardCopy[x][y] != EMPTY_SPACE:
  413.                 # 如果不是空的，这个空间会下降，但是下面的空间是空的
  414.                 droppingGems.append( {'imageNum': boardCopy[x][y], 'x': x, 'y': y, 'direction': DOWN} )
  415.                 boardCopy[x][y] = EMPTY_SPACE
  416.     return droppingGems
  417.  
  418.  
  419. def animateMovingGems(board, gems, pointsText, score):
  420.     # pointsText是一个带有'x'、'y'和'points'键的字典
  421.     progress = 0 #进展在0代表开始，100代表完成
  422.     while progress < 100: # 动画循环
  423.         DISPLAYSURF.fill(BGCOLOR)
  424.         drawBoard(board)
  425.         for gem in gems: # 布置每一个宝石
  426.             drawMovingGem(gem, progress)
  427.         drawScore(score)
  428.         for pointText in pointsText:
  429.             pointsSurf = BASICFONT.render(str(pointText['points']), 1, SCORECOLOR)
  430.             pointsRect = pointsSurf.get_rect()
  431.             pointsRect.center = (pointText['x'], pointText['y'])
  432.             DISPLAYSURF.blit(pointsSurf, pointsRect)
  433.  
  434.         pygame.display.update()
  435.         FPSCLOCK.tick(FPS)
  436.         progress += MOVERATE # 为下一帧的动画进行更多的进展
  437.  
  438.  
  439. def moveGems(board, movingGems):
  440.     # 移动宝石是一个带有键x, y，方向，imageNum的字典列表
  441.     for gem in movingGems:
  442.         if gem['y'] != ROWABOVEBOARD:
  443.             board[gem['x']][gem['y']] = EMPTY_SPACE
  444.             movex = 0
  445.             movey = 0
  446.             if gem['direction'] == LEFT:
  447.                 movex = -1
  448.             elif gem['direction'] == RIGHT:
  449.                 movex = 1
  450.             elif gem['direction'] == DOWN:
  451.                 movey = 1
  452.             elif gem['direction'] == UP:
  453.                 movey = -1
  454.             board[gem['x'] + movex][gem['y'] + movey] = gem['imageNum']
  455.         else:
  456.             # 宝石位于板的上方(新的宝石来自板的上方)
  457.             board[gem['x']][0] = gem['imageNum'] # move to top row
  458.  
  459.  
  460. def fillBoardAndAnimate(board, points, score):
  461.     dropSlots = getDropSlots(board)
  462.     while dropSlots != [[]] * BOARDWIDTH:
  463.         # 只要有更多的宝石掉落，做掉落的动画
  464.         movingGems = getDroppingGems(board)
  465.         for x in range(len(dropSlots)):
  466.             if len(dropSlots[x]) != 0:
  467.                 # 使每个槽中最低的宝石开始向下移动
  468.                 movingGems.append({'imageNum': dropSlots[x][0], 'x': x, 'y': ROWABOVEBOARD, 'direction': DOWN})
  469.  
  470.         boardCopy = getBoardCopyMinusGems(board, movingGems)
  471.         animateMovingGems(boardCopy, movingGems, points, score)
  472.         moveGems(board, movingGems)
  473.  
  474.         # 通过删除之前的最低的gem，从下拉槽中删除下一行gems是最低的
  475.         
  476.         for x in range(len(dropSlots)):
  477.             if len(dropSlots[x]) == 0:
  478.                 continue
  479.             board[x][0] = dropSlots[x][0]
  480.             del dropSlots[x][0]
  481.  
  482.  
  483. def checkForGemClick(pos):
  484.     # 查看鼠标点击是否在面板上
  485.     for x in range(BOARDWIDTH):
  486.         for y in range(BOARDHEIGHT):
  487.             if BOARDRECTS[x][y].collidepoint(pos[0], pos[1]):
  488.                 return {'x': x, 'y': y}
  489.     return None # Click不在面板上
  490.  
  491.  
  492. def drawBoard(board):
  493.     for x in range(BOARDWIDTH):
  494.         for y in range(BOARDHEIGHT):
  495.             pygame.draw.rect(DISPLAYSURF, GRIDCOLOR, BOARDRECTS[x][y], 1)
  496.             gemToDraw = board[x][y]
  497.             if gemToDraw != EMPTY_SPACE:
  498.                 DISPLAYSURF.blit(GEMIMAGES[gemToDraw], BOARDRECTS[x][y])
  499.  
  500.  
  501. def getBoardCopyMinusGems(board, gems):
  502.     # 创建并返回已传递的板数据结构的副本，并从其中删除“gems”列表中的gems
  503.     # Gems是一个dicts列表，带有键x, y，方向，imageNum
  504.  
  505.     boardCopy = copy.deepcopy(board)
  506.  
  507.     # 从面板板数据结构拷贝中删除一些宝石
  508.     for gem in gems:
  509.         if gem['y'] != ROWABOVEBOARD:
  510.             boardCopy[gem['x']][gem['y']] = EMPTY_SPACE
  511.     return boardCopy
  512.  
  513.  
  514. def drawScore(score):
  515.     scoreImg = BASICFONT.render(str(score), 1, SCORECOLOR)
  516.     scoreRect = scoreImg.get_rect()
  517.     scoreRect.bottomleft = (10, WINDOWHEIGHT - 6)
  518.     DISPLAYSURF.blit(scoreImg, scoreRect)
  519.  
  520.  
  521. if __name__ == '__main__':
  522.     main()

 

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

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

  

闽ICP备14008679号