python3+pygame實現的2048，非常完整的代碼

前幾天寫了一個2048程序，是基於python3+pygame實現的，對於初學python的同學來說應該是很好的練手項目，現在將源碼分享給大家，添加了清晰的注釋，相信大家能看的很明白

運行效果如下：

游戲結束后的效果如下：

 

完整代碼如下，如果需要下載素材（圖片、字體等可以到 https://www.itprojects.cn/web/material/details.html?id=10進行下載）

import random
import sys
from collections import Iterable
from functools import reduce

import pygame

# 屏幕尺寸
WIDTH, HEIGHT = (650, 370)
# 背景顏色
BG_COLOR = '#92877d'
# 棋盤需要的數據
MARGIN_SIZE = 10  # 間隔大小
BLOCK_SIZE = 80  # 棋子位置大小


def draw_tips(screen):
    """
    顯示提示信息
    """
    # 顯示"分數："
    tips_img = pygame.image.load("resources/images/tips.png")
    screen.blit(tips_img, (375, 200))


def get_score(chess_nums_temp):
    """
    計算當前棋盤的總分數
    """

    def sum_all(x, y):
        if isinstance(x, Iterable):
            return sum(x) + sum(y)
        return x + sum(y)

    return reduce(sum_all, chess_nums_temp)


def draw_score(screen, score):
    """
    顯示分數
    """
    # 顯示數字
    font_size_big = 60
    font_color = (0, 255, 255)
    font_big = pygame.font.Font("resources/font/Gabriola.ttf", font_size_big)
    score = font_big.render(str(score), True, font_color)
    screen.blit(score, (470, 25))
    # 顯示"分數："
    score_img = pygame.image.load("resources/images/score.png")
    screen.blit(score_img, (370, 30))


def show_game_over(screen):
    font_size_big = 60
    font_size_small = 30
    font_color = (255, 255, 255)
    font_big = pygame.font.Font("resources/font/Gabriola.ttf", font_size_big)
    font_small = pygame.font.Font("resources/font/Gabriola.ttf", font_size_small)
    surface = screen.convert_alpha()
    surface.fill((127, 255, 212, 2))
    text = font_big.render('Game Over!', True, font_color)
    text_rect = text.get_rect()
    text_rect.centerx, text_rect.centery = WIDTH / 2, HEIGHT / 2 - 50
    surface.blit(text, text_rect)
    button_width, button_height = 100, 40
    button_start_x_left = WIDTH / 2 - button_width - 20
    button_start_x_right = WIDTH / 2 + 20
    button_start_y = HEIGHT / 2 - button_height / 2 + 20
    pygame.draw.rect(surface, (0, 255, 255), (button_start_x_left, button_start_y, button_width, button_height))
    text_restart = font_small.render('Restart', True, font_color)
    text_restart_rect = text_restart.get_rect()
    text_restart_rect.centerx, text_restart_rect.centery = button_start_x_left + button_width / 2, button_start_y + button_height / 2
    surface.blit(text_restart, text_restart_rect)
    pygame.draw.rect(surface, (0, 255, 255), (button_start_x_right, button_start_y, button_width, button_height))
    text_quit = font_small.render('Quit', True, font_color)
    text_quit_rect = text_quit.get_rect()
    text_quit_rect.centerx, text_quit_rect.centery = button_start_x_right + button_width / 2, button_start_y + button_height / 2
    surface.blit(text_quit, text_quit_rect)
    clock = pygame.time.Clock()
    while True:
        screen.blit(surface, (0, 0))
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                sys.exit()
            elif event.type == pygame.MOUSEBUTTONDOWN and event.button:
                if text_quit_rect.collidepoint(pygame.mouse.get_pos()):
                    sys.exit()
                if text_restart_rect.collidepoint(pygame.mouse.get_pos()):
                    return True
        pygame.display.update()
        clock.tick(60)


def judge_game_over(field):
    """
    只要有1個方向可以移動，那么游戲就沒結束
    """
    return not any([judge_move_left(field), judge_move_right(field), judge_move_up(field), judge_move_down(field)])


def judge_move_up(chess_nums_temp):
    # 對棋盤的數字進行「行與列轉置」，即原來在第2行第3列變為第3行第2列
    # zip: 實現
    # *chess_nums_temp對列表進行拆包
    chess_nums_temp = [list(row) for row in zip(*chess_nums_temp)]
    return judge_move_left(chess_nums_temp)


