探索中国象棋游戏的算法实现

本文还有配套的精品资源，点击获取

简介：中国象棋游戏作为中国传统棋类，其算法实现是计算机科学与人工智能领域中的经典课题。本文详细探讨了中国象棋算法的设计与实现，包括棋盘状态表示、棋子移动规则、游戏逻辑以及高效搜索算法等关键组成部分。文章还将介绍如何通过评估函数和剪枝技术优化搜索过程，并提出实现高级特性如残局数据库和开局库的方法，最终目的是设计出更智能、更具挑战性的象棋AI。

1. 棋盘状态表示

在设计一款具有智能对弈功能的中国象棋程序时，棋盘状态的表示是基础，也是核心。一个清晰、高效的数据结构对于后续的棋子移动规则设计、游戏逻辑实现以及搜索算法的应用至关重要。

棋盘与棋子的数据结构设计

为了表示棋盘，我们通常采用一个二维数组，数组中的每个元素对应棋盘上的一个位置。初始时，数组中每个元素代表的是一个空位置。随着游戏的进行，棋子会移动到对应的位置，这时二维数组中的元素需要被更新为相应的棋子信息。

棋子的信息可以用对象来表示，包含棋子类型（如将、士、象、车、马、炮、卒等），所属方（红方或黑方），以及棋子的当前位置。这样的设计使得棋子在棋盘上的移动操作变得简单明了。

状态表示的优化

为了提高程序的运行效率，可以使用位运算来优化棋盘状态的存储。例如，可以用一个位向量来表示棋盘上某一类棋子的所有位置信息，这样在进行搜索时，能够快速获取这类棋子的可能位置，加速搜索算法的执行。

# 举例：使用位向量表示棋盘上的象位置
# 假设棋盘大小为10x9，象的初始位置为(3, 1)和(3, 7)
象的位置 = 1 << (1 + 3 * 9) | 1 << (7 + 3 * 9)

本章的介绍到此为止，为后续章节的游戏逻辑与算法实现奠定了基础。接下来的章节将深入探讨棋子的移动规则设计以及游戏逻辑的具体实现。

2. 棋子移动规则设计与游戏逻辑实现

2.1 棋子移动规则的设计

2.1.1 棋子的基本移动规则

在设计棋类游戏，如中国象棋时，棋子的基本移动规则是游戏机制的核心。每种棋子都拥有其独特的移动方式，例如：

• 将/帅 ：只能在九宫内移动，每次只能一格。
• 车 ：可以沿直线无阻碍地移动。
• 马 ：走“日”字，即先直走一格然后横走两格，或先横走一格然后直走两格，且不能被“绊马脚”。
• 象/相 ：可以沿对角线移动，但每次移动都必须跳过中间的棋子。
• 士/仕 ：斜向移动，每次只能走一格，且不能出九宫。
• 炮 ：走直线，但吃子时必须跳过一个棋子。
• 兵/卒 ：只能直走，过河后可以横行。

这些基本规则是通过编程语言中的函数或方法来实现的。例如，在Java中，我们可以为每种棋子创建一个类，并在其中定义它们的移动规则。

public class ChessPiece {
    // 基础属性和方法省略...
    public boolean canMove(int startX, int startY, int endX, int endY) {
        // 根据棋子类型实现具体移动逻辑
        // return true if move is valid, false otherwise
    }
    // 不同棋子具体的移动逻辑实现...
}

// 具体棋子类继承ChessPiece并实现其canMove方法
public class Rook extends ChessPiece {
    // 车的移动规则实现
    @Override
    public boolean canMove(int startX, int startY, int endX, int endY) {
        // 实现车的移动逻辑
        return true;
    }
}

这段代码展示了如何抽象棋子的移动规则。每种棋子的类都重写了 canMove 方法，确保了每种棋子的移动都遵循了游戏的规则。

2.1.2 特殊移动规则的处理

对于特殊移动规则，如“炮打隔子”，“马脚”，以及“过河兵变”等，我们需要设计额外的检查机制，以确保游戏逻辑的准确性。

这些特殊规则需要在游戏引擎中进行严格的判断，以防止玩家进行非法操作。为此，可能需要实现额外的检查函数，来处理这些特殊情况。

