python五子棋

之後不更新了,把之前的一些東西發出來。node

 

這是一個命令行環境的五子棋程序。使用了minimax算法。算法

除了百度各個棋型的打分方式,全部代碼皆爲本人所擼。本程序結構與以前的井字棋、黑白棋如出一轍。app

有一點小問題,沒時間弄了,就這樣吧。函數

1、效果圖

(略)測試

2、完整代碼

from functools import wraps
import time
import csv

''' 
五子棋 Gobang 
做者:hhh5460
時間:20181213
'''


#1.初始化棋盤
#------------
def init_board():
    '''
    初始化棋盤
    
    棋盤規格 15*15
    
    以下所示:
    board = [[. . . . . . . . . . . . . . .],
             [. . . . . . . . . . . . . . .],
             [. . . . . . . . . . . . . . .],
             [. . . . . . . . . . . . . . .],
             [. . . . . . . . . . . . . . .],
             [. . . . . . . . . . . . . . .],
             [. . . . . . . . . . . . . . .],
             [. . . . . . . . . . . . . . .],
             [. . . . . . . . . . . . . . .],
             [. . . . . . . . . . . . . . .],
             [. . . . . . . . . . . . . . .],
             [. . . . . . . . . . . . . . .],
             [. . . . . . . . . . . . . . .],
             [. . . . . . . . . . . . . . .],
             [. . . . . . . . . . . . . . .]]

    其中: 
        . – 未被佔用 
        X – 被黑棋佔用 
        O – 被白棋佔用
    '''
    print('Init board...')
    time.sleep(0.5)
    n = 15
    board = [['.' for _ in range(n)] for _ in range(n)]
    
    return board

#2.肯定玩家,執黑先走
#--------------------
def get_player():
    '''
    人類玩家選擇棋子顏色(黑'X'先走)
    '''
    humancolor = input("Enter your color. (ex. 'X' or 'O'):").upper()
    computercolor = ['X', 'O'][humancolor == 'X']
    
    return computercolor, humancolor

#3.進入循環
#----------

#4.打印棋盤、提示走子
#------------------------------
def print_board(board): #ok
    '''
    打印棋盤、比分
    
    開局:
      1 2 3 4 5 6 7 8 9 a b c d e f
    1 . . . . . . . . . . . . . . .
    2 . . . . . . . . . . . . . . .
    3 . . . . . . . . . . . . . . .
    4 . . . . . . . . . . . . . . .
    5 . . . . . . . . . . . . . . .
    6 . . . . . . . . . . . . . . .
    7 . . . . . . . . . . . . . . .
    8 . . . . . . . . . . . . . . .
    9 . . . . . . . . . . . . . . .
    a . . . . . . . . . . . . . . .
    b . . . . . . . . . . . . . . .
    c . . . . . . . . . . . . . . .
    d . . . . . . . . . . . . . . .
    e . . . . . . . . . . . . . . .
    f . . . . . . . . . . . . . . .
    '''
    axises = list('123456789abcdef')
    print(' ', ' '.join(axises))
    for i, v in enumerate(axises): 
        print(v, ' '.join(board[i]))

#5.思考走法、放棄終止
#--------------------
def get_human_move(board, color): #ok
    '''
    取人類玩家走法
    '''
    giveup = True # 放棄標誌
    
    legal_moves = _get_legal_moves(board, color)
    
    #print(','.join([translate_move(move) for move in legal_moves]), len(legal_moves))
    
    while True:
        _move = input("Enter your move.(ex.'cd' means row=c col=d): ").lower()
        
        move = translate_move(_move)
        
        if move in legal_moves:
            giveup = False # 不放棄
            break
    
    return move, giveup

