AI玩转重力四子棋

最新推荐文章于 2024-05-14 13:56:46 发布

可西哥

最新推荐文章于 2024-05-14 13:56:46 发布

阅读量6.1k

点赞数 5

分类专栏： Python 算法文章标签：算法 python

本文链接：https://blog.csdn.net/xmxoxo/article/details/109672165

版权

Python 同时被 2 个专栏收录

13 篇文章 0 订阅

订阅专栏

算法

7 篇文章 0 订阅

订阅专栏

本文介绍了重力四子棋的游戏规则及其变体，详细讲解了AI算法的实现过程，包括棋盘状态特征提取、棋串概念、气度计算以及AI的下一步棋推荐策略。通过特征值和得分计算，AI能在有限搜索深度内判断最优落子位置，为后续的深度学习模型提供了基础。

摘要由CSDN通过智能技术生成

AI玩转重力四子棋

导语

最近看到一个小游戏，感觉很有意思，想着如何让电脑学会跟人下。于是做了一些简单的探索，完成了基本的AI模拟，这里的算法是直接使用特征来进行差别。搜索深度也只做了2步，还可以做更深度的搜索，也可以使用深度模型来训练，就算是抛砖引玉吧。

版本历史

1.0.3 优化WEB界面，增加人机比分展示；

1.0.2 完成HTTP服务端包装，可通过网页实现对弈；

1.0.1 完成AI算法，可进行人机对弈；

1.0.0 完成重力四子棋基本框架，可进行命令行对弈；

先汇总一下相关资源：

重力四子棋在线游戏 http://connect4.hexi5.com/
重力四子棋源码：https://github.com/xmxoxo/connect4

重力四子棋介绍

重力四子棋共有7行6列
每次只能选择在一个列中下一个棋子；
由于重力作用，所下的棋子会下落到该列的最下方；
一方棋子在任意直线方向上连成4个棋子即获胜；

当然，根据这个规则还可以把游戏变得更复杂：
棋盘也可以变成更大，四子也可以变成N子；
甚至可以把二维变成三维：最强大脑里的立体重力四子棋，有兴趣的可以自行百度

如果对规则不是很了解的话，可以到马上试玩一下：重力四子棋

重力四子棋的基本实现

首先是实现重力四子棋的基本方法，可以下棋，换游戏者，判断胜负等。
这些过程相对比较简单，重点的就说几个地方吧：

一是下棋：重力作用会让棋落到最下面。

这个的实现是基于原来的代码结构，使用了一个column的类来完成。其实也可以简化成使用numpy的判断。

二是判断胜负：搜索所有的棋判断有没有连成4个。
搜索的时候是从上到下，从左到右，找到每一个棋子，
然后沿着：右，右下，下，左下，这四个方向去查找。
为什么是这四个方向呢，因为另外四个方向其实是对称的，已经包含在上面的方向里了。
只要在方向上能找到连续的另外三颗同色的棋子，就说明获胜了。

基本的实现过程可以看源码中的 Connect_N.ipynb

重力四子棋的AI模拟

整个AI模拟的思路过程也都写在了Connect_N.ipynb 文件中。

这里把思路重新理一下：

棋盘状态特征

棋盘状态特征的目的是针对当前棋盘状态，提取出棋子的特征值。

棋子的特征值可以分为针对游戏者双方分别给出特征值，提取的方法是相同的。

最终的特征为已方棋子特征加上对方棋子的特征,即：

[[已方特征],[对方特征]]

棋子特征

棋子特征主要是要能够描述棋子的好坏，棋子的发展变化情况，棋子离目标状态的远近。

这里参考围棋的思路，主要引入几个核心要素：棋串，棋长，真气，长气，气度等。

棋串

棋串是指一个或者多个在一条直线上的棋子连成的串;

棋串包括横向，竖向和斜向（正反）四个方向。

每个棋子可以包含在不同的棋串中。

棋串用chess表示

○○○○○○
○○▲○○○
○●●▲○○

上图中●方共有子串三个：

●     位置：((3,2))
●     位置：((3,3))
●●    位置：((3,2),(3,3))

▲方共有子串三个:

▲     位置：((3,2))
▲     位置：((3,3))
▲▲    位置：((2,3),(3,4)) 斜线

棋长

棋长是指棋串的最大长度,是一个整数；

棋长用maxlen表示；

可以很容易推断出，对于N子棋来说：

当出现棋长为N的棋串表示已经胜利；
当前局面中最大的棋长为N-1

真气

真气是指棋串周边可以下棋的空位位置，位置包括斜方向，与围棋的气的计算相同。