public class SpecialMovesChecker {
    // 特殊移动的检查方法
    public boolean isSpecialMoveValid(ChessPiece piece, int startX, int startY, int endX, int endY) {
        // 根据棋子类型和移动类型，检查特殊移动是否有效
        // return true if special move is valid, false otherwise
    }
    // 特殊移动的逻辑实现...
}

// 在实际移动时调用特殊移动检查
ChessPiece piece = ...;
if (specialMovesChecker.isSpecialMoveValid(piece, startX, startY, endX, endY)) {
    // 执行特殊移动
}

通过这些额外的检查，我们保证了游戏规则的正确性和完整性，同时为玩家提供了接近真实对弈的体验。

2.2 游戏逻辑的实现

2.2.1 游戏初始化与界面展示

游戏初始化和界面展示是玩家体验游戏的第一步。在这一阶段，主要涉及到棋盘的绘制、棋子的布局以及游戏界面的初步展示。

实现这一功能的代码通常包含初始化棋盘和棋子的数据结构、绘制棋盘和棋子的图形界面以及设置初始状态（如轮到哪方走棋）。

public class ChessGame {
    // 游戏状态变量
    private ChessPiece[][] board;
    public ChessGame() {
        // 初始化棋盘和棋子
        initializeBoard();
        // 初始化界面显示
        displayBoard();
    }
    private void initializeBoard() {
        // 初始化棋盘上的棋子位置
    }
    private void displayBoard() {
        // 使用图形库绘制棋盘和棋子
    }
}

// 游戏初始化后，调用ChessGame的构造函数开始游戏
new ChessGame();

2.2.2 用户操作的响应与执行

用户操作响应是实现人机交互的关键环节。游戏逻辑需要捕获用户的输入，并将其转化为具体的棋子移动。

实现用户操作响应的代码通常包括对鼠标点击事件的监听、移动规则的验证以及移动的执行。

// 假设使用Java Swing作为图形界面框架
public class ChessGame {
    // ...
    public void onMouseClick(int x, int y) {
        // 获取被点击的棋子
        ChessPiece piece = board[x][y];
        if (piece != null && piece.isCurrentPlayer()) {
            // 如果是当前玩家的棋子，则请求移动
            requestMove(piece, x, y);
        }
    }
    private void requestMove(ChessPiece piece, int startX, int startY) {
        // 处理移动请求
        // 验证移动是否合法
        // 执行移动或提示非法操作
    }
}

2.2.3 游戏胜负判断与结束处理

游戏胜负的判断是游戏逻辑中非常重要的部分，它决定了游戏何时结束以及谁是赢家。胜负的判断依赖于棋子的特定状态，如将/帅的被“将军”和“将死”。

实现胜负判断与结束处理的代码需要经常检查棋盘状态，判断是否有“将死”或“困毙”等局面的出现。

public class ChessGame {
    // ...
    public boolean isGameOver() {
        // 判断游戏是否结束
        // 检查将/帅是否被将军或被将死
        return false;
    }
    // 如果游戏结束，执行结束处理逻辑
    private void handleGameOver() {
        // 显示胜负结果
        // 清除或重置棋盘
        // 可能的重新开始游戏的选项
    }
}

// 棋局中每一步操作后，检查游戏是否结束
if (game.isGameOver()) {
    game.handleGameOver();
}

通过上述章节的介绍，我们已经介绍了棋子移动规则的设计和游戏逻辑实现的基本理念和步骤。在下一级章节中，我们会继续深入探讨如何通过搜索算法优化游戏逻辑，提升游戏的可玩性和AI的智慧。

3. 搜索算法在象棋中的应用

3.1 搜索算法概述

3.1.1 搜索算法的重要性

在计算机象棋游戏中，搜索算法是决策制定的关键部分。一个优秀的搜索算法能够在有限的计算资源下，找到最优或近似最优的走法。搜索算法允许程序评估不同的移动序列，并预测未来可能的游戏状态，从而在给定的局势中作出最佳的移动选择。

搜索算法不仅应用于单人游戏，如象棋、围棋和国际象棋等，也广泛应用于双人对战的策略游戏，甚至在人工智能领域的其他领域，如机器学习和优化问题中也有应用。在这些领域中，搜索算法的任务是找到一个最优或满足一定条件的解。

3.1.2 常见搜索算法对比

在搜索算法的大家族中，有许多不同类型的算法被设计出来以解决各种问题。对于象棋游戏而言，常见的搜索算法包括：