def judge_move_down(chess_nums_temp):
    """
    邏輯：判斷能否向下移動, 也就是對於元素進行轉置, 判斷轉置后的棋盤能否向右移動
    """
    # 1.「行與列轉置」
    chess_nums_temp = [list(row) for row in zip(*chess_nums_temp)]
    # 2. 判斷是否可以向右移動
    return judge_move_right(chess_nums_temp)


def judge_move_left(chess_nums_temp):
    # 只要棋盤的任意一行可以向左移動， 就返回True
    for row in chess_nums_temp:
        for i in range(3):  # 每一行判斷3次
            # 如果判斷的左邊的數為0，右邊的數不為0，則說明可以向左移動；
            if row[i] == 0 and row[i + 1] != 0:
                return True
            elif row[i] != 0 and row[i + 1] == row[i]:
                # 如果判斷的左邊的數不為0，且左右2個數相等，則說明可以向左移動；
                return True
    return False


def judge_move_right(chess_nums_temp):
    # 對棋盤的每一行元素進行反轉，此時就可以用向左的函數進行判斷了
    return judge_move_left([row[::-1] for row in chess_nums_temp])


def move_left(chess_nums_temp):
    for i, row in enumerate(chess_nums_temp):
        # 1.把這一行的非0 數字向前放，把0向后放。例如之前是[0, 2, 2, 2]-->[2, 2, 2, 0]
        row = sorted(row, key=lambda x: 1 if x == 0 else 0)

        # 2.依次循環判斷兩個數是否相等，如果相等 第一個*2 第二個數為0。例如[2, 2, 2, 0]-->[4, 0, 2, 0]
        for index in range(3):
            if row[index] == row[index + 1]:
                row[index] *= 2
                row[index + 1] = 0

        # 3.將合並之后的空隙移除，即非0靠左，0靠右。例如[4, 0, 2, 0]-->[4, 2, 0, 0]
        row = sorted(row, key=lambda x: 1 if x == 0 else 0)
        # 4. 更新數字列表，因為這一行已經是操作之后的了
        chess_nums_temp[i] = row
    return chess_nums_temp


def move_right(chess_nums_temp):
    # 先翻翻轉
    chess_nums_temp = [row[::-1] for row in chess_nums_temp]
    # 然后在調用像左移動的功能
    move_left(chess_nums_temp)
    # 最后再次翻轉，實現之前的樣子
    return [row[::-1] for row in chess_nums_temp]


def move_up(chess_nums_temp):
    # "行與列轉置"
    chess_nums_temp = [list(row) for row in zip(*chess_nums_temp)]
    # 向左移動
    chess_nums_temp = move_left(chess_nums_temp)
    # 再次"行與列轉置"從而實現復原
    return [list(row) for row in zip(*chess_nums_temp)]


def move_down(chess_nums_temp):
    # "行與列轉置"
    chess_nums_temp = [list(row) for row in zip(*chess_nums_temp)]
    # 向右移動
    chess_nums_temp = move_right(chess_nums_temp)
    # 再次"行與列轉置"從而實現復原
    return [list(row) for row in zip(*chess_nums_temp)]


def move(chess_nums_temp, direction):
    """
    根據方向移動數字
    """
    # 存儲判斷各個方向是否可移動對應的函數
    judge_move_func_dict = {
        'left': judge_move_left,
        'right': judge_move_right,
        'up': judge_move_up,
        'down': judge_move_down
    }
    # 存儲各個方向移動的函數
    move_func_dict = {
        'left': move_left,
        'right': move_right,
        'up': move_up,
        'down': move_down
    }

    # 調用對應的函數，判斷是否可以朝這個方向移動
    ret = judge_move_func_dict[direction](chess_nums_temp)
    print("%s方向是否可以移動：" % direction, ret)
    if ret:
        chess_nums_temp = move_func_dict[direction](chess_nums_temp)
        create_random_num(chess_nums_temp)

    # 返回列表，如果更新了就是新的，如果沒有更新就是之前的那個
    return chess_nums_temp


def get_num_color(num):
    """
    根據當前要顯示的數字，提取出背景色以及字體顏色
    對應的數字：[方格背景顏色, 方格里的字體顏色]
    """
    color_dict = {
        2: ['#eee4da', '#776e65'], 4: ['#ede0c8', '#776e65'], 8: ['#f2b179', '#f9f6f2'],
        16: ['#f59563', '#f9f6f2'], 32: ['#f67c5f', '#f9f6f2'], 64: ['#f65e3b', '#f9f6f2'],
        128: ['#edcf72', '#f9f6f2'], 256: ['#edcc61', '#f9f6f2'], 512: ['#edc850', '#f9f6f2'],
        1024: ['#edc53f', '#f9f6f2'], 2048: ['#edc22e', '#f9f6f2'], 4096: ['#eee4da', '#776e65'],
        8192: ['#edc22e', '#f9f6f2'], 16384: ['#f2b179', '#776e65'], 32768: ['#f59563', '#776e65'],
        65536: ['#f67c5f', '#f9f6f2'], 0: ['#9e948a', None]
    }
    return color_dict[num]


