象棋和五子棋的AI开发（三）

最新推荐文章于 2022-08-20 13:01:55 发布
最新推荐文章于 2022-08-20 13:01:55 发布
阅读量401 收藏 1
点赞数 2
分类专栏： 计算机问题 文章标签： AI 人工智能 象棋 五子棋
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lweiyue/article/details/84530805
版权

三、象棋AI算法

3.1 走法

相对于五子棋，象棋的走法是更复杂的。在走法里面，要说的东西不多，我直接贴代码：

protected override List<Step> GenerateAllMove(ChessColor c)
{
    List<Step> moves = new List<Step>();

    for (int i = 0; i < Row; i++)
    {
        for (int j = 0; j < Col; j++)
        {
            if (board[i, j].type != ChessType.空 && board[i, j].color == c)
            {
                switch (board[i, j].type)
                {
                    case ChessType.卒:
                        GenerateMove卒(i, j, c, moves);
                        break;
                    case ChessType.士:
                        GenerateMove士(i, j, c, moves);
                        break;
                    case ChessType.将:
                        GenerateMove将(i, j, c, moves);
                        break;
                    case ChessType.象:
                        GenerateMove象(i, j, c, moves);
                        break;
                    case ChessType.马:
                        GenerateMove马(i, j, c, moves);
                        break;
                    case ChessType.车:
                        GenerateMove车(i, j, c, moves);
                        break;
                    case ChessType.炮:
                        GenerateMove炮(i, j, c, moves);
                        break;
                }
            }
        }
    }

    return moves;
}

private void GenerateMove卒(int row, int col, ChessColor c, List<Step> moves)
{
    if (c == ChessColor.红)
    {
        if (row < 5)
        {
            AddStep(moves, new Step(row, col, row + 1, col), c);
        }
        else
        {
            AddStep(moves, new Step(row, col, row + 1, col), c);
            AddStep(moves, new Step(row, col, row, col + 1), c);
            AddStep(moves, new Step(row, col, row, col - 1), c);
        }
    }
    else
    {
        if (row >= 5)
        {
            AddStep(moves, new Step(row, col, row - 1, col), c);
        }
        else
        {
            AddStep(moves, new Step(row, col, row - 1, col), c);
            AddStep(moves, new Step(row, col, row, col + 1), c);
            AddStep(moves, new Step(row, col, row, col - 1), c);
        }
    }
}

private void GenerateMove士(int row, int col, ChessColor c, List<Step> moves)
{
    int row1 = row + 1;
    int row_1 = row - 1;
    int col1 = col + 1;
    int col_1 = col - 1;

    Step[] steps = new Step[] {
        new Step(row,col,row1,col1),
        new Step(row,col,row1,col_1),
        new Step(row,col,row_1,col1),
        new Step(row,col,row_1,col_1)
    };

    if (c == ChessColor.红)
    {
        for (int i = 0; i < steps.Length; i++)
        {
            if (steps[i].ToRow < 0 || steps[i].ToRow > 2)
            {
                continue;
            }
            if (steps[i].ToCol < 3 || steps[i].ToCol > 5)
            {
                continue;
            }

            AddStep(moves, steps[i], c);
        }
    }
    else
    {
        for (int i = 0; i < steps.Length; i++)
        {
            if (steps[i].ToRow < 7 || steps[i].ToRow > 9)
            {
                continue;
            }
            if (steps[i].ToCol < 3 || steps[i].ToCol > 5)
            {
                continue;
            }

            AddStep(moves, steps[i], c);
        }
    }
}

private void GenerateMove将(int row, int col, ChessColor c, List<Step> moves)
{
    Step[] steps = new Step[] {
        new Step(row,col, row + 1,col),
        new Step(row,col, row - 1,col),
        new Step(row,col,row, col + 1),
        new Step(row,col,row, col - 1)
    };

    if (c == ChessColor.红)
    {
        for (int i = 0; i < steps.Length; i++)
        {
            if (steps[i].ToRow < 0 || steps[i].ToRow > 2)
            {
                continue;
            }
            if (steps[i].ToCol < 3 || steps[i].ToCol > 5)
            {
                continue;
            }

            AddStep(moves, steps[i], c);
        }

        bool face_to_face = false;
        int start = row + 1;
        for (; start < 10; start++)
        {
            if (board[start, col].type == ChessType.将)
            {
                face_to_face = true;
                break;
            }
            else if (board[start, col].type != ChessType.空)
            {
                break;
            }
        }
        if (face_to_face)
        {
            AddStep(moves, new Step(row, col, start, col), c);
        }
    }
    else if (c == ChessColor.黑)
    {
        for (int i = 0; i < steps.Length; i++)
        {
            if (steps[i].ToRow < 7 || steps[i].ToRow > 9)
            {
                continue;
            }
            if (steps[i].ToCol < 3 || steps[i].ToCol > 5)
            {
                continue;
            }

            AddStep(moves, steps[i], c);
        }

        bool face_to_face = false;
        int start = row - 1;
        for (; start >= 0; start--)
        {
            if (board[start, col].type == ChessType.将)
            {
                face_to_face = true;
                break;
            }
            else if (board[start, col].type != ChessType.空)
            {
                break;
            }
        }
        if (face_to_face)
        {
            AddStep(moves, new Step(row, col, start, col), c);
        }
    }
}