• 深度优先搜索（DFS） ：按深度优先策略探索所有可能的走法分支，直到达到预定的深度，或在分支达到某个终止条件时停止。
• 广度优先搜索（BFS） ：按层进行搜索，一层层地扩展所有可能的走法，直到找到解决方案。
• 启发式搜索 ：结合评估函数，优先探索对当前玩家最有利的走法分支。
• Minimax算法 ：利用递归进行两层搜索，一层代表我方策略，另一层代表对方策略，两者交替进行直到搜索到一定深度。

在实际应用中，每种算法都有其优缺点，它们在处理问题时的效率和效果各有不同。例如，DFS在空间复杂度方面可能更有优势，而BFS在找到最短路径问题上更高效。启发式搜索和Minimax算法在象棋游戏中应用较多，因为它们能结合评估函数来引导搜索过程，更有效地找到较好的走法。

3.2 深度优先搜索（DFS）与广度优先搜索（BFS）

3.2.1 DFS与BFS的基本原理

深度优先搜索（DFS） 的基本思想是从初始状态开始，沿着一个分支深入探索，直到找到目标状态或没有更多可探索的分支。一旦当前分支探索失败，DFS会回溯到上一个分叉点，尝试另一条路径。

广度优先搜索（BFS） 则采用不同的策略，它从初始状态开始，同时探索所有可能的路径，直到找到目标状态或所有路径都被探索完毕。BFS按层次顺序进行扩展，逐层增加搜索的深度。

3.2.2 在中国象棋中的具体实现

在实现深度优先搜索时，我们通常使用递归方法。以下是一个简化的DFS算法伪代码，它展示了如何在象棋游戏中实现DFS：

function DFS(node, depth, maxDepth)
    if depth > maxDepth or node is terminal
        return node
    foreach possible move from node
        child = makeMove(node, move)
        result = DFS(child, depth + 1, maxDepth)
        if result != null
            return result
    return null

在广度优先搜索中，我们使用队列来按层顺序扩展节点。以下是一个简化的BFS伪代码：

function BFS(startNode, maxDepth)
    queue = createQueue()
    queue.enqueue(startNode)
    while not queue.isEmpty() and maxDepth > 0
        currentNode = queue.dequeue()
        maxDepth -= 1
        foreach possible move from currentNode
            child = makeMove(currentNode, move)
            if child is targetState
                return child
            queue.enqueue(child)
    return null

3.2.2.1 算法逻辑分析

在上述DFS伪代码中， node 表示当前棋局状态， depth 记录当前搜索深度，而 maxDepth 则是预设的最大搜索深度。函数首先判断当前节点是否为终止状态或已达到最大深度，如果是，则返回当前节点。然后，算法遍历所有可能的移动并递归地调用DFS函数。

BFS伪代码中的 startNode 表示起始棋局状态， maxDepth 同样是预设的最大搜索深度。算法使用一个队列来维护待处理的节点，每处理一个节点就将其所有可能的移动产生的子节点加入队列。每处理一层节点，深度减一，直到找到目标状态或搜索深度达到预设值。

3.2.2.2 参数说明

在DFS和BFS的实现中， maxDepth 参数控制了搜索的深度，它对搜索效率和效果有直接影响。在实际应用中，由于计算资源的限制，通常不能实现完全搜索，而是要选择一个合适的深度限制。

3.2.2.3 实际操作步骤

• 确定搜索的起始节点（当前棋局状态）。
• 设置最大搜索深度，根据游戏的计算资源和实时性要求来调整。
• 对于DFS，使用递归函数进行深度优先搜索，直到达到终止条件或最大深度。
• 对于BFS，使用队列结构实现广度优先搜索，逐层扩展节点直至找到目标状态。

3.2.2.4 代码块展示

下面是一个简化版的DFS和BFS的Python代码示例：

def dfs(node, depth, maxDepth):
    if depth > maxDepth or is_terminal(node):
        return None
    if is_target_state(node):
        return node
    for move in get_possible_moves(node):
        child = make_move(node, move)
        result = dfs(child, depth + 1, maxDepth)
        if result:
            return result
    return None