真气的数量越多，表示棋串未来的发展变化程度越大。

棋串的真气数量用gas_count表示；

对于真气为0的棋串，已经没有发展的空间，可以不需要参与计算；

气度

棋串的每一个真气，有些真气是马上可以“落下棋”的位置，而有些是未来才能“落下棋”的位置；

气度就是要多少步才能“落下棋”到该位置，用一个整数来表示，0表示马上就可以落棋；

对于N子棋来说，气度的取值范围为0至N-1；

显然，气度为0的真气就是下一步要落子的位置。

长气

长气是指棋串的真气中，可以让棋长变大的真气；

长气的个数最小值为0，最大值为2；

必胜局面

显然可见，对于4子棋来说，如果出现：一个棋串长度为3，长气个数为2，长气的气度均为0，则为必胜棋。
如下图：

○○○○○○
○○○○○○
○○○○○○
○○○○○○
○○○○○○
○○▲▲▲○
○○●●●○

对于●方：

最大棋串的长度为3，真气个数为4，左右两边分别有一个长气，即长气个数为2，并且这两个长气的气度均为0。

此时无论对方下哪个位置，这两个位置二者必得其一，所以是必胜的局面。

必应局面

对于4子棋来说，如果最大棋串长度为3，长气个数为1，且长气的气度为0，则为必应局面，也就是必须抢占这个位置。

如下图：

○○○○○○
○○○○○○
○○○○○○
○○○○○○
○○○○○○
○○○▲▲▲
○○○●●●

对于●方：

最大棋串长度为3，长气个数为1，气度为0，也就是再下到这里就获胜了，所以是双方抢占的位置。

对于已方来说，叫获胜位；对于对方来说，叫必应位。

棋盘状态表示

棋盘状态使用各个棋串表示，搜索出当前棋盘下的所有棋串，去除掉包含的子串以及死串。

重点：使用棋串长度l，长气气度d1，长气气度d2 这三个值组成的特征数组表示一个棋串

例如：

[3,1,1]  必胜棋串
[3,0,1]  必应棋串
[3,2,2]  带禁入的棋串， 
[2,0,2]  斜向有发展前途的棋串

使用以下公式来计算一个棋串的分值：

value = 10**(l+2) + 10**(l+1)/d1**3 + 10**(l+1)/d2**3 + 10**(l+1)/(d1*d2)**2 + 10**(l)/(d1+d2)**2

公式中，要排除掉d1,d2为0的情况，避免出现计算错误。

棋盘的总得分即为所有棋串的分值总和。

这样设计公式的原因是把棋串长度，气度1，气度2分别放在不同的位上进行区分；

当棋串长度从3变为4时，棋串得分立即从10万等级上长到100万等级，因此很容易判断是否获胜。

同时考虑了气度1、气度2为0；以及同时为1的情况，公式的设计可以实现同长度棋串的不同气度排序：

[x,1,1] > [x, 1, 2] > [x, 1, 3] > [x, 0,1] > [x, 0, 2]

棋串得分公式及验证

# 棋串得分计算公式
def chessvalue(l,d1,d2):
    
    if l<4 and  d1==d2==0: return 0
    value = 10**(l+2) 
    k1 = d1*d2
    k2 = d1+d2
    
    v1 = 0 if d1==0 else 10**(l+1)/d1**3
    v2 = 0 if d2==0 else 10**(l+1)/d2**3
    value += v1+v2
    if k1>0:
        value += (10**(l+1) / k1**1.5)
    if k2>0:
        value += (10**(l) / k2)
    #value *= 100
    return int(value)

testv = [[5,0,0],
         [4,1,1],
         [4,0,0],
         [4,0,1],
         [4,0,2],
    
         [3,1,1],
         [3,1,2],
         [3,1,3],
         [3,1,4],
         [3,0,1],
         [3,1,0],
         [3,2,2],
         [3,2,3],
         [3,2,4],    
         [3,0,2],
         [3,0,3],
         [3,0,0],
         
         [2,1,1],
         [2,0,1],
         [2,1,0],
         [2,1,2],
         [2,1,3],
         [2,0,2],
         [2,0,3],
         [2,1,4],
         [2,0,0],
         
         [1,1,1],
         [1,0,1],
         [1,0,0],
        ]

for x in testv:
    print('{0} ==> {1:>10,d}'.format(str(x), chessvalue(*x)))

运行完的结果：