private void GenerateMove象(int row, int col, ChessColor c, List<Step> moves)
{
    int row1 = row + 1;
    int row2 = row + 2;
    int row_1 = row - 1;
    int row_2 = row - 2;
    int col1 = col + 1;
    int col2 = col + 2;
    int col_1 = col - 1;
    int col_2 = col - 2;

    if (c == ChessColor.红)
    {
        if (row_1 >= 0 && col_1 >= 0 && board[row_1, col_1].type == ChessType.空)
        {
            AddStep(moves, new Step(row, col, row_2, col_2), c);
        }
        if (row_1 >= 0 && col1 <= 8 && board[row_1, col1].type == ChessType.空)
        {
            AddStep(moves, new Step(row, col, row_2, col2), c);
        }
        if (row1 <= 4 && col_1 >= 0 && board[row1, col_1].type == ChessType.空)
        {
            AddStep(moves, new Step(row, col, row2, col_2), c);
        }
        if (row1 <= 4 && col1 <= 8 && board[row1, col1].type == ChessType.空)
        {
            AddStep(moves, new Step(row, col, row2, col2), c);
        }
    }
    else
    {
        if (row_1 >= 5 && col_1 >= 0 && board[row_1, col_1].type == ChessType.空)
        {
            AddStep(moves, new Step(row, col, row_2, col_2), c);
        }
        if (row_1 >= 5 && col1 <= 8 && board[row_1, col1].type == ChessType.空)
        {
            AddStep(moves, new Step(row, col, row_2, col2), c);
        }
        if (row1 <= 9 && col_1 >= 0 && board[row1, col_1].type == ChessType.空)
        {
            AddStep(moves, new Step(row, col, row2, col_2), c);
        }
        if (row1 <= 9 && col1 <= 8 && board[row1, col1].type == ChessType.空)
        {
            AddStep(moves, new Step(row, col, row2, col2), c);
        }
    }
}

private void GenerateMove马(int row, int col, ChessColor c, List<Step> moves)
{
    int row1 = row + 1;
    int row2 = row + 2;
    int row_1 = row - 1;
    int row_2 = row - 2;
    int col1 = col + 1;
    int col2 = col + 2;
    int col_1 = col - 1;
    int col_2 = col - 2;

    if (row_1 >= 0 && board[row_1, col].type == ChessType.空)
    {
        AddStep(moves, new Step(row, col, row_2, col_1), c);
        AddStep(moves, new Step(row, col, row_2, col1), c);
    }
    if (row1 < 10 && board[row1, col].type == ChessType.空)
    {
        AddStep(moves, new Step(row, col, row2, col_1), c);
        AddStep(moves, new Step(row, col, row2, col1), c);
    }
    if (col_1 >= 0 && board[row, col_1].type == ChessType.空)
    {
        AddStep(moves, new Step(row, col, row_1, col_2), c);
        AddStep(moves, new Step(row, col, row1, col_2), c);
    }
    if (col1 < 9 && board[row, col1].type == ChessType.空)
    {
        AddStep(moves, new Step(row, col, row_1, col2), c);
        AddStep(moves, new Step(row, col, row1, col2), c);
    }
}

