** MemoryPuzzle 記憶拼圖 **

經(jīng)過前幾篇的基本學習，今天就開始實戰(zhàn)，在實戰(zhàn)中學習，既會有成就感，還能鞏固一下前面的知識

想想還有點小激動，畢竟是第一個游戲，雖然很簡單，已經(jīng)夠我玩一下午了 ** (●'?'●) **

（有興趣的童鞋可以自己再加上音效,加上計時器）

** 游戲?qū)崿F(xiàn)的思路（基本步驟）**

1，繪制一個640*480的窗口

2，在里面繪制10*7個box（方塊）

3，方塊的大小為 40*40，方塊間的間隔為10

4，計算方塊與窗口間的邊距，用來確定繪制Box的具體像素坐標

5，定義一個數(shù)據(jù)結(jié)構(gòu)用來存放Board中每一個Box的狀態(tài)（形狀，顏色）

6，根據(jù)以上條件，繪制好游戲基本的元素（Board和Box）

7，在每一個Box上面繪制一層白色的覆蓋Cover

8，再定義一個數(shù)據(jù)結(jié)構(gòu)用來存每一個Box對應(yīng)的False/True（覆蓋/揭開）狀態(tài)

9，獲得鼠標點擊事件，鼠標點擊的像素坐標

10，根據(jù)像素坐標轉(zhuǎn)化成Box的坐標

11，根據(jù)Box的坐標獲得其狀態(tài)（形狀，顏色）

12，點擊后就將他揭開（狀態(tài)設(shè)為True）

• 如果該Box是第一個點擊的Box，就賦值給firstSelection

• 如果是第二個點擊的Box，將他與第一個Box對比，如果如果形狀或顏色不匹配就將其狀態(tài)設(shè)為False（覆蓋），匹配就檢查游戲是否獲勝；不管匹配不匹配，都重新設(shè)置firstSelection為None

13，游戲基本就OK了，再定義幾個動畫，增加游戲體驗：

• 覆蓋Box的動畫

• 揭開Box的動畫

• 開場動畫

• 游戲獲勝動畫

(●'?'●)

** 不多說了直接上代碼 （代碼量也不多300多行，基本每一行我都做了詳細的注釋）**

# -*- coding: UTF-8 -*-
'''
Created on 2016年11月22日

@author: 小峰峰
'''

import random, pygame, sys
from pygame.locals import *

FPS = 30 #設(shè)置幀率
WINDOWWIDTH = 640# 設(shè)置窗口的寬度
WINDOWHEIGHT = 480# 設(shè)置窗口的高度
REVEALSPEED = 8# 設(shè)置box滑動的和顯示的速度
BOXSIZE = 40# 設(shè)置box的大小
GAPSIZE = 10# 設(shè)置box間的間隔
BOARDWIDTH = 10# 設(shè)置橫向box的數(shù)量
BOARDHEIGHT = 7# 設(shè)置縱向box的數(shù)量


# 斷言:總的box數(shù)必須能被2整除，因為要兩兩配對
assert (BOARDWIDTH * BOARDHEIGHT) % 2 == 0, '總的box數(shù)必須是偶數(shù)'

XMARGIN = int((WINDOWWIDTH - (BOARDWIDTH * (BOXSIZE + GAPSIZE))) / 2)# 計算距離x軸邊緣的距離
YMARGIN = int((WINDOWHEIGHT - (BOARDHEIGHT * (BOXSIZE + GAPSIZE))) / 2)# 計算距離y軸邊緣的距離

# 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# 設(shè)置背景色
LIGHTBGCOLOR = GRAY# 設(shè)置亮背景色
BOXCOLOR = WHITE# 設(shè)置box的顏色
HIGHLIGHTCOLOR = BLUE# 設(shè)置高亮顏色

#定義形狀
DONUT = 'donut'# 甜甜圈
SQUARE = 'square'# 方形
DIAMOND = 'diamond'# 鉆石
LINES = 'lines'# 多條線 
OVAL = 'oval'# 橢圓

ALLCOLORS = (RED, GREEN, BLUE, YELLOW , RED , GREEN, BLUE,)
 
ALLSHAPES = (DONUT, SQUARE, DONUT, SQUARE, OVAL)


# 斷言:顏色和形狀的數(shù)量的乘積的兩倍必須大于所有的box的數(shù)量，這樣才能保證在每一對都不重復(fù)的情況下也能填滿所有的box
assert len(ALLCOLORS) * len(ALLSHAPES) * 2 >= BOARDWIDTH * BOARDHEIGHT, "顏色和形狀數(shù)量的乘積的兩倍必須大于所有的box的數(shù)量"




