zoukankan      html  css  js  c++  java
  • python五子棋

    以后不更新了,把以前的一些东西发出来。

    这是一个命令行环境的五子棋程序。使用了minimax算法。

    除了百度各个棋型的打分方式,所有代码皆为本人所撸。本程序结构与之前的井字棋、黑白棋一模一样。

    有一点小问题,没时间弄了,就这样吧。

    一、效果图

    (略)

    二、完整代码

    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、-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='
    ')
                    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()
  • 相关阅读:
    English,The Da Vinci Code, Chapter 23
    python,meatobject
    English,The Da Vinci Code, Chapter 22
    English,The Da Vinci Code, Chapter 21
    English,The Da Vinci Code, Chapter 20
    English,The Da Vinci Code, Chapter 19
    python,xml,ELement Tree
    English,The Da Vinci Code, Chapter 18
    English,The Da Vinci Code, Chapter 17
    English,The Da Vinci Code, Chapter 16
  • 原文地址:https://www.cnblogs.com/hhh5460/p/10331133.html
Copyright © 2011-2022 走看看