private void GenerateMove车(int row, int col, ChessColor c, List<Step> moves)
{
    int temp_row = row;
    while (temp_row > 0)
    {
        temp_row--;
        if (board[temp_row, col].type == ChessType.空)
        {
            AddStep(moves, new Step(row, col, temp_row, col), c);
        }
        else if (board[temp_row, col].color == c)
        {
            break;
        }
        else
        {
            AddStep(moves, new Step(row, col, temp_row, col), c);
            break;
        }
    }

    temp_row = row;
    while (temp_row < 9)
    {
        temp_row++;
        if (board[temp_row, col].type == ChessType.空)
        {
            AddStep(moves, new Step(row, col, temp_row, col), c);
        }
        else if (board[temp_row, col].color == c)
        {
            break;
        }
        else
        {
            AddStep(moves, new Step(row, col, temp_row, col), c);
            break;
        }
    }

    int temp_col = col;
    while (temp_col > 0)
    {
        temp_col--;
        if (board[row, temp_col].type == ChessType.空)
        {
            AddStep(moves, new Step(row, col, row, temp_col), c);
        }
        else if (board[row, temp_col].color == c)
        {
            break;
        }
        else
        {
            AddStep(moves, new Step(row, col, row, temp_col), c);
            break;
        }
    }

    temp_col = col;
    while (temp_col < 8)
    {
        temp_col++;
        if (board[row, temp_col].type == ChessType.空)
        {
            AddStep(moves, new Step(row, col, row, temp_col), c);
        }
        else if (board[row, temp_col].color == c)
        {
            break;
        }
        else
        {
            AddStep(moves, new Step(row, col, row, temp_col), c);
            break;
        }
    }
}

private void GenerateMove炮(int row, int col, ChessColor c, List<Step> moves)
{
    int temp_row = row;
    bool hit = false;
    while (temp_row > 0)
    {
        temp_row--;
        if (board[temp_row, col].type == ChessType.空)
        {
            if (!hit)
            {
                AddStep(moves, new Step(row, col, temp_row, col), c);
            }
        }
        else if (board[temp_row, col].color == c)
        {
            if (!hit)
            {
                hit = true;
            }
            else
            {
                break;
            }
        }
        else
        {
            if (!hit)
            {
                hit = true;
            }
            else
            {
                AddStep(moves, new Step(row, col, temp_row, col), c);
                break;
            }
        }
    }

    temp_row = row;
    hit = false;
    while (temp_row < 9)
    {
        temp_row++;
        if (board[temp_row, col].type == ChessType.空)
        {
            if (!hit)
            {
                AddStep(moves, new Step(row, col, temp_row, col), c);
            }
        }
        else if (board[temp_row, col].color == c)
        {
            if (!hit)
            {
                hit = true;
            }
            else
            {
                break;
            }
        }
        else
        {
            if (!hit)
            {
                hit = true;
            }
            else
            {
                AddStep(moves, new Step(row, col, temp_row, col), c);
                break;
            }
        }
    }

    int temp_col = col;
    hit = false;
    while (temp_col > 0)
    {
        temp_col--;
        if (board[row, temp_col].type == ChessType.空)
        {
            if (!hit)
            {
                AddStep(moves, new Step(row, col, row, temp_col), c);
            }
        }
        else if (board[row, temp_col].color == c)
        {
            if (!hit)
            {
                hit = true;
            }
            else
            {
                break;
            }
        }
        else
        {
            if (!hit)
            {
                hit = true;
            }
            else
            {
                AddStep(moves, new Step(row, col, row, temp_col), c);
                break;
            }
        }
    }

    temp_col = col;
    hit = false;
    while (temp_col < 8)
    {
        temp_col++;
        if (board[row, temp_col].type == ChessType.空)
        {
            if (!hit)
            {
                AddStep(moves, new Step(row, col, row, temp_col), c);
            }
        }
        else if (board[row, temp_col].color == c)
        {
            if (!hit)
            {
                hit = true;
            }
            else
            {
                break;
            }
        }
        else
        {
            if (!hit)
            {
                hit = true;
            }
            else
            {
                AddStep(moves, new Step(row, col, row, temp_col), c);
                break;
            }
        }
    }
}

private int AdjustRow(ChessColor c, int row)
{
    if (c == ChessColor.黑)
    {
        return Row - 1 - row;
    }
    return row;
}

private int AdjustCol(ChessColor c, int col)
{
    if (c == ChessColor.黑)
    {
        return Col - 1 - col;
    }
    return col;
}

private int AdjustChange(ChessColor c)
{
    if (c == ChessColor.黑)
    {
        return -1;
    }
    return 1;
}

private void AddStep(List<Step> moves, Step step, ChessColor c)
{
    if (step.ToRow < 0 || step.ToRow >= Row)
    {
        return;
    }
    if (step.ToCol < 0 || step.ToCol >= Col)
    {
        return;
    }
    if (board[step.ToRow, step.ToCol].type != ChessType.空 && board[step.ToRow, step.ToCol].color == c)
    {
        return;
    }

    moves.Add(step);
}