def main():
    
    
    global FPSCLOCK, DISPLAYSURF# 定義全局變量
    
    mousex = 0 # 用來表示鼠標的x坐標
    mousey = 0 # 用來表示鼠標的y坐標
    
    pygame.init()# 初始化pygame
    
    FPSCLOCK = pygame.time.Clock()# 獲得pygame時鐘
    
    DISPLAYSURF = pygame.display.set_mode((WINDOWWIDTH, WINDOWHEIGHT))# 設(shè)置窗口大小

    
    pygame.display.set_caption('Memory Game')# 設(shè)置標題

    mainBoard = getRandomizedBoard()# 隨機獲得board的狀態(tài)
    
    revealedBoxes = generateRevealedBoxesData(False)# 生成一個數(shù)據(jù)結(jié)構(gòu)，用來存放已經(jīng)找到匹配的box

    firstSelection = None # 用來記錄第一個被點擊的box的坐標(x, y)

    DISPLAYSURF.fill(BGCOLOR)# 設(shè)置背景
    
    startGameAnimation(mainBoard)# 開始游戲的入場動畫
    
    while True: # 游戲主循環(huán)
        
        mouseClicked = False# 鼠標點擊狀態(tài)
        
        # 事件處理
        for event in pygame.event.get(): 
            
            # 按下ESC鍵或者點擊關(guān)閉，就退出程序
            if event.type == QUIT or (event.type == KEYDOWN and event.key == K_ESCAPE):
                pygame.quit()
                sys.exit()
            
            # 鼠標移動時記錄鼠標位置    
            elif event.type == MOUSEMOTION:
                mousex, mousey = event.pos
            
            # 鼠標點擊時記錄點擊位置，并把點擊狀態(tài)設(shè)置為True    
            elif event.type == MOUSEBUTTONUP:
                mousex, mousey = event.pos    
                mouseClicked = True
        
        #通過鼠標的x,y值獲得對應(yīng)的box的x,y(也就是鼠標所指的box)
        boxx, boxy = getBoxAtPixel(mousex, mousey)
        
        
        if boxx != None and boxy != None:
            
            # 鼠停標在一個box的上面，并且已經(jīng)點擊了該box
            if not revealedBoxes[boxx][boxy] and mouseClicked:
                revealBoxesAnimation(mainBoard, [(boxx, boxy)])# 動畫
                revealedBoxes[boxx][boxy] = True # 相當于將這個box存入revealed中
                
                if firstSelection == None: # 如果第一個被點擊的box為空，就把當前的box設(shè)為第一個點擊的box
                    firstSelection = (boxx, boxy) 
                else: 
                    # 如果當前的box是第二次被點擊的box
                    
                    # 檢查他與第一次被點擊的box是否匹配
                    
                    icon1shape, icon1color = getShapeAndColor(mainBoard, firstSelection[0], firstSelection[1])# 獲得第一次被點擊的box的形狀和顏色
                    
                    icon2shape, icon2color = getShapeAndColor(mainBoard, boxx, boxy)# 獲得當前被點擊的box的形狀和顏色
                    
                    if icon1shape != icon2shape or icon1color != icon2color:# 如果形狀或顏色不匹配
                        
                        pygame.time.wait(300) # 等待300毫秒
                        
                        coverBoxesAnimation(mainBoard, [(firstSelection[0], firstSelection[1]), (boxx, boxy)])# 把這兩個box都覆蓋回去
                        
                        revealedBoxes[firstSelection[0]][firstSelection [1]] = False# 相當于把第一個box從revealed里拿出
                        
                        revealedBoxes[boxx][boxy] = False# 相當于把當前的box從revealed里拿出
                        
                    elif hasWon(revealedBoxes): # 判斷是否獲勝
                        
                        gameWonAnimation(mainBoard)

                    
                    #不管匹配不匹配，都重新設(shè)置第一個被點擊的box為None
                    firstSelection = None 
                        
                        
        # 更新屏幕
        pygame.display.update()
        # 設(shè)置幀率
        FPSCLOCK.tick(FPS)                
                    
                                   

# 生成一個10*7的數(shù)組，用來存放box的狀態(tài)                
def generateRevealedBoxesData(val):
    revealedBoxes = []
    for i in range(BOARDWIDTH):
        revealedBoxes.append([val] * BOARDHEIGHT)
    
    return revealedBoxes            

# 隨機生成 board 內(nèi)的游戲數(shù)據(jù)        
def getRandomizedBoard():
    
    # 全排列舉所有的顏色和形狀的組合，存在icons中
    icons = []
    for color in ALLCOLORS:
        for shape in ALLSHAPES:
            icons.append( (shape, color) )

    random.shuffle(icons) # 隨機打亂icons里的元素的順序
    
    numIconsUsed = int(BOARDWIDTH * BOARDHEIGHT / 2) # 計算需要多少種的元素(也就是 board 里所有 box 的一半)
    
    icons = icons[:numIconsUsed] * 2 # 將上面得到的元素復(fù)制一份(得到的結(jié)果就可以兩兩配對)
    
    random.shuffle(icons)# 再次打亂 icons 里的元素的順序


    # 創(chuàng)建用來存放 board 數(shù)據(jù)的結(jié)構(gòu)，將上面處理好的 icons 分組放入 board 中
    board = []
    for x in range(BOARDWIDTH):
        column = []
        for y in range(BOARDHEIGHT):
            column.append(icons[0])
            del icons[0] # 刪除已經(jīng)復(fù)制的元素
        board.append(column)
    
    return board        
        

