"神經衰弱"翻牌遊戲考察玩家的記憶力，遊戲的開頭會短時間給你看一小部分牌的圖案，當玩家翻開兩張相同圖案牌的時候，會消除，和你的小夥伴比一比誰用時更短把。

原始碼

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)
GREEN  = ( 0,0)
BLUE   = ( 0,255)
YELLOW  = (255,0)
ORANGE  = (255,128,0)
PURPLE  = (255,255)
CYAN   = ( 0,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,boxy):
  quarter = int(BOXSIZE * 0.25) # syntactic sugar
  half =  int(BOXSIZE * 0.5) # syntactic sugar

  left,boxy) # get pixel coords from board coords
  # Draw the shapes
  if shape == DONUT:
    pygame.draw.circle(DISPLAYSURF,(left + half,top + half),half - 5)
    pygame.draw.circle(DISPLAYSURF,BGCOLOR,quarter - 5)
  elif shape == SQUARE:
    pygame.draw.rect(DISPLAYSURF,(left + quarter,top + quarter,BOXSIZE - half,BOXSIZE - half))
  elif shape == DIAMOND:
    pygame.draw.polygon(DISPLAYSURF,((left + half,top),(left + BOXSIZE - 1,top + BOXSIZE - 1),(left,top + half)))
  elif shape == LINES:
    for i in range(0,4):
      pygame.draw.line(DISPLAYSURF,top + i),(left + i,top))
      pygame.draw.line(DISPLAYSURF,top + i))
  elif shape == OVAL:
    pygame.draw.ellipse(DISPLAYSURF,half))


def getShapeAndColor(board,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,BOXSIZE))
    shape,color = getShapeAndColor(board,box[0],box[1])
    drawIcon(shape,box[1])
    if coverage > 0: # only draw the cover if there is an coverage
      pygame.draw.rect(DISPLAYSURF,BOXCOLOR,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,boxy)
      if not revealed[boxx][boxy]:
        # Draw a covered box.
        pygame.draw.rect(DISPLAYSURF,BOXSIZE))
      else:
        # Draw the (revealed) icon.
        shape,boxy)
        drawIcon(shape,boxy)


def drawHighlightBox(boxx,boxy):
  left,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()

執行效果：

以上就是python 實現"神經衰弱"翻牌遊戲的詳細內容，更多關於python "神經衰弱"翻牌遊戲的資料請關注我們其它相關文章！