200行Python代碼實現的2048小游戲

2048這個小游戲大家都不陌生，應該都玩過，之前已經在網上見過各個版本的2048實現了，有JAVA、HTML5等，今天我就給大家來一個我自己在 實驗樓 學到的python版2048。所有代碼加起來才200行，不用很麻煩很累就可以寫一個 2048 游戲出來。

游戲的具體規則什么的就不多說了，自己親自去玩一下就清楚了。

導入需要的包

    import curses
    from random import randrange, choice
    from collections import defaultdict

游戲主邏輯

用戶行為

用戶在玩游戲的主要輸入分為六種，"上，下，左，右，游戲重置，退出"用 actions 表示

    actions = ['Up', 'Left', 'Down', 'Right', 'Restart', 'Exit']

分別用 W（上），A（左），S（下），D（右），R（重置），Q（退出），進行輸入來操作游戲，這里考慮到大寫鎖定鍵鎖定的情況：

letter_codes = [ord(ch) for ch in 'WASDRQwasdrq']

將輸入與行為進行關聯：

actions_dict = dict(zip(letter_codes, actions * 2))

用戶輸入處理

阻塞＋循環，直到獲得用戶有效輸入才返回對應行為：

def get_user_action(keyboard):    
    char = "N"
    while char not in actions_dict:    
        char = keyboard.getch()
    return actions_dict[char]

矩陣轉置與矩陣逆轉

這兩個操作主要是用戶在操作游戲之后對棋盤狀態的變化以及修改，擁有這兩個函數能夠節省不少的代碼量。

矩陣轉置：

def transpose(field):
    return [list(row) for row in zip(*field)]

矩陣逆轉（不是逆矩陣）：

def invert(field):
    return [row[::-1] for row in field]

創建棋盤

初始化棋盤的參數，可以指定棋盤的高和寬以及游戲勝利條件，默認是最經典的 4x4～2048。

class GameField(object):
def __init__(self, height=4, width=4, win=2048):
    self.height = height       #高
    self.width = width         #寬
    self.win_value = 2048      #過關分數
    self.score = 0             #當前分數
    self.highscore = 0         #最高分
    self.reset()               #棋盤重置

棋盤操作

隨機生成一個 2 或者 4

def spawn(self):
        new_element = 4 if randrange(100) > 89 else 2
        (i,j) = choice([(i,j) for i in range(self.width) for j in range(self.height) if self.field[i][j] == 0])
        self.field[i][j] = new_element

重置棋盤

def reset(self):
    if self.score > self.highscore:
        self.highscore = self.score
    self.score = 0
    self.field = [[0 for i in range(self.width)] for j in range(self.height)]
    self.spawn()
    self.spawn()

一行向左合並

(注：這一操作是在 move 內定義的，拆出來是為了方便閱讀)

def move_row_left(row):
    def tighten(row): # 把零散的非零單元擠到一塊
        new_row = [i for i in row if i != 0]
        new_row += [0 for i in range(len(row) - len(new_row))]
        return new_row

    def merge(row): # 對鄰近元素進行合並
        pair = False
        new_row = []
        for i in range(len(row)):
            if pair:
                new_row.append(2 * row[i])
                self.score += 2 * row[i]
                pair = False
            else:
                if i + 1 < len(row) and row[i] == row[i + 1]:
                    pair = True
                    new_row.append(0)
                else:
                    new_row.append(row[i])
        assert len(new_row) == len(row)
        return new_row
    #先擠到一塊再合並再擠到一塊
    return tighten(merge(tighten(row)))

棋盤走一步

通過對矩陣進行轉置與逆轉，可以直接從左移得到其余三個方向的移動操作

def move(self, direction):
    def move_row_left(row):
        #一行向左合並

    moves = {}
    moves['Left']  = lambda field: [move_row_left(row) for row in field]
    moves['Right'] = lambda field: invert(moves['Left'](invert(field)))
    moves['Up']    = lambda field: transpose(moves['Left'](transpose(field)))
    moves['Down']  = lambda field: transpose(moves['Right'](transpose(field)))

    if direction in moves:
        if self.move_is_possible(direction):
            self.field = moves[direction](self.field)
            self.spawn()
            return True
        else:
            return False

