基於curses的2048遊戲

本文主要完成了2048遊戲，用curses庫對界面的顯示，用SQlite數據庫保存遊戲數據。

1． 引言
在突發奇想中，想到了經常玩的2048遊戲，於是便用python實現了簡易版的2048遊戲，實現了基本的上下左右操作，以及退出，重新開始，繼續等選項，並且鏈接SQlite數據庫記錄最高分。
2． 系統結構
該程序設計採用有限狀態機進行設計。因此實現系統結構介紹分爲有限狀態機設計介紹和主要邏輯介紹。
2.1．系統總體設計
該程序設計採用開發平臺爲Visual Studio Code，採用程序語言爲Python。所使用的Python模塊爲curses模塊、sqlite3模塊、random模塊、collections模塊。不同的Python模塊分別用於實現不同的程序功能
表1 模塊-功能對照表

2.2．邏輯實現設計
此次遊戲採用了常見的遊戲設計模式，有限狀態機，2048遊戲有，初始狀態（Init），遊戲狀態（Game），退出狀態（Exit），勝利狀態（Win），失敗狀態（Gameover），繼續狀態（Goon），重新開始狀態（restart），狀態之間的關係如圖所示：

設計也分三個模塊分別設計，數據庫模塊，主要邏輯模塊，狀態模塊
數據庫模塊：採用的是輕量級數據庫SQlite，內置於Python3，因爲目前只需要記錄最高分數，不需要使用Mysql等其他數據庫。實現基本的增改查。
主要邏輯模塊: 2048遊戲最主要邏輯是當按下代表上下左右的鍵時，能夠移動並且數字相同的合併達到目標數字贏下游戲。移動邏輯如圖：

圖2 移動邏輯
實現原理：創建44二維數組，將每一行中不爲0的數按順序移動至最前方，若相鄰數字相同，則至前方數字爲0，後方爲數字2，再進行將每一行中不爲0的數按順序移動至最前方的操作，完成左移。上移，右移，下移則是將矩陣進行反轉以或轉置操作。如圖所示：

圖3 其他方位邏輯
狀態模塊：實現狀態機轉換，將WASDQRGwasdqrg用字典對應每個狀態，獲取用戶按下的值返回狀態，不同狀態對應不同的不同的處理函數，只要狀態機不等於EXIT，則無限循環等待用戶操作。如圖4

圖4 狀態模塊邏輯
3． 代碼實現
引入模塊

import sqlite3  
import curses  
from random import randrange, choice  # generate and place new tile  
from collections import defaultdict  

將WASDQRGwasdqrg與狀態用字典關聯

letter_codes = [ord(ch) for ch in 'WASDRQGwasdrqg']  	  
actions = ['Up', 'Left', 'Down', 'Right', 'Restart', 'Exit','Goon']  
actions_dict = dict(zip(letter_codes, actions * 2)) 

獲得用戶按下的按鍵

def get_user_action(keyboard):
    char = 'N'
    while char not in actions_dict:
        # 返回按下鍵的 ascii 碼值
        char = keyboard.getch()

    return actions_dict[char]

狀態模塊：對各個狀態實現操作函數，將狀態與函數關聯

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'], responses['Goon'] = 'Init', 'Exit' , 'Goon'  # 對應不同的行爲轉換到不同的狀態
        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'

    def Goon():
        game_field.draw(stdscr)
        game_field.Goon()
        return 'Game'

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

    #使用默認顏色
    curses.use_default_colors()
    # curses.init_pair(1, curses.COLOR_RED, curses.COLOR_BLACK)
    # curses.init_pair(2, curses.COLOR_MAGENTA, curses.COLOR_BLACK)
    # curses.init_pair(3, curses.COLOR_YELLOW, curses.COLOR_BLACK)
    # curses.init_pair(4, curses.COLOR_GREEN, curses.COLOR_BLACK)
    # curses.init_pair(5, curses.COLOR_CYAN, curses.COLOR_BLACK)
    # curses.init_pair(6, curses.COLOR_BLUE, curses.COLOR_BLACK)


    # 設置終結狀態最大數值爲 32
    game_field = GameField(win=16)

    state = 'Init'

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

    game_field.reset()

主要邏輯模塊，分爲遊戲邏輯與繪製界面兩部分
其中游戲邏輯部分，實現了上下左右對應的操作，判斷遊戲勝負，初始化。

    def Goon(self):
        self.win_value *= 2

    def reset(self):
        if self.score > self.highscore:
            self.highscore = self.score
        self.dbase.update(self.highscore)
        self.score = 0
        #定義了二維數組
        self.field = [[0 for i in range(self.width)] for j in range(self.height)]
        self.spawn()
        self.spawn()

    def move(self, direction):
        def move_row_left(row):
            def tighten(row):  # squeese non-zero elements together
                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)))

        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):  # true if there'll be change in i-th tile
                if row[i] == 0 and row[i + 1] != 0:  # Move
                    return True
                if row[i] != 0 and row[i + 1] == row[i]:  # Merge
                    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!'
        goOn_string = '          Go on(G)'

        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) + '  GOAL: ' + str(self.win_value))
        cast('HIGHSCORE: ' + str(self.highscore))
        for row in self.field:  
            draw_hor_separator()
            draw_row(row)
        draw_hor_separator()
        if self.is_win():
            cast(win_string)
            cast(goOn_string)
        else:
            if self.is_gameover():
                cast(gameover_string)
            else:
                cast(help_string1)
        cast(help_string2)

數據庫模塊，完成鏈接數據庫，創建表，插入，更新以及查找功能

    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!'
        goOn_string = '          Go on(G)'

        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) + '  GOAL: ' + str(self.win_value))
        cast('HIGHSCORE: ' + str(self.highscore))
        for row in self.field:  
            draw_hor_separator()
            draw_row(row)
        draw_hor_separator()
        if self.is_win():
            cast(win_string)
            cast(goOn_string)
        else:
            if self.is_gameover():
                cast(gameover_string)
            else:
                cast(help_string1)
        cast(help_string2)

4． 實驗
初始界面：

勝利：

5． 總結與展望
此次實現這個遊戲，讓我瞭解遊戲的基本設計模式，有限狀態機設計，對於Python的很多函數也有了較好的理解，比如Zip，也對一些知識點更加深入理解，當然這個遊戲並不完美，並沒有實現顏色顯示，以及界面大小調整和輸入法切換，較爲遺憾，此次並沒有有到Pygame模塊來實現，是因爲curses較簡單，日後會用Pygame實現。
6． 參考文獻
《Python幫助文檔》
《PYTHON 數據庫 之 sqlite3》
https://blog.csdn.net/xuzhexing/article/details/90600228

如需完整代碼
https://download.csdn.net/download/qq_41030253/12579608