def _get_all_lianxin(board, move, color): #ok
    '''
    取當前點位落子後連星
    
    1.按照棋盤兩連、三連、四連的個數 double triple quadra penta
    '''
    n = len(board)
    uncolor = ['X', 'O'][color == 'X'] # 反色
    
    lianxin = [] # 連星數,len(lianxin) == 4
    
    directions = ((0,1),(1,0),(1,1),(1,-1)) # 東, 南, 東南, 西南
    for direction in directions:
        dr, dc = direction      # 步幅
        #r, c = move # 起點
        
        count = 1                  # 連星數,算上起點(落子位置)
        jump_count = [0, 0]        # 順、反方向跳開一個空格以後的連星數
        jump_flag = [False, False] # 順、反方向跳開一個空格的標誌
        block = [False, False]     # 順、反方向是否堵死
        #name = ['','']
        
        for i,v in enumerate([1, -1]): # 順、反方向分別用一、-1表示
            dr, dc = v*dr, v*dc           # 步幅
            r, c = move[0]+dr, move[1]+dc # 先走一步
            while True:
                if not _is_on_board(board, [r, c]) or board[r][c] == uncolor: # 不在棋盤內,或對方棋子
                    block[i] = True  # 被堵死
                    break
                if board[r][c] == '.':                                                      # 爲空
                    if not _is_on_board(board, [r+dr, c+dc]) or board[r+dr][c+dc] != color: # 且下一格,不在棋盤內、或者非己方棋子
                        break
                    if jump_flag[i] == True: # 前面已經跳了一格了,則終止
                        break                # 能力所限,不考慮又跳一格的狀況!!!
                    else:
                        jump_flag[i] = True
                elif board[r][c] == color:
                    if jump_flag[i] == True:
                        jump_count[i] += 1
                    else:
                        count += 1
                
                r, c = r + dr, c + dc # 步進
                
            
        
        lianxin.append([count, jump_count, block])
    
    return lianxin
    
def _move_score(board, move): #ok
    '''
    對該落子位置「打分」
    
    這個邏輯太複雜了,代碼又長又臭!!暫時不考慮簡化
    
    棋型分值:
    0.活五     +100000
    1.死五  +100000
    2.活四     +10000
    3.死四     +1000
    4.活三     +1000
    5.死三     +100
    6.活二     +100
    7.死二     +10
    8.活一     +10
    9.死一  +2
    
    特別說明:
   10.跳N   兩邊棋型分相加 * 上一級分值的20% ?商榷
    
    
    lianxin == [[2,[0,0],[True,False]],
                [1,[0,0],[True,False]],
                [3,[1,0],[False,False]],
                [3,[2,1],[True,False]]]
    '''
    #           死一,  活一,  死二,  活二,  死三,  活三,  死四,  活四,  死五,  活五
    scores = [     2,    10,    10,   100,   100,  1000,  1000, 10000,100000,100000]
    sum_score = 0
    for color in ['X','O']:
        for lianxin in _get_all_lianxin(board, move, color):
            count, jump_count, block = lianxin
            if jump_count[0] > 0 and jump_count[1] > 0: # 狀況一:兩邊跳
                if block[0] == True and block[1] == True:
                    if count + jump_count[0] + jump_count[1] + 2 < 5: continue
                else:
                    # 這邊跳了
                    if block[0] == True:  # 有跳的,先把分數加了再說(查表加分)
                        sum_score += scores[jump_count[0]*2-2] # 加死的分
                        sum_score += min(scores[(jump_count[0]+count)*2-2] * 0.2, 200) # 上一級的20%
                    else:
                        sum_score += scores[jump_count[0]*2-1] # 加活的分
                        sum_score += min(scores[(jump_count[0]+count)*2-1] * 0.2, 200) # 上一級的20%
                    
                    # 這邊也跳了
                    if block[1] == True:  # 有跳的,先把分數加了再說(查表加分)
                        sum_score += scores[jump_count[1]*2-2] # 加死的分
                        sum_score += min(scores[(jump_count[1]+count)*2-2] * 0.2, 200) # 上一級的20%
                    else:
                        sum_score += scores[jump_count[1]*2-1] # 加活的分
                        sum_score += min(scores[(jump_count[1]+count)*2-1] * 0.2, 200) # 上一級的20%
                    
                    # 中間
                    sum_score += scores[count*2-1]  # 中間加活的分
                
            elif jump_count[0] > 0 and jump_count[1] == 0: # 狀況二:有一邊跳
                if block[0] == True and block[1] == True:
                    if count + jump_count[0] + jump_count[1] + 1 < 5: continue
                else:
                    # 跳的這邊
                    if block[0] == True:  # 先把跳那邊的分數加了再說(查表加分)
                        sum_score += scores[jump_count[0]*2-2] # 加死的分
                        sum_score += min(scores[(jump_count[0]+count)*2-2] * 0.2, 200) # 上一級的20%
                    else:
                        sum_score += scores[jump_count[0]*2-1] # 加活的分
                        sum_score += min(scores[(jump_count[0]+count)*2-1] * 0.2, 200) # 上一級的20%
                    
                    # 沒跳的那邊
                    if block[1] == True:
                        sum_score += scores[count*2-2] # 加死的分
                    else:
                        sum_score += scores[count*2-1] # 加活的分
                    
            elif jump_count[1] > 0 and jump_count[0] == 0: # 狀況三:另外一邊跳
                if block[0] == True and block[1] == True:
                    if count + jump_count[0] + jump_count[1] + 1 < 5: continue
                else:
                    # 跳的這邊
                    if block[1] == True:  # 先把跳那邊的分數加了再說(查表加分)
                        sum_score += scores[jump_count[1]*2-2] # 加死的分
                        sum_score += min(scores[(jump_count[1]+count)*2-2] * 0.2, 200) # 上一級的20%
                    else:
                        sum_score += scores[jump_count[1]*2-1] # 加活的分
                        sum_score += min(scores[(jump_count[1]+count)*2-1] * 0.2, 200) # 上一級的20%
                    
                    # 沒跳的那邊
                    if block[0] == True:
                        sum_score += scores[count*2-2] # 加死的分
                    else:
                        sum_score += scores[count*2-1] # 加活的分
                    
            elif jump_count[0] == 0 and jump_count[1] == 0: # 狀況四:兩邊都沒跳
                if block[0] and block[1]:  # 兩邊都堵死了
                    if count == 5: # 等於5才加,不然不加
                        sum_score += scores[count*2-2] # -1,-2同樣
                elif block[0] or block[1]: # 只堵死一邊
                    sum_score += scores[count*2-2] # 加死的分
                else:
                    sum_score += scores[count*2-1] # 加活的分

    return sum_score
    