def create_random_num(nums_temp):
    """
    在棋盤中隨機生成一個數字
    """
    # 存儲所有空位置
    positions = list()
    for row, line in enumerate(nums_temp):
        for col, num in enumerate(line):
            if num == 0:
                positions.append((row, col))

    # 隨機從空位置列表中抽取一個，然后拆包
    row, col = random.choice(positions)
    nums_temp[row][col] = random.choice([2, 4, 2])  # 隨機從2個2，1個4中抽取，這樣抽到2的概率是4的2倍


def draw_nums(screen, chess_nums_temp):
    """
    顯示棋盤上的數字
    """
    # 准備字體等
    font_size = BLOCK_SIZE - 10
    font = pygame.font.Font("./resources/font/Gabriola.ttf", font_size)
    # 遍歷數字
    for i, line in enumerate(chess_nums_temp):
        for j, num in enumerate(line):
            if num != 0:
                # 計算顯示位置（x坐標、y坐標）
                x = MARGIN_SIZE * (j + 1) + BLOCK_SIZE * j
                y = MARGIN_SIZE * (i + 1) + BLOCK_SIZE * i
                # 獲取顏色
                font_color = pygame.Color(get_num_color(num)[1])
                # 顯示數字
                text = font.render(str(num), True, font_color)
                text_rect = text.get_rect()
                text_rect.centerx, text_rect.centery = x + BLOCK_SIZE / 2, y + BLOCK_SIZE / 2
                # 用對應的數字背景色，重新繪制這個方塊
                pygame.draw.rect(screen, pygame.Color(get_num_color(num)[0]), (x, y, BLOCK_SIZE, BLOCK_SIZE))
                screen.blit(text, text_rect)


def draw_chess_board(screen):
    """
    顯示棋盤
    """
    for i in range(4):
        for j in range(4):
            x = MARGIN_SIZE * (j + 1) + BLOCK_SIZE * j
            y = MARGIN_SIZE * (i + 1) + BLOCK_SIZE * i
            pygame.draw.rect(screen, pygame.Color('#f9f6f2'), (x, y, BLOCK_SIZE, BLOCK_SIZE))


def run(screen):
    # 定義列表，用來記錄當前棋盤上的所有數字，如果某位置沒有數字，則為0
    chess_nums = [[0 for _ in range(4)] for _ in range(4)]
    # 隨機生成一個數字
    create_random_num(chess_nums)
    create_random_num(chess_nums)
    # 記錄當前的分數
    score = get_score(chess_nums)
    # 創建計時器（防止while循環過快，占用太多CPU的問題）
    clock = pygame.time.Clock()
    while True:
        # 事件檢測（鼠標點擊、鍵盤按下等）
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                sys.exit()
            elif event.type == pygame.KEYDOWN:
                if event.key in [pygame.K_UP, pygame.K_DOWN, pygame.K_LEFT, pygame.K_RIGHT]:
                    direction = {pygame.K_UP: 'up', pygame.K_DOWN: 'down', pygame.K_LEFT: 'left', pygame.K_RIGHT: 'right'}[event.key]
                    print("按下了方向鍵:", direction)
                    chess_nums = move(chess_nums, direction)
                    if judge_game_over(chess_nums):
                        print("游戲結束....")
                        return
                    # 每按下方向鍵，就重新計算
                    score = get_score(chess_nums)

        # 顯示背景色
        screen.fill(pygame.Color(BG_COLOR))

        # 顯示棋盤
        draw_chess_board(screen)

        # 顯示棋盤上的數字
        draw_nums(screen, chess_nums)

        # 顯示分數
        draw_score(screen, score)

        # 顯示操作提示
        draw_tips(screen)

        # 刷新顯示（此時窗口才會真正的顯示）
        pygame.display.update()

        # FPS（每秒鍾顯示畫面的次數）
        clock.tick(60)  # 通過一定的延時，實現1秒鍾能夠循環60次


def main():
    # 游戲初始化
    pygame.init()
    screen = pygame.display.set_mode((WIDTH, HEIGHT))
    while True:
        # 運行一次游戲
        run(screen)
        # 顯示游戲結束，是否重來
        show_game_over(screen)


if __name__ == '__main__':
    main()