3.2 走法排序

走法排序的目的是使用历史启发算法。我们先来看一下代码：

protected override void SortMove(List<Step> steps)
{
    for (int i = steps.Count - 1; i >= 0; i--)
    {
        Step step = steps[i];

        //杀子优先
        switch (board[step.ToRow, step.ToCol].type)
        {
            case ChessType.卒:
                step.value = VALUE卒 * (1 << AlgorithmDepth) / 10;
                break;
            case ChessType.士:
                step.value = VALUE士 * (1 << AlgorithmDepth) / 10;
                break;
            case ChessType.将:
                step.value = VALUE将 * (1 << AlgorithmDepth) / 10;
                break;
            case ChessType.炮:
                step.value = VALUE炮 * (1 << AlgorithmDepth) / 10;
                break;
            case ChessType.象:
                step.value = VALUE象 * (1 << AlgorithmDepth) / 10;
                break;
            case ChessType.车:
                step.value = VALUE车 * (1 << AlgorithmDepth) / 10;
                break;
            case ChessType.马:
                step.value = VALUE马 * (1 << AlgorithmDepth) / 10;
                break;
            default:
                step.value = 0;
                break;
        }

        //历史启发
        int from_chess = GetStepNum(step);
        if (history_score.ContainsKey(from_chess))
        {
            step.value += history_score[from_chess];
        }
    }

    steps.Sort();
}

排在前面的走法会被优先考虑，我们一般使用之前出现剪枝的走法。根据本人的经验，杀子的走法一般都是比较好的走法，所以就同时考虑了杀子优先。特别是在开局的时候，杀子优先作用更大。

3.3 估值算法

先看代码：

protected override int Evaluation(ChessColor c, Step[] pre_steps)
{
    int score = 0;
    for (int i = 0; i < Row; i++)
    {
        for (int j = 0; j < Col; j++)
        {
            Chess chess = board[i, j];
            if (chess.type != ChessType.空)
            {
                int temp_score = 0;
                List<Step> moves = new List<Step>();
                switch (chess.type)
                {
                    case ChessType.卒:
                        temp_score = VALUE卒;
                        GenerateMove卒(i, j, chess.color, moves);
                        temp_score += moves.Count * STEP卒;
                        break;
                    case ChessType.炮:
                        temp_score = VALUE炮;
                        GenerateMove炮(i, j, chess.color, moves);
                        temp_score += moves.Count * STEP炮;
                        break;
                    case ChessType.马:
                        temp_score = VALUE马;
                        GenerateMove马(i, j, chess.color, moves);
                        temp_score += moves.Count * STEP马;
                        break;
                    case ChessType.士:
                        temp_score = VALUE士;
                        GenerateMove士(i, j, chess.color, moves);
                        temp_score += moves.Count * STEP士;
                        break;
                    case ChessType.象:
                        temp_score = VALUE象;
                        GenerateMove象(i, j, chess.color, moves);
                        temp_score += moves.Count * STEP象;
                        break;
                    case ChessType.车:
                        temp_score = VALUE车;
                        GenerateMove车(i, j, chess.color, moves);
                        temp_score += moves.Count * STEP车;
                        break;
                    case ChessType.将:
                        temp_score = VALUE将;
                        break;
                }

                if (chess.color == c)
                {
                    score += temp_score;
                }
                else
                {
                    score -= temp_score;
                }
            }
        }
    }

    return score;
}

在《PC游戏编程（人机博弈）》一书里，估值考虑了三种情况。一是每种棋子的价值，二是每种棋子的灵活性，三是棋子是否受到了威胁。前面两种情况计算还是比较快的，第三种情况则较慢（测试得出）。我认为，其实这一局的收到威胁，就是下一局的杀子。多一层，其实就是考虑了威胁，所以不必考虑威胁这种情况。上面的代码就是只考虑棋子价值和灵活性。在这样的情况下，我的电脑可以运行6层，而如果加上威胁检测，就只能运行5层了。