def _get_center_enmpty_points(board): #ok
    '''
    取中心點附近的空位
    
    從中心點逐圈順時針掃描,若連續兩圈未有棋子,則中止
    '''
    n = len(board)
    
    center_point = [n//2, n//2] # 中心點[7,7],即'88'
    
    c1 = 0      # 空圈計數
    legal_moves = [] # 保存空位
    for i in range(8): #從內到外掃描8圈
        c2 = True   # 空圈標誌
        
        if i == 0:
            points = [[n//2, n//2]]
        else:
            # points = [第7-i行] + [第7+i列] + [第7+i行] + [第7-i列] # 從左上開始,順時針一圈
            points = [[7-i,c] for c in range(7-i,7+i)] + \
                     [[r,7+i] for r in range(7-i,7+i)] + \
                     [[7+i,c] for c in range(7+i,7-i,-1)] + \
                     [[r,7-i] for r in range(7+i,7-i,-1)]
                     
        for point in points:
            if board[point[0]][point[1]] == '.': # 遇到空位,則
                legal_moves.append(point) # 保存點位
            else:
                c2 = False                # 此圈非空
        
        if c2 == True: # 若此圈爲空,空圈計數器加1
            c1 += 1
            if c1 == 2: break
        else:       # 不然,清零
            c1 = 0
    
    return legal_moves # 越前,棋盤點位分值越高!

def minimax(board, color, maximizingPlayer, depth):
    '''
    極大極小算法
    
    其中:
    maximizingPlayer = True  #己方
    
    用例:
    _, move = minimax(board, 'X', True, 4) # 假設計算機執黑'X'
    
    #參見: https://en.wikipedia.org/wiki/Minimax
    function minimax(node, depth, maximizingPlayer) is
        if depth = 0 or node is a terminal node then
            return the heuristic value of node
        if maximizingPlayer then
            value := −∞
            for each child of node do
                value := max(value, minimax(child, depth − 1, FALSE))
            return value
        else (* minimizing player *)
            value := +∞
            for each child of node do
                value := min(value, minimax(child, depth − 1, TRUE))
            return value

    (* Initial call *)
    minimax(origin, depth, TRUE)
    '''
    pass
    
def get_computer_move(board, color):
    '''
    取計算機玩家走法
    
    計算機走子策略:
        1.對全部合法的落子位置逐個「打分」(如何「打分」,決定了計算機下棋的水平)
        2.取全部分值最高的落子位置
    '''
    print('Computer is thinking...', end='')
    legal_moves = _get_legal_moves(board, color)
    
    scores = [_move_score(board, move) for move in legal_moves]
    
    max_score = max(scores) # 最高分值
    best_move = legal_moves[scores.index(max_score)]
    
    print("'{}'".format(translate_move(best_move)))
    return best_move
    
def    _is_legal_move(board, move): #ok
    '''
    判斷落子位置是否合法
    
    說明:只要在棋盤內,且爲空,即合法
    
    '''
    if _is_on_board(board, move) and board[move[0]][move[1]] == '.': 
        return True
    
    return False
    
def    _get_legal_moves(board, color): #ok
    '''
    取當前顏色棋子全部的合法走法
    
    返回格式:[[x1,y1], [x2,y2], ...]
    '''
    legal_moves = _get_center_enmpty_points(board)
    
    return legal_moves
    
def _is_on_board(board, move): #ok
    '''
    判斷點位是否在棋盤範圍內
    '''
    n = len(board)
    
    return move[0] in range(n) and move[1] in range(n)
    
def translate_move(move): #ok
    '''
    轉換座標
    
    如'1a'可轉換爲[0,9];又如[9,10]轉換爲'ab'
    
    此函數,只是爲了方便,不是必要的
    '''
    axises = list('123456789abcdef')

    if type(move) is str: # 如'cd'
        row = axises.index(move[0]) 
        col = axises.index(move[1])
        _move = [row, col] # 得[2,3]
    elif type(move) is list: # 如[2,3]
        row = axises[move[0]]
        col = axises[move[1]]
        _move = '{}{}'.format(row, col) # 得'cd'

    return _move
    
#6.落子
#----------
def do_move(board, move, color): #ok
    '''
    在當前位置落子
    '''
    assert board[move[0]][move[1]] == '.'
    
    board[move[0]][move[1]] = color
  
#7.判斷局面、是否終止
#------------------------------
def check_board(board, color): #ok
    '''
    檢查棋盤
    
    返回:是否勝利
    '''
    n = len(board)
    
    directions = ((0,1),(1,0),(1,1),(1,-1)) # 東, 南, 東南, 西南
    # 四個搜索方向的起點(座標),分四組。
    # 形如:[[第1列的點], [第1行的點], [第1列+第1行的點], [第1行+第n列的點]]
    all_start_points = [[[i, 0] for i in range(n)],
                        [[0, j] for j in range(n)],
                        [[i, 0] for i in range(n-4)] + [[0, j] for j in range(1,n-4)], # 排除了長度小於5,及重複的狀況
                        [[0, j] for j in range(4,n)] + [[i, n-1] for i in range(1,n-4)]]
    
    for direction, start_points in zip(directions, all_start_points):
        dr, dc = direction     # 步幅
        for start_point in start_points:
            r, c = start_point # 起點
            count = 0
            while _is_on_board(board, [r, c]):
                if board[r][c] == color:
                    count += 1
                    if count == 5:
                        return True
                else:
                    count = 0
                
                r, c = r + dr, c + dc # 步進
    
    return False

def check_board__(board, color): # 廢棄!
    '''
    檢查棋盤 (不如上面的方式簡潔)
    
    返回 是否勝利
    '''
    n = len(board)
    uncolor = ['X', 'O'][color == 'X'] # 反色
    
    # 1.行搜索
    for i in range(n):
        count = 0
        for j in range(n):
            if board[i][j] == color:
                count += 1
                if count == 5:
                    return True # 'Winner is ' + color
            elif board[i][j] == uncolor:
                count = 0
    
    # 2.列搜索
    for j in range(n):
        count = 0
        for i in range(n):
            if board[i][j] == color:
                count += 1
                if count == 5:
                    return True # 'Winner is ' + color
            elif board[i][j] == uncolor:
                count = 0
    
    # 3.斜搜索k=1左上右下
    #3.a.k=1對角線上方
    for j in range(n-4):     # 終止列n-4
        count = 0
        for i in range(n-j): # 終止行n-j
            if board[i][j+i] == color:
                count += 1
                if count == 5:
                    return True
            elif board[i][j+i] == uncolor:
                count = 0
                
    #3.b.k=1對角線下方
    for i in range(1, n-4):     # 終止行n-4
        count = 0
        for j in range(n-i): # 終止列n-i
            if board[i+j][j] == color:
                count += 1
                if count == 5:
                    return True
            elif board[i+j][j] == uncolor:
                count = 0
                
    # 4.斜搜索k=-1左下右上
    #4.a.k=-1對角線下方
    for j in range(n-4):     # 終止列n-4
        count = 0
        for i in range(n-j): # 終止行n-j
            if board[n-i-1][j+i] == color:
                count += 1
                if count == 5:
                    return True
            elif board[n-i-1][j+i] == uncolor:
                count = 0
    
    #4.b.k=-1對角線上方
    for j in range(4, n):
        count = 0
        for i in range(n-1):
            if board[i][j-i] == color:
                count += 1
                if count == 5:
                    return True
            elif board[i][j-i] == uncolor:
                count = 0
    return False
    



#8.遊戲結束,返回信息
#--------------------

    
def logging(func): #ok
    '''
    記錄遊戲相關信息  (裝飾器)
    
    包括:
    開始時間、比賽耗時、棋盤大小、黑棋玩家、白棋玩家、遊戲比分、本局棋譜
    
    保存到reversi.csv文件
    '''
    @wraps(func)
    def wrap(*args, **kwargs):
        try:
            start = time.strftime("%Y%m%d %H:%M:%S", time.localtime()) # 開始時間
            
            t1 = time.time()
            info = func(*args,**kwargs) # 棋盤大小、黑棋玩家、白棋玩家、遊戲比分、本局棋譜(主程序)
            t2 = time.time()
            t = int(t2 - t1) # 比賽耗時
            
            line = [start, t, *info]
            
            with open('gobang.csv', 'a') as f:
                writer = csv.writer(f, lineterminator='\n')
                writer.writerow(line) # 寫入
        except Exception as e:
            pass
    
    return wrap

#==========================================
# 主函數
#==========================================
#@logging
def main(): #ok
    '''
    主程序

    人機對戰

    流程:
    1.初始化棋盤
    2.肯定棋手,黑先
    3.進入循環
      4.打印棋盤,提示走子
      5.思考走法,放棄終止
      6.落子
      7.檢查棋盤,是否終止
      8.切換棋手
    9.遊戲結束,返回信息
    '''
    # 1.初始化棋盤
    board = init_board()
    
    # 2.肯定玩家,執黑先走
    computer_color, human_color = get_player()
    current_color = 'X'
    
    record = '' # 棋譜,如'X:ab O:aa X:ba ...'
    # 3.進入循環
    while True:
        # 4.打印棋盤、提示走子
        print_board(board)
        print("Now turn to '{}'...".format(current_color))
        
        # 5.思考走法,記錄棋譜
        if current_color == computer_color:
            move = get_computer_move(board, current_color)
        elif current_color == human_color:
            move, giveup = get_human_move(board, current_color)
            if giveup == True: break # 放棄則終止
        
        record = record + ' {}:{}'.format(current_color, translate_move(move)) # 錄入棋譜
        
        # 6.落子
        do_move(board, move, current_color)
        
        # 7.判斷局面
        done = check_board(board, current_color) # 返回終止標誌
        
        # 7_1.終止
        if done == True:
            print_board(board)
            print("Game over! Winner is '{}'".format(current_color))
            break
        
        # 8.切換棋手
        current_color = ['X', 'O'][current_color == 'X']


#測試
def test_get_center_enmpty_points():
    '''
    #         1 2 3 4 5 6 7 8 9 a b c d e f
    board = [[. . . . . . . . . . . . . . .],#1
             [. . . . . . . . . . . . . . .],#2
             [. . . . . . . . . . . . . . .],#3
             [. . . . . . . . . . . . . . .],#4
             [. . . . . . . . . . . . . . .],#5
             [. . . . . . . . . . . . . . .],#6
             [. . . . . . . . . . . . . . .],#7
             [. . . . . . . . . . . . . . .],#8
             [. . . . . . . . . . . . . . .],#9
             [. . . . . . . . . . . . . . .],#a
             [. . . . . . . . . . . . . . .],#b
             [. . . . . . . . . . . . . . .],#c
             [. . . . . . . . . . . . . . .],#d
             [. . . . . . . . . . . . . . .],#e
             [. . . . . . . . . . . . . . .]]#f
             
    #         1 2 3 4 5 6 7 8 9 a b c d e f
    board = [[. . . . . . . . . . . . . . .],#1
             [. . . . . . . . . . . . . . .],#2
             [. . . . . . . . . . . . . . .],#3
             [. . . . . . . . . . . . . . .],#4
             [. . . . . . . . . X . . . . .],#5
             [. . . . . . X . . . . . . . .],#6
             [. . . . . O . . X O . . . . .],#7
             [. . . . . X X O X . . . . . .],#8
             [. . . . . X O X . . . . . . .],#9
             [. . . . . . . . . . X . . . .],#a
             [. . . X . . . . . . . . . . .],#b
             [. . X . . . . . . . . . . . .],#c
             [. O . . . . . . . . . . . . .],#d
             [. . . . . . . . . . . . . . .],#e
             [. . . . . . . . . . . . . . .]]#f
    '''
    print('Testing _get_center_enmpty_points()...')
    
    #          1   2   3   4   5   6   7   8   9   a   b   c   d   e   f
    board = [['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],#1
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],#2
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],#3
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],#4
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],#5
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],#6
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],#7
             ['.','.','.','.','.','.','.','X','.','.','.','.','.','.','.'],#8
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],#9
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],#a
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],#b
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],#c
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],#d
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],#e
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.']]#f
    empty_points = _get_center_enmpty_points(board)
    
    translate_points = [translate_move(move) for move in empty_points]
    #print(translate_points)
    assert translate_points == ['77','78','79','89','99','98','97','87', '66','67','68','69','6a','7a','8a','9a','aa','a9','a8','a7','a6','96','86','76']
    
    #          1   2   3   4   5   6   7   8   9   a   b   c   d   e   f
    board = [['.','.','.','.','.','.','.','X','.','.','.','.','.','.','.'],#1
             ['.','.','.','.','.','.','.','X','.','.','.','.','.','.','.'],#2
             ['.','.','.','.','.','.','.','X','.','.','.','.','.','.','.'],#3
             ['.','.','.','.','.','.','.','X','.','.','.','.','.','.','.'],#4
             ['.','.','.','.','.','.','.','X','.','.','.','.','.','.','.'],#5
             ['.','.','.','.','.','.','.','X','.','.','.','.','.','.','.'],#6
             ['.','.','.','.','.','.','.','X','.','.','.','.','.','.','.'],#7
             ['.','.','.','.','.','.','.','X','.','.','.','.','.','.','.'],#8
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],#9
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],#a
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],#b
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],#c
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],#d
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],#e
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.']]#f
    empty_points = _get_center_enmpty_points(board)
    
    translate_points = [translate_move(move) for move in empty_points]
    print(translate_points)
    assert '11' in translate_points
    
    #          1   2   3   4   5   6   7   8   9   a   b   c   d   e   f
    board = [['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],#1
             ['.','.','.','.','.','.','.','X','.','.','.','.','.','.','.'],#2
             ['.','.','.','.','.','.','.','X','.','.','.','.','.','.','.'],#3
             ['.','.','.','.','.','.','.','X','.','.','.','.','.','.','.'],#4
             ['.','.','.','.','.','.','.','X','.','.','.','.','.','.','.'],#5
             ['.','.','.','.','.','.','.','X','.','.','.','.','.','.','.'],#6
             ['.','.','.','.','.','.','.','X','.','.','.','.','.','.','.'],#7
             ['.','.','.','.','.','.','.','X','.','.','.','.','.','.','.'],#8
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],#9
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],#a
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],#b
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],#c
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],#d
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],#e
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.']]#f
    empty_points = _get_center_enmpty_points(board)
    
    translate_points = [translate_move(move) for move in empty_points]
    print(translate_points)
    assert '11' in translate_points
    
    print('ok')
    