def bfs(start_node, maxDepth):
    queue = deque([start_node])
    while queue:
        if maxDepth == 0:
            break
        node = queue.popleft()
        maxDepth -= 1
        for move in get_possible_moves(node):
            child = make_move(node, move)
            if is_target_state(child):
                return child
            queue.append(child)
    return None

3.2.2.5 执行逻辑说明

在以上代码中， is_terminal 函数用于判断当前节点是否为终止节点， is_target_state 判断是否达到目标状态。 get_possible_moves 函数获取当前节点所有可能的移动列表， make_move 函数用于产生新的棋局状态。这些函数的实现需要根据具体的游戏规则来编写。

3.2.2.6 代码执行结果

虽然此处没有具体的执行结果展示，但通过执行上述代码，我们可以得到从起始节点开始，到达目标状态的移动序列。在实际的中国象棋程序中，这些移动序列会转化为具体的走法显示给玩家，或者用作AI的决策依据。

搜索算法在计算机象棋中起着至关重要的作用，它使得计算机能够在有限的时间内计算出最佳的走法。虽然深度优先搜索和广度优先搜索在效率和实现上有所不同，但它们都为理解更复杂的搜索算法打下了基础，例如启发式搜索和Minimax算法，这些都是后续章节将深入探讨的主题。

4. Minimax算法与Alpha-Beta剪枝技术

4.1 Minimax算法原理与应用

4.1.1 Minimax算法核心思想

Minimax算法是一种在博弈论中常用的决策规则，尤其适用于两个玩家轮流进行回合的零和游戏（如中国象棋、国际象棋、井字棋等）。其核心思想是假设两位玩家都在尽可能地做出最优决策，一方通过最小化对方的可能最大得分来最大化自己的最小得分。换句话说，算法模拟了两位玩家的最佳游戏策略，并选择那些能带来最佳防御位置的移动。

4.1.2 实现Minimax算法

在实现Minimax算法时，首先需要定义游戏的状态评估函数，该函数能给定一个棋局状态评估分数。接下来，需要递归地搜索所有可能的移动及其结果。在这个搜索树中，叶节点是游戏的最终状态（胜利、失败或平局），而内部节点是玩家和对手的决策点。算法从叶节点开始，向根节点回溯，交替地最大化和最小化分数，最终决定下一步的最佳移动。

一个基本的Minimax伪代码可以表示如下：

def minimax(node, depth, isMaximizingPlayer):
    if depth == 0 or node.is_terminal():
        return node.evaluate()

    if isMaximizingPlayer:
        maxEval = -inf
        for child in node.get_children():
            eval = minimax(child, depth - 1, False)
            maxEval = max(maxEval, eval)
        return maxEval
    else:
        minEval = +inf
        for child in node.get_children():
            eval = minimax(child, depth - 1, True)
            minEval = min(minEval, eval)
        return minEval

在上述伪代码中， isMaximizingPlayer 标识当前是最大化玩家（如本方棋手）还是最小化玩家（如对手）。 node.is_terminal() 检查当前节点是否是一个游戏结束状态。 node.get_children() 生成所有可能的下一步移动，而 node.evaluate() 则评估当前棋局的得分。

4.2 Alpha-Beta剪枝优化

4.2.1 Alpha-Beta剪枝的原理

Alpha-Beta剪枝是一种改进的Minimax算法，它减少了需要评估的节点数量，从而大幅提高了搜索效率。这种剪枝技术通过跟踪当前找到的最好结果，避免评估那些不可能比当前最好结果更优的路径。简单来说，如果一个节点的最优值（最小或最大）已经小于当前搜索路径上已知的值，则可以停止对该节点的进一步搜索。

4.2.2 实现Alpha-Beta剪枝并优化搜索效率

Alpha-Beta剪枝可以通过维护两个参数 alpha 和 beta 来实现，它们分别表示最大玩家和最小玩家迄今为止找到的最佳路径。在搜索过程中，这两个参数会不断更新，并在它们之间的值不再有可能变得更好时剪枝掉某些分支。

以下是实现Alpha-Beta剪枝的基本伪代码：