还是叫明
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【创新】教你用python做五子棋AI（含代码）
2401_86187906的博客
07-11 626
【创新】教你用python做五子棋AI（含代码）
五子棋 AI（一）
大田二十
03-26 4365
五子棋 AI（一）
五子棋AI版
04-03
简单的AI，可用于大学编程作业，其中的代码易懂，一般能战胜大部分人。
五子棋人工智能算法设计与实现
03-12
这是关于益智小游戏——五子棋人工智能的算法设计与实现，专业论文
五子棋(简易AI)
10-23
一个带有简易AI的五子棋小游戏，采用了极大极小搜索和估值函数，对弈规则是：指定开局、三手交换、五手N打、禁手
Android studio-人工智能：中国象棋
07-15
代码中有注释（很多）人机对弈（已经更新最新版本，文件介绍：https://blog.csdn.net/weixin_46409629/article/details/125353521?utm_source=app&app_version=5.5.0&code=app_1562916241&uLinkId=usr1mkqgl919blen）
中国象棋和五子棋 联网版 源码
06-24
中国象棋和五子棋，包含了客户端和服务端，支持玩家匹配，聊天，观战，其中中国象棋还实现了人机博弈，开发工具 intelliJ IDEA 2018.1 和 Android Studio 3.4，mysql 5.0+
象棋五子棋AI源代码（C#）
11-26
标题中的“象棋五子棋AI源代码（C#）”指的是使用C#编程语言编写的象棋和五子棋游戏的人工智能算法实现。这些AI算法是游戏的核心部分，负责模拟对手的行为，使得计算机能够与玩家进行智能对弈。 在描述中提到，...
Qt做的多种游戏俄罗斯方块贪吃蛇五子棋象棋等
08-20
首先，我们可以看到一个“基于QT中国象棋游戏毕业设计答辩.pdf”，这表明该文档详细介绍了如何使用Qt来设计和实现一款中国象棋游戏。在这样的项目中，开发者可能涉及到图形用户界面（GUI）的设计，包括棋盘和棋子的...
Android 小游戏象棋五子棋
04-23
在Android平台上开发一款小游戏，比如象棋五子棋，是一个有趣的编程挑战，它涉及到许多核心技术和组件。五子棋是一款简单但策略丰富的游戏，玩家通过在棋盘上放置黑或白棋子，尝试先连成五子直线者获胜。在这个过程...
IOS游戏开发之五子棋OC版
01-05
先上效果图 – 功能展示 – 初高级棋盘切换效果 实现思路及主要代码详解 1.绘制棋盘 利用Quartz2D绘制棋盘.... - (void)drawBackground:(CGSize)size{ self.gridWidth = (size.width - 2 * kBoardSpace) / self....
五子棋ai(C#)
01-01
自己C#写的五子棋AI，智能程度不是很高，适合初学者学习.
五子棋带ai
12-29
五子棋附ai附教程内容详细，适合初学者参考学习。。。
五子棋AI算法
09-27
五子棋AI算法，采用Java实现，支持与电脑对战，自行选择难度和先手。 对应博文： https://blog.csdn.net/feifei316631241/article/details/82874681
机器学习五子棋AI
08-02
机器学习五子棋 AI,构建决策树，代码中有大量数据，用于教会ai决定是及时阻止对方，还是提高自己的连子数。(跑两次不同的决策树)
中国象棋源码 ---深入浅出的AI算法详解
09-19
中国象棋源码，基于王小春《PC游戏编成--人机对弈》 版权归原作者所有 。
五子棋AI（C++、QT）
最新发布
HuanBianCheng27的博客
08-20 2259
学习视频链接五子棋-3_bilibili_哔哩哔哩_bilibili。
AI版的五子棋小游戏
ym18861512953的博客
01-03 7167
本项目实现的五子棋博弈游戏是双人的、完备信息的五子棋问题。游戏模式可以分为人机对弈和双人对弈两种模式。本程序采用基于启发式max/min算法的alpha-beta剪枝技术来选择出最佳的机器落子位置。除此之外，我们还设置了残局闯关模式，在增加了游戏趣味性的同时给用户们带来了更好的游戏体验。
五子棋AI设计
热门推荐
pi9nc的专栏
09-01 4万+
五子棋AI设计——从门外到门内不得不说的事儿1 分类： 人工智能 AI 五子棋 Naive2012-06-08 09:48 278人阅读 评论(0) 收藏 举报 mfc测试 这学期选了人工智能原理，上课的时候完全没搞懂老师要讲什么，所以听课听得云里雾里的，幸好有几个小实验，可以帮助理解人工智能的精髓。 第一个实验就是基于带alpha-beta剪枝的MinMax搜索的五子
Java GUI实现的五子棋博弈与AI策略探索
博弈论作为一门学科，起初主要关注象棋、桥牌等棋类游戏中的策略分析，但随着理论的发展，它逐渐扩展到对预测行为和优化策略的研究。 五子棋作为中国传统棋种，棋盘为15x15，黑白棋子的放置规则简单却富有策略性。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值