程式碼來源：https://www.shiyanlou.com/courses/368/labs/1172/document

小白，最近看到實驗樓的2048的小遊戲，在程式碼上帶了自己的註釋。

前期準備:

1. 有限狀態機      ##https://www.cnblogs.com/21207-iHome/p/6085334.html
   
2. defaultdict()    ##https://blog.csdn.net/real_ray/article/details/17919289
3. zip()    ##zip() 函式用於將可迭代的物件作為引數，將物件中對應的元素打包成一個個元組，然後返回由這些元組組成的列表。
4. assert  ##在開發一個程式時候，與其讓它執行時崩潰，不如在它出現錯誤條件時就崩潰（返回錯誤）。
5. randrange()  ##randrange() 方法返回指定遞增基數集合中的一個隨機數，基數預設值為1。
6. any()   ##any() 函式用於判斷給定的可迭代引數 iterable 是否全部為空物件，如果都為空、0、false，則返回 False，如果不都為空、0、false，則返回 True。
7. curses()   //關於curses的使用與安裝，將會另外開一篇文章來說

#-*- coding:utf-8 -*-
import curses
from random import randrange, choice
from collections import defaultdict


letter_codes = 
 
[ord(ch) for ch in 'WASDRQwasdrq']   #ord函式是把字元轉換成對應的數字
actions = ['Up','Left','Down','Right','Restart','Exit']
actions_dict = dict(zip(letter_codes,actions * 2))  #zip是把元組的數值對應起來
def get_user_action(keyboard):
char = "N"    ##初始值為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)]       ##相當於旋轉90度。zip後加*，是把行變成列，把列變成行
def invert(field):
return [row[::-1] for row in field]   #步長為-1。相當於是調轉180，把前後列表調轉
##Merge and tighten,移動方向時候應該有的邏輯判斷, 整個遊戲的畫面繪製，規則定製等。
class GameField(object):
def __init__(self,height=4,width=4,win=2048):
self.height = height
self.width = width
self.win_value = win
self.score = 0
self.highscore = 0
self.reset()

    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)]   #橫縱座標恢復為0
self.spawn()    #呼叫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))]   #其餘位置用0來fill in
return new_row

            def merge(row):
pair = False
new_row = []
                for i in range(len(row)):    #在格子裡迴圈
if pair:    #如果pair為真
new_row.append(2 * row[i])   #乘以2的值追加到new_row中
self.score += 2 * row[i]
                        pair = False
                    else:
if i + 1 < len(row) and row[i] == row[i+1]:  #如果pair為假，然後i+1還沒到邊界，並且row[i]=row[i+1]
pair = True              ##那麼執行上面的pair為真的部分
new_row.append(0)        #追加0
else:
new_row.append(row[i])   #pair為假，不能合併，超出邊界，多加row[i]
assert len(new_row) == len(row)    ##報錯提醒
return new_row
            return tighten(merge(tighten(row)))    #先擠在一起，然後合併，然後再擠在一起
moves = {}

        #將只有一個方向左，旋轉90度成為向上（transpose(field))，利用左方向調轉（invert(field))成為右方向。因此擁有四個方向
moves['Left'] = lambda field: [move_row_left(row) for row in field]
        moves['Right'] = lambda field: invert(moves['Left'](invert(field)))        ##moves['Left']已經定義了merge跟tighten的操作
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)   #i在格子中，並且i的值超出了2048
def is_gameover(self):
return not any(self.move_is_possible(move) for move in actions)

###遊戲頁面繪製
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='        Congratulation! 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('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)
        else:
if self.is_gameover():
cast(gameover_string)
            else:
cast(help_string1)
        cast(help_string2)

##隨機生成2或者4
def spawn(self):
new_element = 4 if randrange(100) > 89 else 2   #100次有89次出現4
(i,j) = choice([(i,j) for i in range(self.width) for j in range(self.height) if self.field[i][j]==0])
        ##就是2,4隨機出現的區域，要在width，height的裡面。前提self.field[i][j]==0
self.field[i][j] = new_element   ##那麼, 2,4出現的要獲取他的橫縱座標
##判斷是否可移動
def move_is_possible(self, direction):
def row_is_left_movable(row):
def change(i):    ##True if there will be change in i-th tile
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))   ##any()為一個函式，全為0為false
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
##Main Logic
def main(stdsrc):
def init():
#重置遊戲棋盤
game_field.reset()
        return 'Game'
def not_game(state):
#畫出GameOver或者Win的介面
game_field.draw(stdsrc)
        #讀取使用者輸入得到action，判斷是重啟遊戲還是結束遊戲
action = get_user_action(stdsrc)

        responses = defaultdict(lambda:state) #預設當前狀態，沒有行為就會在當前介面迴圈
responses['Restart'],responses['Exit'] = 'Init','Exit' #對應不同的行為轉換到不同的狀態
return responses[action]

    def game():
##畫出當前棋盤狀態
game_field.draw(stdsrc)
        #Getthe action
action = get_user_action(stdsrc)

        if action == 'Restart':
return 'Init'
if action == 'Exit':
return 'Exit'
if game_field.move(action):
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()  ##Color
    #設定終結狀態最大數值為32
game_field = GameField(win=32)

    state='Init'
#狀態機開始迴圈
while state != 'Exit':
state = state_actions[state]()

curses.wrapper(main)


##Once the callable returns, wrapper() will restore the original state of the terminal.

##執行結果

一路上遇到的問題:

1. Redirection is not supported.    >>>>把pycharm改成cmd來執行
2. import curses的問題

懶，決定在這裡也講述如何在Windows上安裝curses。 Curses庫在Windows下沒有直接的安裝的，有大神搞了在windows下的wheel版。

•  檢視自己的pip支援什麼格式內容

E:\MyDownloads\Download>python
Python 3.6.3 (v3.6.3:2c5fed8, Oct  3 2017, 18:11:49) [MSC v.1900 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> import pip
>>> print(pip.pep425tags.get_supported())
[('cp36', 'cp36m', 'win_amd64'), ('cp36', 'none', 'win_amd64'), ('py3', 'none', 'win_amd64'), ('cp36', 'none', 'any'), ('cp3', 'non
e', 'any'), ('py36', 'none', 'any'), ('py3', 'none', 'any'), ('py35', 'none', 'any'), ('py34', 'none', 'any'), ('py33', 'none', 'an
y'), ('py32', 'none', 'any'), ('py31', 'none', 'any'), ('py30', 'none', 'any')]

>>> ^Z

• 從以下網站中download wheel檔案。

從上面可以得知， 我的pip支援的是cp36的。於是從以下網址下載cp36的wheel

https://www.lfd.uci.edu/~gohlke/pythonlibs/#curses

• 一鍵安裝  

Successfully installed curses-2.2

以後目標：

1. 改變顏色跟邊框曲線2. 把數字改變為朝代。相同朝代碰撞能變為下一個朝代。