def test_move_score():
    '''
    _move_score(board, move, color)
    #         1 2 3 4 5 6 7 8 9 a b c d e f
    board = [[. . . . . . . . . . . . . . .],#1
             [. . . . . . . . . . . . . . .],#2
             [. . . . . . . . . . . . . . .],#3
             [. . . . . . . . . . . . . . .],#4
             [. . . . . . . . . . . . . . .],#5
             [. . . . . . . . . . . . . . .],#6
             [. . . . . . . . . . . . . . .],#7
             [. . . . . . . . . . . . . . .],#8
             [. . . . . . . . . . . . . . .],#9
             [. . . . . . . . . . . . . . .],#a
             [. . . . . . . . . . . . . . .],#b
             [. . . . . . . . . . . . . . .],#c
             [. . . . . . . . . . . . . . .],#d
             [. . . . . . . . . . . . . . .],#e
             [. . . . . . . . . . . . . . .]]#f
             
    #         1 2 3 4 5 6 7 8 9 a b c d e f
    board = [[. . . . . . . . . . . . . . .],#1
             [. . . . . . . . . . . . . . .],#2
             [. . . . . . . . . . . . . . .],#3
             [. . . . . . . . . . . . . . .],#4
             [. . . . . . . . . X . . . . .],#5
             [. . . . . . X . . . . . . . .],#6
             [. . . . . O . . X O . . . . .],#7
             [. . . . . X X O X . . . . . .],#8
             [. . . . . X O X . . . . . . .],#9
             [. . . . . . . . . . X . . . .],#a
             [. . . X . . . . . . . . . . .],#b
             [. . X . . . . . . . . . . . .],#c
             [. O . . . . . . . . . . . . .],#d
             [. . . . . . . . . . . . . . .],#e
             [. . . . . . . . . . . . . . .]]#f
    '''
    print('Testing _move_score()...')
    
    #          1   2   3   4   5   6   7   8   9   a   b   c   d   e   f
    board = [['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],#1
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],#2
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],#3
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],#4
             ['.','.','.','.','.','.','.','.','.','X','.','.','.','.','.'],#5
             ['.','.','.','.','.','.','X','.','.','.','.','.','.','.','.'],#6
             ['.','.','.','.','.','O','.','.','X','O','.','.','.','.','.'],#7
             ['.','.','.','.','.','X','X','O','X','.','.','.','.','.','.'],#8
             ['.','.','.','.','.','X','O','X','.','.','.','.','.','.','.'],#9
             ['.','.','.','.','.','.','.','.','.','.','X','.','.','.','.'],#a
             ['.','.','.','X','.','.','.','.','.','.','.','.','.','.','.'],#b
             ['.','.','X','.','.','.','.','.','.','.','.','.','.','.','.'],#c
             ['.','O','.','.','.','.','.','.','.','.','.','.','.','.','.'],#d
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],#e
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.']]#f
    #[count, jump_count, block] # 東, 南, 東南, 西南
    lianxin = _get_all_lianxin(board, [6,7], 'X')
    #print(lianxin)
    assert lianxin == [[2,[0,0],[True,False]],
                       [1,[0,0],[True,False]],
                       [3,[1,0],[False,False]],
                       [3,[2,1],[True,False]]]
    #           死一,  活一,  死二,  活二,  死三,  活三,  死四,  活四,  死五,  活五
    scores = [     2,    10,    10,   100,   100,  1000,  1000, 10000,100000,100000]
    assert _move_score(board, [6,7], 'X') == 10 + 2 + (1000 + 10 + 200) + (1000 + 10 + 10 + 200 + 200)
    
    print('ok')
    