[5, 0, 0] ==> 10,000,000
[4, 1, 1] ==>  1,305,000
[4, 0, 0] ==>  1,000,000
[4, 0, 1] ==>  1,110,000
[4, 0, 2] ==>  1,017,500
[3, 1, 1] ==>    130,500
[3, 1, 2] ==>    114,083
[3, 1, 3] ==>    111,731
[3, 1, 4] ==>    110,981
[3, 0, 1] ==>    111,000
[3, 1, 0] ==>    111,000
[3, 2, 2] ==>    103,375
[3, 2, 3] ==>    102,098
[3, 2, 4] ==>    101,729
[3, 0, 2] ==>    101,750
[3, 0, 3] ==>    100,703
[3, 0, 0] ==>          0
[2, 1, 1] ==>     13,050
[2, 0, 1] ==>     11,100
[2, 1, 0] ==>     11,100
[2, 1, 2] ==>     11,408
[2, 1, 3] ==>     11,173
[2, 0, 2] ==>     10,175
[2, 0, 3] ==>     10,070
[2, 1, 4] ==>     11,098
[2, 0, 0] ==>          0
[1, 1, 1] ==>      1,305
[1, 0, 1] ==>      1,110
[1, 0, 0] ==>          0

对局面来进行评估

有了棋串的得分，把一个局面中所有的棋串得分加起来，就是当前局面的得分了。
代码如下：

    def all_chess(self, board=None):
        '''盘面分析，获取所有的棋串，并计算得分'''
        
        #判断子串重复
        check_repeat = lambda m,n: all( map(lambda x:x in n, m))
        
        ret = [[],[]]
        # 每个点沿右，右下，下，左下4个方向最多走3步，每一步都必须与当前点同色，如果能走到3步则表示获胜
        dire = [[0,1],[1,1],[1,0],[1,-1]]
        if board is None:
            bd = self.board
        else:
            bd = board
        for x in range(bd.shape[0]):
            for y in range(bd.shape[1]):
                po = bd[x,y]
                if po>0:
                    #ret[po-1].append([(x,y)])
                    for d in dire:
                        step=0
                        chess = []
                        #chess.append(po)
                        chess.append((x,y))
                        xn,yn = x,y
                        #----- 计算气度1:d1
                        d1 = 0
                        px, py = x-d[0],y-d[1]
                        if 0<=px<bd.shape[0] and 0<=py<bd.shape[1]:
                            if bd[px,py]==0:
                                k = bd[:, py][::-1][:bd.shape[0]-px]
                                d1 = len(list(filter(lambda x:x==0,k)))
                        #-----
                        #最大深入3级
                        for s in range(3):
                            # 计算下一个点的位置
                            xn,yn = xn+d[0],yn+d[1]
                            # 判断点是否在区域内
                            if 0<=xn<bd.shape[0] and 0<=yn<bd.shape[1]:
                                if bd[xn,yn]==po:
                                    chess.append((xn,yn))
                                    step += 1
                                else:
                                    break
                            else:
                                break
                        #----- 计算气度2：d2
                        d2 = 0
                        #xn,yn = xn+d[0],yn+d[1]
                        if 0<=xn<bd.shape[0] and 0<=yn<bd.shape[1]:
                                if bd[xn,yn]==0:
                                    k = bd[:, yn][::-1][:bd.shape[0]-xn]
                                    d2 = len(list(filter(lambda x:x==0,k)))
                        #-----
                        # 记录棋串
                        #if step>0:
                        # 判断是重重复
                        if not any(map(lambda x:check_repeat(chess,x[0]), ret[po-1])):
                            value = chessvalue(len(chess),d1,d2)
                            ret[po-1].append([chess,[len(chess), d1, d2],value])
                        # 记录棋串长度，气度1，气度2
        # 棋串排序,按棋长
        #mysort = lambda r: sorted(r,key=lambda x:-len(x[0]))
        # 棋串排序,按棋串得分
        mysort = lambda r: sorted(r,key=lambda x:-x[-1])
        ret = list(map(mysort,ret))
        return ret

有了局面的分值，就可以进行评估了，这里来进行模拟一下：

board = Board(4)

board.drop_disk(6)
board.drop_disk(5)

board.drop_disk(5)
board.drop_disk(4)

board.drop_disk(5)
board.drop_disk(4)

board.drop_disk(4)
board.drop_disk(3)

board.drop_disk(3)
board.drop_disk(3)

#board.drop_disk(3)

board.display()

ai = AI(board)
allchess = ai.all_chess()
#v = map(lambda y: sum(map(lambda x:x[-1], y)), allchess)
v1, v2 = ai.score()

print('棋盘状态:')
print('玩家1  得分:{0:,d}'.format(v1))
ret = list(map(print,allchess[0]))
print('-'*30)