判斷輸贏

def is_win(self):
    return any(any(i >= self.win_value for i in row) for row in self.field)

def is_gameover(self):
    return not any(self.move_is_possible(move) for move in actions)

判斷能否移動

def move_is_possible(self, direction):
    def row_is_left_movable(row): 
        def change(i):
            if row[i] == 0 and row[i + 1] != 0: # 可以移動
                return True
            if row[i] != 0 and row[i + 1] == row[i]: # 可以合並
                return True
            return False
        return any(change(i) for i in range(len(row) - 1))

    check = {}
    check['Left']  = lambda field: any(row_is_left_movable(row) for row in field)

    check['Right'] = lambda field: check['Left'](invert(field))

    check['Up']    = lambda field: check['Left'](transpose(field))

    check['Down']  = lambda field: check['Right'](transpose(field))

    if direction in check:
        return check[direction](self.field)
    else:
        return False

繪制游戲界面

（注：這一步是在棋盤類內定義的）

def draw(self, screen):
    help_string1 = '(W)Up (S)Down (A)Left (D)Right'
    help_string2 = '     (R)Restart (Q)Exit'
    gameover_string = '           GAME OVER'
    win_string = '          YOU WIN!'
    def cast(string):
        screen.addstr(string + '\n')
    
    #繪制水平分割線
    def draw_hor_separator():
        line = '+' + ('+------' * self.width + '+')[1:]
        separator = defaultdict(lambda: line)
        if not hasattr(draw_hor_separator, "counter"):
            draw_hor_separator.counter = 0
        cast(separator[draw_hor_separator.counter])
        draw_hor_separator.counter += 1

    def draw_row(row):
        cast(''.join('|{: ^5} '.format(num) if num > 0 else '|      ' for num in row) + '|')

    screen.clear()
    
    cast('SCORE: ' + str(self.score))
    if 0 != self.highscore:
        cast('HGHSCORE: ' + str(self.highscore))
    
    for row in self.field:
        draw_hor_separator()
        draw_row(row)
    
    draw_hor_separator()
    
    if self.is_win():
        cast(win_string)
    else:
        if self.is_gameover():
            cast(gameover_string)
        else:
            cast(help_string1)
    cast(help_string2)

完成主邏輯

完成以上工作后，我們就可以補完主邏輯了！

def main(stdscr):
    def init():
        #重置游戲棋盤
        game_field.reset()
        return 'Game'

    def not_game(state):
        #畫出 GameOver 或者 Win 的界面
        game_field.draw(stdscr)
        #讀取用戶輸入得到action，判斷是重啟游戲還是結束游戲
        action = get_user_action(stdscr)
        responses = defaultdict(lambda: state) #默認是當前狀態，沒有行為就會一直在當前界面循環
        responses['Restart'], responses['Exit'] = 'Init', 'Exit' #對應不同的行為轉換到不同的狀態
        return responses[action]

    def game():
        #畫出當前棋盤狀態
        game_field.draw(stdscr)
        #讀取用戶輸入得到action
        action = get_user_action(stdscr)

        if action == 'Restart':
            return 'Init'
        if action == 'Exit':
            return 'Exit'
        if game_field.move(action): # move successful
            if game_field.is_win():
                return 'Win'
            if game_field.is_gameover():
                return 'Gameover'
        return 'Game'


    state_actions = {
            'Init': init,
            'Win': lambda: not_game('Win'),
            'Gameover': lambda: not_game('Gameover'),
            'Game': game
        }

    curses.use_default_colors()
    game_field = GameField(win=32)
    

    state = 'Init'

    #狀態機開始循環
    while state != 'Exit':
        state = state_actions[state]()

運行

填上最后一行代碼：

curses.wrapper(main)

運行看看吧！

$ python 2048.py

詳細代碼參見：http://git.shiyanlou.com/littlemonkey/shiyanlou_cs368/src/master/2048.py