def test_get_all_lianxin():
    '''
    get_all_lianxin(board, move, color)
    #         1 2 3 4 5 6 7 8 9 a b c d e f
    board = [[. . . . . . . . . . . . . . .],#1
             [. . . . . . . . . . . . . . .],#2
             [. . . . . . . . . . . . . . .],#3
             [. . . . . . . . . . . . . . .],#4
             [. . . . . . . . . . . . . . .],#5
             [. . . . . . . . . . . . . . .],#6
             [. . . . . . . . . . . . . . .],#7
             [. . . . . . . . . . . . . . .],#8
             [. . . . . . . . . . . . . . .],#9
             [. . . . . . . . . . . . . . .],#a
             [. . . . . . . . . . . . . . .],#b
             [. . . . . . . . . . . . . . .],#c
             [. . . . . . . . . . . . . . .],#d
             [. . . . . . . . . . . . . . .],#e
             [. . . . . . . . . . . . . . .]]#f
             
    #         1 2 3 4 5 6 7 8 9 a b c d e f
    board = [[. . . . . . . . . . . . . . .],#1
             [. . . . . . . . . . . . . . .],#2
             [. . . . . . . . . . . . . . .],#3
             [. . . . . . . . . . . . . . .],#4
             [. . . . . . . . . X . . . . .],#5
             [. . . . . . X . . . . . . . .],#6
             [. . . . . O . . X O . . . . .],#7
             [. . . . . X X O X . . . . . .],#8
             [. . . . . X O X . . . . . . .],#9
             [. . . . . . . . . . X . . . .],#a
             [. . . X . . . . . . . . . . .],#b
             [. . X . . . . . . . . . . . .],#c
             [. O . . . . . . . . . . . . .],#d
             [. . . . . . . . . . . . . . .],#e
             [. . . . . . . . . . . . . . .]]#f
    '''
    print('Testing _get_all_lianxin()...')
    #          1   2   3   4   5   6   7   8   9   a   b   c   d   e   f
    board = [['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],#1
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],#2
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],#3
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],#4
             ['.','.','.','.','.','.','.','.','.','X','.','.','.','.','.'],#5
             ['.','.','.','.','.','.','X','.','.','.','.','.','.','.','.'],#6
             ['.','.','.','.','.','O','.','.','X','O','.','.','.','.','.'],#7
             ['.','.','.','.','.','X','X','O','X','.','.','.','.','.','.'],#8
             ['.','.','.','.','.','X','O','X','.','.','.','.','.','.','.'],#9
             ['.','.','.','.','.','.','.','.','.','.','X','.','.','.','.'],#a
             ['.','.','.','X','.','.','.','.','.','.','.','.','.','.','.'],#b
             ['.','.','X','.','.','.','.','.','.','.','.','.','.','.','.'],#c
             ['.','O','.','.','.','.','.','.','.','.','.','.','.','.','.'],#d
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],#e
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.']]#f
    #[count, jump_count, block] # 東, 南, 東南, 西南
    lianxin = _get_all_lianxin(board, [6,7], 'X')
    #print(lianxin)
    assert lianxin == [[2,[0,0],[True,False]],
                       [1,[0,0],[True,False]],
                       [3,[1,0],[False,False]],
                       [3,[2,1],[True,False]]]
    
    #          1   2   3   4   5   6   7   8   9   a   b   c   d   e   f
    board = [['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'], #1
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'], #2
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'], #3
             ['.','.','.','.','.','.','.','.','.','X','.','.','.','.','.'], #4
             ['.','.','.','.','.','.','X','.','.','.','.','.','.','.','.'], #5
             ['.','.','.','.','.','O','.','.','X','O','.','.','.','.','.'], #6
             ['.','.','.','.','.','X','X','O','X','.','.','.','.','.','.'], #7
             ['.','.','.','.','.','X','O','X','.','.','.','.','.','.','.'], #8
             ['.','.','.','.','.','.','.','.','.','.','X','.','.','.','.'], #9
             ['.','.','.','X','.','.','.','.','.','.','.','.','.','.','.'], #a
             ['.','.','X','.','.','.','.','.','.','.','.','.','.','.','.'], #b
             ['.','O','.','.','.','.','.','.','.','.','.','.','.','.','.'], #c
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'], #d
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'], #e
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.']] #f
    #[count, jump_count, block] # 東, 南, 東南, 西南
    lianxin = _get_all_lianxin(board, [5,7], 'X')
    #print(lianxin)
    assert lianxin == [[2,[0,0],[True,False]],
                       [1,[0,0],[True,False]],
                       [3,[1,0],[False,False]],
                       [3,[2,1],[True,False]]]
    
    
    print('ok')
    
def test_check_board():
    '''
    
    '''
    print('Testing check_board()...')
    board = [['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.']]
    assert check_board(board, 'X') == False
    
    board = [['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['X','X','X','X','X','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.']]
    assert check_board(board, 'X') == True
    
    board = [['X','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['X','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['X','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['X','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['X','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.']]
    assert check_board(board, 'X') == True

    board = [['.','.','.','.','.','.','.','.','.','.','X','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','X','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','X','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','X','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','X'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.']]
    assert check_board(board, 'X') == True
    
    board = [['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['X','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','X','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','X','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','X','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','X','.','.','.','.','.','.','.','.','.','.']]
    assert check_board(board, 'X') == True
    
    board = [['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','X'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','X','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','X','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','X','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','X','.','.','.','.']]
    assert check_board(board, 'X') == True
    
    board = [['.','.','.','.','X','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','X','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','X','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','X','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['X','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'],
             ['.','.','.','.','.','.','.','.','.','.','.','.','.','.','.']]
    assert check_board(board, 'X') == True
    
    print('ok')
    
if __name__ == '__main__':
    main()
    #test_check_board()
    #test_get_all_lianxin()
    #test_move_score()
    #test_get_center_enmpty_points()
相關文章
相關標籤/搜索