print('玩家2  得分:{0:,d}'.format(v2))
ret = list(map(print,allchess[1]))

运行结果如下：


------------重力棋游戏-------------
玩家：●     电脑:▲

1 2 3 4 5 6
○○○○○○
○○○○○○
○○○○○○
○○○○○○
○○▲●●○
○○●▲●○
○○▲▲▲●
1 2 3 4 5 6

当前轮到: [●]玩家 
棋盘状态:
玩家1  得分:145,325
[[(4, 3), (5, 4), (6, 5)], [3, 1, 0], 111000]
[[(4, 3), (5, 2)], [2, 1, 1], 13050]
[[(4, 4), (5, 4)], [2, 1, 0], 11100]
[[(4, 3), (4, 4)], [2, 0, 2], 10175]
------------------------------
玩家2  得分:212,413
[[(6, 2), (6, 3), (6, 4)], [3, 1, 0], 111000]
[[(4, 2), (5, 3), (6, 4)], [3, 4, 0], 100406]
[[(4, 2)], [1, 3, 0], 1007]
[[(5, 3), (6, 3)], [2, 0, 0], 0]
[[(5, 3), (6, 2)], [2, 0, 0], 0]

AI棋步推荐

有了局面的分值，就可以计算出局面的分值变化了，最终的目标就是让下一步棋后，得到分值更大的局面。当然这里也可以判断分值超过百万就是获胜了。
AI就是去计算每一步棋下完后的局面得分，然后按分值的高低排序即可。

以下是下一步棋推荐的核心代码：

    def nextstep(self, player):
        '''预测出下一步最好的棋应该下在哪里'''
        
        '''计算下一步可下棋的位置'''
        pos = np.where (self.board[0]==0)[0]+1
        #print(pos)
        
        #模拟在某一列下一个棋
        def dropstep(bd,col,player):
            bd = bd.copy()
            #print('-'*30)
            #print(bd)
            k = bd[:, col][::-1]
            row = bd.shape[0] - k.tolist().index(0) - 1
            bd[row,col] = player
            #print('-'*30)
            #print('drop:',col)
            #print(bd)
            return bd
        
        # 当前得分
        current_score = np.array(self.score())
        #print('current_score:', current_score)
        
        #分别计算每一个可下位置下棋后的状态得分变化值
        def nextscore(bd, current_score, player):
            nplayer = 1 if player==2 else 2
            f_score = np.array([current_score] * bd.shape[1])
            '''计算下一步可下棋的位置'''
            pos = np.where (self.board[0]==0)[0]
            for p in pos:
                #模拟下一步棋后的状态
                nbd = dropstep(bd, p, player)
                # 计算状态及得分
                v_chess = self.all_chess(board=nbd)
                v_score = list(map(lambda y: sum(map(lambda x:x[-1], y)), v_chess))
                f_score[p] = v_score
            f_score -= current_score
            return f_score
     
        score_change = nextscore(self.board, current_score, player )
        #print('score_change:', score_change)
        pp = [1,-2]
        if player == 2:
            pp = [-2, 1] 
        score_change = score_change * pp

        # 得分变化计算方式：已方增加值值 - 对方增加值
        t_score = score_change[:,0] - score_change[:,1]
        #print(t_score)
        # 排序
        idx = np.array(t_score).argsort()[::-1] + 1
        #print('sorted:', idx)
        nt = np.sort(t_score,axis=0)[::-1]
        
        #ns = np.sort(score_change,axis=0)[::-1]
        #nf =  np.sort(f_score,axis=0)[::-1]
        
        rpos = list(zip(idx, nt.tolist())) #, ns.tolist(), nm.tolist()
        return rpos

针对上面的局面，让AI推荐一下：

recommand = ai.nextstep(1)
print(recommand)
print('-'*30)
recommand = ai.nextstep(2)
print(recommand)

运行结果如下；

[(3, 892909), (5, 198948), (4, 23813), (6, 23125), (1, 1110), (2, -123436)]
------------------------------
[(3, 210798), (5, 24983), (1, -1110), (6, -1850), (4, -10635), (2, -995407)]

可以看到，都是推荐下在第3列，后面的值是得分的变化值。

总结与后计

上周末跟儿子一起下这个重力四子棋，没想到连输了好几盘，答应他这周末搞出一个AI来跟他下，看来基本上是完成了。
整个过程中对于numpy、flask、session、ajax等的使用能力都有所提升，代码里也有一些小小的通用功能点实现，可以作为后续工程的参考。
例如：对array的各类旋转、切片操作；加载favicon.ico；记录人和AI的获胜得分比；

当然代码中还有很多可以优化的地方：