|
马上注册,结交更多好友,享用更多功能^_^
您需要 登录 才可以下载或查看,没有账号?立即注册
x
本帖最后由 某一个“天” 于 2024-1-29 19:40 编辑
请大家多多评分,如果大家喜欢 我还有更多
- # Memory Puzzle
- # Released under a "Simplified BSD" license
- import random, pygame, sys
- from pygame.locals import *
- FPS = 30 # frames per second, the general speed of the program
- WINDOWWIDTH = 640 # size of window's width in pixels
- WINDOWHEIGHT = 480 # size of windows' height in pixels
- REVEALSPEED = 8 # speed boxes' sliding reveals and covers
- BOXSIZE = 40 # size of box height & width in pixels
- GAPSIZE = 10 # size of gap between boxes in pixels
- BOARDWIDTH = 10 # number of columns of icons
- BOARDHEIGHT = 7 # number of rows of icons
- assert (BOARDWIDTH * BOARDHEIGHT) % 2 == 0, 'Board needs to have an even number of boxes for pairs of matches.'
- XMARGIN = int((WINDOWWIDTH - (BOARDWIDTH * (BOXSIZE + GAPSIZE)-GAPSIZE)) / 2) # 边缘有多少像素
- YMARGIN = int((WINDOWHEIGHT - (BOARDHEIGHT * (BOXSIZE + GAPSIZE)-GAPSIZE)) / 2)
- # R G B
- GRAY = (100, 100, 100)
- NAVYBLUE = ( 60, 60, 100)
- WHITE = (255, 255, 255)
- RED = (255, 0, 0)
- GREEN = ( 0, 255, 0)
- BLUE = ( 0, 0, 255)
- YELLOW = (255, 255, 0)
- ORANGE = (255, 128, 0)
- PURPLE = (255, 0, 255)
- CYAN = ( 0, 255, 255)
- BGCOLOR = NAVYBLUE
- LIGHTBGCOLOR = GRAY
- BOXCOLOR = WHITE
- HIGHLIGHTCOLOR = BLUE
- DONUT = 'donut'
- SQUARE = 'square'
- DIAMOND = 'diamond'
- LINES = 'lines'
- OVAL = 'oval'
- ALLCOLORS = (RED, GREEN, BLUE, YELLOW, ORANGE, PURPLE, CYAN)
- ALLSHAPES = (DONUT, SQUARE, DIAMOND, LINES, OVAL)
- assert len(ALLCOLORS) * len(ALLSHAPES) * 2 >= BOARDWIDTH * BOARDHEIGHT, "Board is too big for the number of shapes/colors defined."
- def main():
- global FPSCLOCK, DISPLAYSURF
- pygame.init()
- FPSCLOCK = pygame.time.Clock()
- DISPLAYSURF = pygame.display.set_mode((WINDOWWIDTH, WINDOWHEIGHT))
- mousex = 0 # used to store x coordinate of mouse event
- mousey = 0 # used to store y coordinate of mouse event
- pygame.display.set_caption('Memory Game')
- mainBoard = getRandomizedBoard()
- revealedBoxes = generateRevealedBoxesData(False)
- firstSelection = None # stores the (x, y) of the first box clicked.
- DISPLAYSURF.fill(BGCOLOR)
- startGameAnimation(mainBoard)
- while True: # main game loop
- mouseClicked = False
- DISPLAYSURF.fill(BGCOLOR) # drawing the window
- drawBoard(mainBoard, revealedBoxes)
- for event in pygame.event.get(): # event handling loop
- if event.type == QUIT or (event.type == KEYUP and event.key == K_ESCAPE):
- pygame.quit()
- sys.exit()
- elif event.type == MOUSEMOTION:
- mousex, mousey = event.pos
- elif event.type == MOUSEBUTTONUP:
- mousex, mousey = event.pos
- mouseClicked = True
- boxx, boxy = getBoxAtPixel(mousex, mousey)
- if boxx != None and boxy != None:
- # The mouse is currently over a box.
- if not revealedBoxes[boxx][boxy]:
- drawHighlightBox(boxx, boxy)
- if not revealedBoxes[boxx][boxy] and mouseClicked:
- revealBoxesAnimation(mainBoard, [(boxx, boxy)]) # 揭开动画
- revealedBoxes[boxx][boxy] = True # set the box as "revealed"
- if firstSelection == None: # the current box was the first box clicked
- firstSelection = (boxx, boxy)
- else: # the current box was the second box clicked
- # Check if there is a match between the two icons.
- icon1shape, icon1color = getShapeAndColor(mainBoard, firstSelection[0], firstSelection[1])
- icon2shape, icon2color = getShapeAndColor(mainBoard, boxx, boxy)
- if icon1shape != icon2shape or icon1color != icon2color:
- # Icons don't match. Re-cover up both selections.
- pygame.time.wait(1000) # 1000 milliseconds = 1 sec
- coverBoxesAnimation(mainBoard, [(firstSelection[0], firstSelection[1]), (boxx, boxy)])
- revealedBoxes[firstSelection[0]][firstSelection[1]] = False
- revealedBoxes[boxx][boxy] = False
- elif hasWon(revealedBoxes): # check if all pairs found
- gameWonAnimation(mainBoard)
- pygame.time.wait(2000)
- # Reset the board
- mainBoard = getRandomizedBoard()
- revealedBoxes = generateRevealedBoxesData(False)
- # Show the fully unrevealed board for a second.
- drawBoard(mainBoard, revealedBoxes)
- pygame.display.update()
- pygame.time.wait(1000)
- # Replay the start game animation.
- startGameAnimation(mainBoard)
- firstSelection = None # reset firstSelection variable
- # Redraw the screen and wait a clock tick.
- pygame.display.update()
- FPSCLOCK.tick(FPS)
- def generateRevealedBoxesData(val):
- revealedBoxes = []
- for i in range(BOARDWIDTH):
- revealedBoxes.append([val] * BOARDHEIGHT)
- return revealedBoxes
- def getRandomizedBoard():
- # Get a list of every possible shape in every possible color.
- icons = []
- for color in ALLCOLORS:
- for shape in ALLSHAPES:
- icons.append( (shape, color) )
- random.shuffle(icons) # randomize the order of the icons list
- numIconsUsed = int(BOARDWIDTH * BOARDHEIGHT / 2) # calculate how many icons are needed
- icons = icons[:numIconsUsed] * 2 # make two of each
- random.shuffle(icons)
- # Create the board data structure, with randomly placed icons.
- board = []
- for x in range(BOARDWIDTH):
- column = []
- for y in range(BOARDHEIGHT):
- column.append(icons[0])
- del icons[0] # remove the icons as we assign them
- board.append(column)
- return board
- def splitIntoGroupsOf(groupSize, theList):
- # splits a list into a list of lists, where the inner lists have at
- # most groupSize number of items.
- result = []
- for i in range(0, len(theList), groupSize):
- result.append(theList[i:i + groupSize])
- return result
- def leftTopCoordsOfBox(boxx, boxy):
- # Convert board coordinates to pixel coordinates
- left = boxx * (BOXSIZE + GAPSIZE) + XMARGIN
- top = boxy * (BOXSIZE + GAPSIZE) + YMARGIN
- return (left, top)
- def getBoxAtPixel(x, y):
- for boxx in range(BOARDWIDTH):
- for boxy in range(BOARDHEIGHT):
- left, top = leftTopCoordsOfBox(boxx, boxy)
- boxRect = pygame.Rect(left, top, BOXSIZE, BOXSIZE)
- if boxRect.collidepoint(x, y):
- return (boxx, boxy)
- return (None, None)
- def drawIcon(shape, color, boxx, boxy):
- quarter = int(BOXSIZE * 0.25) # syntactic sugar
- half = int(BOXSIZE * 0.5) # syntactic sugar
- left, top = leftTopCoordsOfBox(boxx, boxy) # get pixel coords from board coords
- # Draw the shapes
- if shape == DONUT:
- pygame.draw.circle(DISPLAYSURF, color, (left + half, top + half), half - 5) # 大圆
- pygame.draw.circle(DISPLAYSURF, BGCOLOR, (left + half, top + half), quarter - 5) # 小圆
- elif shape == SQUARE:
- pygame.draw.rect(DISPLAYSURF, color, (left + quarter, top + quarter, BOXSIZE - half, BOXSIZE - half))
- elif shape == DIAMOND:
- pygame.draw.polygon(DISPLAYSURF, color, ((left + half, top), (left + BOXSIZE - 1, top + half), (left + half, top + BOXSIZE - 1), (left, top + half)))
- elif shape == LINES:
- for i in range(0, BOXSIZE, 4):
- pygame.draw.line(DISPLAYSURF, color, (left, top + i), (left + i, top)) # 左上部分
- pygame.draw.line(DISPLAYSURF, color, (left + i, top + BOXSIZE - 1), (left + BOXSIZE - 1, top + i)) # 右下部分
- elif shape == OVAL:
- pygame.draw.ellipse(DISPLAYSURF, color, (left, top + quarter, BOXSIZE, half))
- def getShapeAndColor(board, boxx, boxy):
- # shape value for x, y spot is stored in board[x][y][0]
- # color value for x, y spot is stored in board[x][y][1]
- return board[boxx][boxy][0], board[boxx][boxy][1]
- def drawBoxCovers(board, boxes, coverage):
- # Draws boxes being covered/revealed. "boxes" is a list
- # of two-item lists, which have the x & y spot of the box.
- for box in boxes:
- left, top = leftTopCoordsOfBox(box[0], box[1])
- pygame.draw.rect(DISPLAYSURF, BGCOLOR, (left, top, BOXSIZE, BOXSIZE))
- shape, color = getShapeAndColor(board, box[0], box[1])
- drawIcon(shape, color, box[0], box[1])
- if coverage > 0: # only draw the cover if there is an coverage
- # coverage是图标覆盖的范围
- pygame.draw.rect(DISPLAYSURF, BOXCOLOR, (left, top, coverage, BOXSIZE))
- pygame.display.update()
- FPSCLOCK.tick(FPS)
- def revealBoxesAnimation(board, boxesToReveal):
- # Do the "box reveal" animation.
- for coverage in range(BOXSIZE, - 1, -REVEALSPEED):
- drawBoxCovers(board, boxesToReveal, coverage)
- def coverBoxesAnimation(board, boxesToCover):
- # Do the "box cover" animation.
- for coverage in range(0, BOXSIZE + REVEALSPEED, REVEALSPEED):
- drawBoxCovers(board, boxesToCover, coverage)
- def drawBoard(board, revealed):
- # Draws all of the boxes in their covered or revealed state.
- for boxx in range(BOARDWIDTH):
- for boxy in range(BOARDHEIGHT):
- left, top = leftTopCoordsOfBox(boxx, boxy)
- if not revealed[boxx][boxy]:
- # Draw a covered box.
- pygame.draw.rect(DISPLAYSURF, BOXCOLOR, (left, top, BOXSIZE, BOXSIZE))
- else:
- # Draw the (revealed) icon.
- shape, color = getShapeAndColor(board, boxx, boxy)
- drawIcon(shape, color, boxx, boxy)
- def drawHighlightBox(boxx, boxy):
- left, top = leftTopCoordsOfBox(boxx, boxy)
- pygame.draw.rect(DISPLAYSURF, HIGHLIGHTCOLOR, (left - 5, top - 5, BOXSIZE + 10, BOXSIZE + 10), 4)
- def startGameAnimation(board):
- # Randomly reveal the boxes 8 at a time.
- coveredBoxes = generateRevealedBoxesData(False)
- boxes = []
- for x in range(BOARDWIDTH):
- for y in range(BOARDHEIGHT):
- boxes.append( (x, y) )
- random.shuffle(boxes)
- boxGroups = splitIntoGroupsOf(8, boxes)
- drawBoard(board, coveredBoxes)
- for boxGroup in boxGroups:
- revealBoxesAnimation(board, boxGroup)
- coverBoxesAnimation(board, boxGroup)
- def gameWonAnimation(board):
- # flash the background color when the player has won
- coveredBoxes = generateRevealedBoxesData(True)
- color1 = LIGHTBGCOLOR
- color2 = BGCOLOR
- for i in range(17):
- color1, color2 = color2, color1 # swap colors
- DISPLAYSURF.fill(color1)
- drawBoard(board, coveredBoxes)
- pygame.display.update()
- pygame.time.wait(200)
- def hasWon(revealedBoxes):
- # Returns True if all the boxes have been revealed, otherwise False
- for i in revealedBoxes:
- print(i)
- if False in i:
- return False # return False if any boxes are covered.
- return True
- if __name__ == '__main__':
- main()
复制代码 |
-
-
评分
-
查看全部评分
|