pygame13个小游戏代码

# Memory Puzzle, by Al Sweigart al@inventwithpython.com # (Requires Pygame) A simple memory matching game.   __version__ = 1 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))) / 2)
YMARGIN = int((WINDOWHEIGHT - (BOARDHEIGHT * (BOXSIZE   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.display.quit(); pygame.quit() # Display quit is a workaround for a Raspberry Pi bug.  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  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, (-REVEALSPEED) - 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(13):
        color1, color2 = color2, color1 # swap colors  DISPLAYSURF.fill(color1)
        drawBoard(board, coveredBoxes)
        pygame.display.update()
        pygame.time.wait(300) def hasWon(revealedBoxes): # Returns True if all the boxes have been revealed, otherwise False  for i in revealedBoxes: if False in i: return False # return False if any boxes are covered.  return True   if __name__ == '__main__':
    main()