def alphabeta(node, depth, alpha, beta, isMaximizingPlayer):
    if depth == 0 or node.is_terminal():
        return node.evaluate()

    if isMaximizingPlayer:
        maxEval = -inf
        for child in node.get_children():
            eval = alphabeta(child, depth - 1, alpha, beta, False)
            maxEval = max(maxEval, eval)
            alpha = max(alpha, eval)
            if beta <= alpha:
                break  # 剪枝
        return maxEval
    else:
        minEval = +inf
        for child in node.get_children():
            eval = alphabeta(child, depth - 1, alpha, beta, True)
            minEval = min(minEval, eval)
            beta = min(beta, eval)
            if beta <= alpha:
                break  # 剪枝
        return minEval

在上面的伪代码中， alpha 和 beta 值在每次递归调用时被更新，并在它们相遇时（即 beta <= alpha ）执行剪枝操作，剪枝掉当前节点的所有兄弟节点及其子树。

通过这种方式，Alpha-Beta剪枝大大减少了必须评估的节点数量，极大地提高了搜索效率，使得在有限的时间内可以探索到更深层的决策树。

Alpha-Beta剪枝的效率高度依赖于 alpha 和 beta 值的更新顺序，以及子节点遍历的顺序。在实践中，通常采用启发式方法，如根据棋局评估函数预测最有希望的移动优先考虑，以进一步提高搜索的效率和质量。

4.3 Minimax算法和Alpha-Beta剪枝的代码示例

import math

def is_terminal(node):
    # 判断当前节点是否为游戏结束状态
    pass

def evaluate(node):
    # 评估当前棋局状态
    pass

def get_children(node):
    # 生成所有可能的下一步移动
    pass

def minimax(node, depth, isMaximizingPlayer):
    if depth == 0 or is_terminal(node):
        return evaluate(node)
    if isMaximizingPlayer:
        maxEval = -math.inf
        for child in get_children(node):
            eval = minimax(child, depth - 1, False)
            maxEval = max(maxEval, eval)
        return maxEval
    else:
        minEval = math.inf
        for child in get_children(node):
            eval = minimax(child, depth - 1, True)
            minEval = min(minEval, eval)
        return minEval

def alphabeta(node, depth, alpha, beta, isMaximizingPlayer):
    if depth == 0 or is_terminal(node):
        return evaluate(node)
    if isMaximizingPlayer:
        maxEval = -math.inf
        for child in get_children(node):
            eval = alphabeta(child, depth - 1, alpha, beta, False)
            maxEval = max(maxEval, eval)
            alpha = max(alpha, eval)
            if beta <= alpha:
                break
        return maxEval
    else:
        minEval = math.inf
        for child in get_children(node):
            eval = alphabeta(child, depth - 1, alpha, beta, True)
            minEval = min(minEval, eval)
            beta = min(beta, eval)
            if beta <= alpha:
                break
        return minEval

在此示例中， is_terminal 函数检查当前节点是否是游戏结束状态， evaluate 函数用于评估棋局分数， get_children 函数用于获取所有可能的移动。这些函数的具体实现依赖于特定的棋类游戏规则。通过这样的代码实现，可以构建出一个基于Minimax或Alpha-Beta剪枝技术的智能棋类游戏对手。

4.4 实际应用与性能测试

4.4.1 应用场景

Minimax算法和Alpha-Beta剪枝技术可以被广泛应用于需要决策制定的场景，尤其在人工智能领域，比如棋类游戏、策略游戏、资源管理等领域。在棋类游戏中，这两种技术构成了大多数计算机对手的基础，能够高效地计算出最优的走法。

4.4.2 性能测试

性能测试可以帮助我们理解在不同参数设置下，算法的时间复杂度和空间复杂度。对于Minimax算法来说，影响其性能的因素包括搜索深度、节点生成的效率以及评估函数的复杂度。而Alpha-Beta剪枝的性能则受到启发式选择、节点遍历顺序等因素的影响。

4.4.3 优化与调整

为了进一步提升算法性能，开发者可能会尝试以下优化：

• 通过更复杂的评估函数来改进评估的准确性。
• 实现迭代加深搜索，优先评估最有可能的移动。
• 使用置换表（transposition table）记录和重用已经评估过的节点，减少冗余计算。
• 通过并行化搜索来提升性能，例如多线程或分布式计算。

4.4.4 实际应用案例分析

在实际应用中，Alpha-Beta剪枝可以在很多棋类游戏中实现接近专家水平的对弈。例如，在国际象棋中，通过精细的参数调整和评估函数优化，程序可以击败世界冠军。类似的实现也可以用于中国象棋、围棋、井字棋等游戏，为玩家提供一个强大的电脑对手。