# 根據(jù)groupSize大小分組
def splitIntoGroupsOf(groupSize, theList):
    #將一個list分成以groupSize為大小的多個組
    result = []
    for i in range(0, len(theList), groupSize):
        result.append(theList[i:i + groupSize])
    return result



# 計算出box的左上角的像素坐標
def leftTopCoordsOfBox(boxx, boxy):
    # 將數(shù)字坐標轉(zhuǎn)化成像素坐標
    left = boxx * (BOXSIZE + GAPSIZE) + XMARGIN
    top = boxy * (BOXSIZE + GAPSIZE) + YMARGIN
    return (left, top)


# 根據(jù)鼠標的像素坐標獲得box的坐標(也就是獲得鼠標所指的box)
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)


# 繪制圖標，將顏色和形狀繪制在相應(yīng)的box中
def drawIcon(shape, color, boxx, boxy):
    quarter = int(BOXSIZE * 0.25) # 1/4的box大小
    half = int(BOXSIZE * 0.5) # 1/2的box大小

    left, top = leftTopCoordsOfBox(boxx, boxy) # 獲得box的左上角的像素坐標
    
    
    # 繪制圖形
    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))    
        

# 根據(jù)box坐標獲得box的形狀和顏色        
def getShapeAndColor(board, boxx, boxy):
    # 形狀值對應(yīng)的存在board[x][y][0]中        
    # 顏色值對應(yīng)的存在board[x][y][1]中
    return board[boxx][boxy][0], board[boxx][boxy][1]    
        
        
        
# 繪制box上的coverage
def drawBoxCovers(board, boxes, coverage):
    # 繪制覆蓋/揭開的box 
    for box in boxes:# 獲得每一個box
        
        left, top = leftTopCoordsOfBox(box[0], box[1])# 計算每一個box的左上角像素坐標
        
        pygame.draw.rect(DISPLAYSURF, WHITE, (left, top, BOXSIZE, BOXSIZE))# 將這個box繪制成白色
        
        shape, color = getShapeAndColor(board, box[0], box[1])# 獲得這個box里存放的形狀和顏色
        
        drawIcon(shape, color, box[0], box[1])# 繪制對應(yīng)的圖標
        
        if coverage > 0: # 當該box有覆蓋時就繪制一層白色的覆蓋
            pygame.draw.rect(DISPLAYSURF, BOXCOLOR, (left, top, coverage, BOXSIZE))
            
    # 更新屏幕        
    pygame.display.update()
    # 設(shè)置幀率
    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)



# 繪制Board
def drawBoard(board, revealed):
    # 根據(jù)所有的box的狀態(tài)(覆蓋/揭開)繪制對應(yīng)的box
    for boxx in range(BOARDWIDTH):
        for boxy in range(BOARDHEIGHT):
            left, top = leftTopCoordsOfBox(boxx, boxy)
            if not revealed[boxx][boxy]:
                # 繪制一個被覆蓋的box
                pygame.draw.rect(DISPLAYSURF, BOXCOLOR, (left, top, BOXSIZE, BOXSIZE))
            else:
                # 繪制一個揭開的圖標
                shape, color = getShapeAndColor(board, boxx, boxy)
                drawIcon(shape, color, boxx, boxy)



# 游戲的開場動畫
def startGameAnimation(board):
    # 一次隨機獲得8個box顯示
    coveredBoxes = generateRevealedBoxesData(False)
    boxes = []
    for x in range(BOARDWIDTH):
        for y in range(BOARDHEIGHT):
            boxes.append( (x, y) )
            
    random.shuffle(boxes)
    # 將上面的結(jié)果以8個為一組的分組
    boxGroups = splitIntoGroupsOf(8, boxes)

    drawBoard(board, coveredBoxes)
    
    # 對每一組的元素都進行，先揭開再覆蓋的動畫
    for boxGroup in boxGroups:
        revealBoxesAnimation(board, boxGroup)
        coverBoxesAnimation(board, boxGroup)


# 游戲獲勝的動畫
def gameWonAnimation(board):

    coveredBoxes = generateRevealedBoxesData(True)
    
    color1 = LIGHTBGCOLOR
    color2 = BGCOLOR

    # 閃動背景顏色
    for i in range(9):
        color1, color2 = color2, color1 # 交換顏色
        DISPLAYSURF.fill(color1)
        # 顯示所有的box
        drawBoard(board, coveredBoxes)
        pygame.display.update()
        pygame.time.wait(300)


# 判斷游戲是否獲勝
def hasWon(revealedBoxes):
    # 當所有的box都被揭開時，游戲才獲勝，否則返回False
    for i in revealedBoxes:
        if False in i:
            return False 
    return True


if __name__ == '__main__':
    main()

ps:說明一下為了減小游戲的難度，這里的顏色集我只用了{ RED, GREEN, BLUE, YELLOW } 這四個，形狀集也只用了 { DONUT, SQUARE, OVAL } 這三個。

** 運行結(jié)果：**

** 游戲獲勝 **