4.4.5 未来展望

随着人工智能技术的发展，未来的算法可能会结合机器学习和深度学习等技术，学习和模仿优秀棋手的策略和风格。此外，算法在搜索效率和决策质量上的改进也将是未来研究的方向。

4.4.6 总结

本章节介绍了Minimax算法和Alpha-Beta剪枝技术在棋类游戏中的应用。这两种技术不仅提供了强大的决策支持，还通过算法优化大幅提升了效率，是现代人工智能领域不可或缺的一部分。通过不断的研究和优化，我们可以期待这些技术在未来会带来更多的突破和应用。

5. 棋局树探索与评估函数设计

5.1 棋局树的构建与探索

5.1.1 棋局树结构设计

在计算机象棋中，棋局树是一个用来描述可能的棋局状态的树状结构，其中每一个节点都代表一个棋局状态，而节点之间的连线代表可能的移动。设计棋局树的核心在于如何高效地探索树上的所有节点，并在可能的棋局中找到最佳的移动策略。

在构建棋局树时，通常以当前棋局作为树的根节点，将根节点的所有合法移动扩展为子节点。然后对每一个子节点，再进行同样的扩展过程，形成多层的树结构。为了减少搜索空间，通常会使用各种剪枝策略，这将在下一小节详细讨论。

5.1.2 棋局树搜索与剪枝策略

棋局树的搜索指的是从根节点开始，按特定的策略遍历树的节点，以此来评估不同移动策略的优劣。常用的搜索策略包括深度优先搜索(DFS)和广度优先搜索(BFS)，但它们往往因为搜索深度和时间的限制而不适用于复杂的游戏如中国象棋。

因此，更为高级的搜索算法如Minimax算法和它的优化版本Alpha-Beta剪枝技术被广泛应用于棋局树的搜索中，这些算法可以在较短的时间内找到较好的移动策略，而不必遍历整个棋局树。

5.2 评估函数的设计与实现

5.2.1 评估函数的构建原则

评估函数是用来对棋局状态进行评分的函数，它对于选择最佳移动至关重要。一个好的评估函数应该能够准确反映棋局的优劣，主要包括以下几个原则：

• 评估值应该与最终赢得比赛的可能性相关联。
• 评估值需要快速计算，不能过分增加搜索算法的复杂度。
• 评估值应该尽量简单，避免过度拟合特定的棋局。
• 评估标准需要公平，能够平衡不同棋子的价值。

5.2.2 设计评估函数并应用于棋局评估

设计评估函数通常涉及到对棋盘上各种因素的加权求和，例如：

• 将军和被将的棋子数量。
• 兵力对比和棋子的位置优劣。
• 棋子的安全性和活动范围。
• 特殊棋型的构建，如连将、重炮、炮二平五等。

下面是一个简化的评估函数伪代码示例：

def evaluate_board(board):
    score = 0
    # 评估将军和被将棋子的数量
    score += len(find_kings_in_check(board)) * -1000
    score += len(find_kings_checking_opponents(board)) * 1000
    # 评估各个棋子的价值
    piece_values = {'车': 900, '马': 450, '炮': 400, '象': 200, '士': 150, '兵': 100}
    for piece, value in piece_values.items():
        score += len(find_pieces(board, piece)) * value
    # 其他评估标准...
    return score

评估函数的实现是决定计算机象棋水平的关键因素之一，它直接影响着计算机在进行搜索时对于棋局状态的判断。通过不断的测试和调整，评估函数将越来越接近人类高级玩家的棋感。

通过本章的介绍，我们了解了棋局树的构建与探索，以及评估函数设计的重要性。在下一章中，我们将探讨如何通过残局数据库和开局库来进一步提升象棋程序的水平。

本文还有配套的精品资源，点击获取

简介：中国象棋游戏作为中国传统棋类，其算法实现是计算机科学与人工智能领域中的经典课题。本文详细探讨了中国象棋算法的设计与实现，包括棋盘状态表示、棋子移动规则、游戏逻辑以及高效搜索算法等关键组成部分。文章还将介绍如何通过评估函数和剪枝技术优化搜索过程，并提出实现高级特性如残局数据库和开局库的方法，最终目的是设计出更智能、更具挑战性的象棋AI。

本文还有配套的精品资源，点击获取