四国军棋引擎开发（2）简单的事件驱动模型下棋

最新推荐文章于 2019-03-17 21:42:11 发布
最新推荐文章于 2019-03-17 21:42:11 发布
阅读量611 收藏 3
点赞数 1
分类专栏： 四国军棋 四国军棋开发 文章标签： 四国军棋 人工智能 事件驱动
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pfysw/article/details/82256133
版权

这次在随机乱下的基础上加上了一些简单的处理，如进营、炸棋、吃子等功能，在和敌方棋子产生碰撞之后会获取敌方棋子大小的一些信息，目前采用的是事件驱动模型，当下完一步棋界面返回结果后会判断是否触发了相关事件，有事件发生则处理相关事件，没有事件发生则仍然是随机下棋。

1.事件驱动模型

首先定义一个各种事件的枚举变量，目前的事件有工兵吃子，摸暗棋，进营，明确吃子，炸棋。定义如下：

enum MoveEvent{
    GONGB_EVENT,
    DARK_EVENT,
    CAMP_EVENT,
    EAT_EVENT,
    BOMB_EVENT
};

事件的优先级由小到大，要改变优先级只需要调整枚举变量的顺序，其他地方不用变。

定义了事件的枚举变量后，当然还要把事件与相应的处理函数进行绑定，并将其放在一个数组里面：

EventHandle eventArr[] = {
    { ComeInCamp, CAMP_EVENT },
    { ProBombEvent, BOMB_EVENT },
    { ProEatEvent, EAT_EVENT },
    { ProEatEvent, GONGB_EVENT },
    { ProEatEvent, DARK_EVENT }
};

在每一次轮到本方行棋时会进行事件检测：

void CheckMoveEvent(
    Engine *pEngine,
    BoardChess *pSrc,
    BoardChess *pDst,
    MoveResultData* pResult)
{
    int type = pResult->result;
    if( type==MOVE || type==EAT  )
    {
        if( pDst->pLineup->iDir%2!=ENGINE_DIR%2 )
        {
            CheckCampEvent(pEngine,pDst);
        }
    }
    //在里面检查是否是引擎方
    CheckBombEvent(pEngine);
    CheckEatEvent(pEngine);
}

如果检测到了有相应的事件发生，则处理事件，否则仍然接着调用随机下棋模块

u8 DealEvent(Engine *pEngine)
{
    u8 isMove = 0;
    int i;
    u8 eventFlag = 0;
    u8 eventId = 0;
    u8 index;

    for(i=0; i<sizeof(eventArr)/sizeof(eventArr[0]); i++)
    {
        if( TESTBIT(aEventBit, eventArr[i].eventId) )
        {
            if( eventArr[i].eventId>=eventId )
            {
                //处理优先级最高的事件
                eventId = eventArr[i].eventId;
                index = i;
            }
            eventFlag = 1;
        }
    }

    if( eventFlag )
    {
        isMove = eventArr[index].xEventFun(pEngine);
    }

    return isMove;
}

2.进营事件

进营的检测是这样的，当敌方有棋子移动后，锁定这个棋子，观察这个棋子的周围是否有本方的营，如果有则触发进营事件。如下图所示，就触发了一个进营事件：
这里写图片描述
当然此时紫方下了轮到绿方下，绿方并不能处理这个事件，然后再轮到蓝方下，蓝方下完后也可能触发进营事件，所以现在保留2个进营事件，防止之前的进营事件被覆盖：

    //遍历该棋子的所有邻居
    for(i=0; i<9; i++)
    {
        if( i==4 ) continue;
        x = pChess->point.x+1-i%3;
        y = pChess->point.y+i/3-1;
        if(x<0||x>16||y<0||y>16) continue;

        if( pJunqi->aBoard[x][y].pAdjList )
        {

            pNbr = pJunqi->aBoard[x][y].pAdjList->pChess;

            if( pNbr->isCamp && pNbr->type==NONE )
            {
                    //找到营将其放在pEngine->pCamp[0]里
                    if( TESTBIT(aEventBit, CAMP_EVENT) )
                    {
                        //如果之前有进营事件未处理，先备份起来
                        pEngine->pCamp[1] = pEngine->pCamp[0];
                    }
                    pEngine->pCamp[0] = pNbr;
                    SETBIT(aEventBit, CAMP_EVENT);
            }
        }
    }

在处理的时候先进第一个营，如果第一个营不能进，再看看第2个营能不能进，如果这2个进营的事件都已经完成则清除进营事件标志位

u8 ComeInCamp(Engine *pEngine)
{
    u8 isMove;
    //先进第一个营
    isMove = MoveInCamp(pEngine, pEngine->pCamp[0]);
    if( isMove )
    {
        pEngine->pCamp[0] = pEngine->pCamp[1];
        //没有进营事件时，清除该标志位
        if( pEngine->pCamp[1]==NULL )
        {
            CLEARBIT(aEventBit, CAMP_EVENT);
        }
        else
        {
            pEngine->pCamp[1] = NULL;
        }
    }
    //如果本方没有棋子可以进第一个营，则进第2个营
    else if( pEngine->pCamp[1] )
    {
        isMove = MoveInCamp(pEngine, pEngine->pCamp[1]);
        if( isMove )
        {
            pEngine->pCamp[1]=NULL;
        }
    }

    return isMove;
}

3.炸棋

炸棋事件的检测很简单，遍历敌方的棋子，看看自己的炸弹有没有对着大棋，如果对着大棋，则触发炸棋事件：

    for(i=0; i<30; i++)
    {
        pLineup = &pJunqi->Lineup[pJunqi->eTurn][i];
        if( pLineup->type==ZHADAN && !pLineup->bDead )
        {
            //检查2家敌方的棋有没有棋炸
            isMove = CanBombChess(pEngine, pLineup->pChess, (ENGINE_DIR+1)%4);
            if( isMove )
            {
                break;
            }
            else
            {
                isMove=CanBombChess(pEngine, pLineup->pChess, (ENGINE_DIR+3)%4);
                if( isMove ) break;
            }
        }
    }

如果有棋炸则记下来，要炸的棋子必须大于旅长

        //由于定义的关系，枚举变量从司令到工兵依次变大，所以这里不要搞混淆了
        if( pLineup->type>=SILING && pLineup->type<=LVZH )
        {
            if( IsEnableMove(pJunqi, pBomb, pLineup->pChess) )
            {
                //本方炸弹
                pEngine->pBomb[0] = pBomb;
                //要炸的棋
                pEngine->pBomb[1] = pLineup->pChess;
                SETBIT(aEventBit, BOMB_EVENT);
                isBomb = 1;

                break;
            }
        }

在处理事件时很简单，直接发送从pBomb[0]到pBomb[1]的移动即可

SendMove(pJunqi, pEngine->pBomb[0], pEngine->pBomb[1]);

3.吃子

吃子与炸棋类似，也就是看自己从工兵到司令的棋有没有对着地方的棋，如果有则触发吃子事件，这里有3种情况，分别是工兵挖雷，摸暗棋，吃明确小于自己的棋，其中前2种优先级较低，第3种优先级最高

        if( IsEnableMove(pJunqi, pSrc, pLineup->pChess) )
        {
            if( pSrc->pLineup->type!=GONGB )
            {
                //吃暗棋
                if( pLineup->type==DARK )
                {
                    pEngine->pEat[0] = pSrc;
                    pEngine->pEat[1] = pLineup->pChess;
                    SETBIT(aEventBit, DARK_EVENT);
                    isEat = 2;
                }
                //吃小于自己的棋
                else if( pSrc->pLineup->type<=pLineup->mx_type )
                {
                    pEngine->pEat[0] = pSrc;
                    pEngine->pEat[1] = pLineup->pChess;
                    SETBIT(aEventBit, EAT_EVENT);
                    isEat = 1;
                    break;
                }
            }
            //工兵只能吃底线的2排棋
            else if( pLineup->index>=20 && !pLineup->isNotLand)
            {
                pEngine->pEat[0] = pSrc;
                pEngine->pEat[1] = pLineup->pChess;
                SETBIT(aEventBit, GONGB_EVENT);
                isEat = 3;
            }

        }

4.判断大小

在每一次碰撞后都会记录下敌方棋子的大小，pLineup->type为棋子最小的可能性，初始化为dark，如果吃掉本方棋子，则至少比吃掉的棋高一级，pLineup->mx_type为对方最大棋子的可能性，初始化为司令，如果对方司令死掉或已走明，则最大为军长，如果军长也死掉或走明，则最大为师长，依次类推。

      //... ...
            //如果吃掉本方的棋不是地雷或军棋，则比吃掉棋的级别大一级
            if( pDst->type!=DILEI && pDst->type!=JUNQI )
            {
                pSrc->pLineup->type = pDst->type-1;
            }

关于司令的判断有2种，一种是收到亮军旗的判决，说明司令死了，另一种是吃掉军长。关于炸弹的判断，如果一方亮军棋了，另一方没亮说明是炸弹，如果地雷打兑也说明是炸弹。暗棋打兑后会将pLineup->bBomb标志位置1，将来再判断最大棋子的时候会用到。

关于地雷的判断，后2排的棋子移动则不是地雷，被工兵飞过也不是地雷，此时pLineup->isNotLand标志位置1，此后工兵不会再去飞这个子。如果撞死的类型超过了最大的类型，说明撞到地雷了

    if( type==KILLED )
    {
        pSrc->pLineup->bDead = 1;
        //自己的棋撞死
        if( pSrc->pLineup->iDir%2==ENGINE_DIR%2 )
        {
            if( pSrc->type==GONGB )
            {
                pDst->pLineup->isNotLand = 1;
            }
            pDst->pLineup->type = pSrc->type-1;
            //撞死的子超过最大可能类型
            if( pDst->pLineup->type<pDst->pLineup->mx_type )
            {
                pDst->pLineup->type = DILEI;
            }
        }

关于工兵的判断，首先暗棋移动非法，会沿着铁路转弯，普通棋不会转弯，可以判断为工兵

    if( pSrc->pLineup->type==DARK )
    {
        if( !IsEnableMove(pJunqi, pSrc, pDst) )
        {
            pSrc->pLineup->type = GONGB;
        }
    }

此外，地雷被挖说明是工兵，排长吃的子也是工兵。

每一次行棋判决后，都会重新预测每个棋子的最大可能性，由AdjustMaxType()函数完成。在这里先统计每种已经碰撞过的棋子种类的数量和暗棋打兑的数量

    u8 aTypeNum[14] = {0};
    u8 aBombNum[14] = {0};
    for(i=0; i<30; i++)
    {
        pLineup = &pJunqi->Lineup[iDir][i];
        if( pLineup->type==NONE || pLineup->type==DARK )
        {
            continue;
        }
        //pLineup->typ为碰撞后最小的棋子可能性
        //如吃掉我方团长，则至少是旅长，此时pLineup->type就是旅长
        aTypeNum[pLineup->type]++;
        //如果是打兑的可能是炸弹，也可能是真的打兑
        if( pLineup->bBomb )
        {
            aBombNum[pLineup->type]++;
        }
    }

接下来看最大类型的棋明棋是否到达最大数量如果达到最大数量则重新预测最大棋子，比如我预测某个棋子是军长，但是现在已明的棋中至少大于军长的棋有2个，那么说明这个棋的最大类型只能是师长，依次类推

    for(i=0; i<30; i++)
    {
        pLineup = &pJunqi->Lineup[iDir][i];
        if( pLineup->type==NONE || pLineup->type==DARK )
        {
            continue;
        }
        //pLineup->mx_type为最大类型，pLineup->type为最小类型
        while( pLineup->mx_type<pLineup->type )
        {
            //获取级别不小于pLineup->mx_type的所以类型，如果没到最大数量，则不用调整
            if( GetTypeNum(aBombNum,aTypeNum,pLineup->mx_type)<aMaxTypeNum[pLineup->mx_type] )
            {
                break;
            }
            //否则级别降1，继续调整
            else
            {
                pLineup->mx_type++;
            }
        }
    }

统计该级别所有明棋的数量时要注意考虑炸弹的情况，首先累计所有大于该级别的数量之和，再减去暗棋打兑的部分。但是如果有3个暗棋打兑，由于最多只有2个炸弹，那么不应该减3而应该减1，如果一个炸弹明了，则打兑中最多只有一个炸弹，所以应该减1，相关代码如下

int GetTypeNum(u8 *aBombNum, u8 *aTpyeNum, int type)
{
    int i;
    int sum = 0;
    int sum1 = 0;
    for(i=SILING; i<=type; i++)
    {
        sum += aTpyeNum[i];
        //sum1为暗棋打兑部分
        sum1 += aBombNum[i];
    }
    if( aTpyeNum[GONGB]>3 )
    {
        //工兵的数量大于3，说明有一个炸被兵飞掉了
        aTpyeNum[ZHADAN] += aTpyeNum[GONGB]-3;
    }
    assert( aTpyeNum[ZHADAN]<=2 );
    //减去暗棋打兑数量和暗炸数量的极小值
    sum -= (sum1<(2-aTpyeNum[ZHADAN]))?sum1:(2-aTpyeNum[ZHADAN]);
    return sum;
}

5.总结

目前这种方法存在很大的缺陷，棋盘上的各种情况太多，无法一一用事件处理来进行判断，在某些情况下事件的优先级是不一样的。而且同一时间吃子的情况有很多，该吃哪个不好界定，躲避对方大棋、防守、抓棋、摸棋等行棋走位都不好处理。所以这种事件驱动的方法实现起来非常繁琐，而且就算增加的事件再多效果也不一定好，所以暂时不打算在这种方法深入下去。接下来打算直接上α-β剪枝算法，先把棋力快速提高到一个正常人的水平再说。

源代码如下
https://github.com/pfysw/JunQi

偏test
关注
专栏目录
四国军棋希望对C++程序员有用啊
07-30
C++写的四国军棋希望对C++程序员有用啊
基于Python的四国军棋AI智能裁判
05-08
四国军棋是一种深受人们喜爱的策略棋类游戏，它需要玩家通过智慧和战术来取得胜利。在数字化时代，为了方便玩家对弈和提高游戏体验，基于Python的四国军棋AI智能裁判应运而生。这样的裁判系统利用了Python的强大功能...
四国军棋引擎开发（1）随机下棋
test
08-21 1680
一个多线程引发的问题 接下来说明一下解决的一个非常棘手的程序崩溃问题，曾一度调的都要放弃。在软件和界面联调时，经常出现莫名奇妙的界面显示异常，也经常出现GTK内部函数的断言错误，还时不时的出现内存引起的程序崩溃而推出。 这个问题不是必现，出现的概率是很高，但是又琢磨不透。自己手工测试很多次，加上打印信息，基本上可以确定是在通信线程执行行棋（即PlayResult）时出现的，但是没发现什么规律，...
四国军棋引擎开发（5）着法生成与棋谱分析
test
09-24 1051
1.着法生成 软件下棋时需要搜索大量的局面并对局面进行评估从而选出最好的着法，每一次行棋时生成所有可行的着法，每个着法产生后对应一个新的局面，然后下一家在新的局面基础上再生成所有着法。 军棋软件和普通的象棋软件的着法生成有所不同，象棋是明棋，每一步行棋的结果都是确定的，而军棋则不同，军棋是暗棋，在产生子力的碰撞后可能会有不同的结果，所以还要根据之前的子力判断分析生成可能的碰撞结果。 在下棋时引擎给...
四国军棋引擎开发（3）寻找到军旗的最短路径
test
09-09 1328
1.问题描述 本来打算接下来做α-β剪枝算法，但是我觉得还是要先解决下棋时一个非常蠢的问题，就是军旗都在旁边了却不懂得去挖。这里要解决的算法就是寻找本方棋子到对方军旗的通路，还要在所有通路中寻找最少步数的路径。这是一个非常有意思的算法场景，所以特地为这个问题来写一篇文章。 如下图所示，此时到军旗的路径有绿色和黄色2条，首先要把这2条路径找出来，然后由于绿色路径的长度是4，而黄色路径的长度是3，...
四国军棋引擎开发（9）子力概率判断分析
test
11-25 974
本文分为2部分，第1部分继续深入分析子力的概率问题，第2部分记录下刚刚碰到的一个非常棘手的bug，解决这个bug后，目前这个版本基本上没有什么明显的bug，可以作为版本为2.0。如果全部着法都搜索的话，1秒最多搜4层，军棋每步可行的走法太多，搜索已经很难优化了，接下来的主要优化在局面评估和局部搜索，目前2.0版本的测试结果如下： 引擎A vs 引擎B 战绩（胜：负：和） 1.1 vs ...
sgjq.rar_sgjq_军棋_四国军棋_四国军棋源码
09-22
而"sgjq.rar_sgjq_军棋_四国军棋_四国军棋源码"这个压缩包文件，则是关于四国军棋游戏的源代码实现，特别指出的是，它基于网狐6.6版本的框架进行开发。 网狐6.6是一款知名的网络游戏开发平台，它提供了强大的服务器...
siguojunqi.rar_siguojunqi_visual c_军棋_军棋小程序_四国军棋
09-20
【标题】"siguojunqi.rar_siguojunqi_visual c_军棋_军棋小程序_四国军棋" 涉及的主要知识点是基于Visual C++开发的一款四国军棋游戏小程序。Visual C++是一款由Microsoft开发的集成开发环境（IDE），它集成了编译器...
QQ四国军棋刷分软件--思路
03-18
QQ四国军棋刷分软件是一种利用编程技术来自动化游戏过程，从而达到快速积累分数的目的。这个主题涉及到多个IT领域的知识点，包括软件开发、游戏算法、网络编程以及可能的反作弊策略。 首先，我们需要理解软件开发的...
junqi.rar_军棋_四国军棋
09-23
四国军棋是一款深受棋类爱好者喜爱的策略游戏，它需要四位玩家分为两队，每队两名玩家，共同协作对抗对方。在这个游戏中，棋盘上布满了各种不同级别的棋子，包括军旗、司令、师长、旅长、团长、营长、连长、排长、...
计算机博弈大赛军棋平台
08-05
这是计算机博弈大赛中军棋项目的游戏平台,2013年版
双人军旗对战源码2012720
07-20
双人军旗对战源码 项目描述 开发环境：vs2008 一款使用C#开发的军旗游戏源码 可以局域网对战， 先建立主机，之后再创建从机， 连接上之后先点击读取布阵。然后自行布阵。 双方都布阵成功即可开始。 MyFile1.txt保存自己方布阵图， MyFile2.txt保存对方布阵图。
四国军棋 源代码
09-15
可以在多台或同一台与服务器联网的电脑上运行客户端程序，点击右上角的树形控件，双击军棋游戏，即可在左边显示大厅数据，只实现了一个大厅，最多容纳64个玩家同时游戏.
四国军棋界面Swing/AWT的代码
03-05
Windows cmd下,进入..\\bin目录，直接运行bat文件打包jar并运行 博文链接：https://metaphy.iteye.com/blog/180498
四国军棋引擎开发（7）概率分析与搜索优化
test
10-14 1081
1.概率分析 四国军棋属于不完全信息博弈，我们是看不到敌方的棋子，但是可以通过棋子间的碰撞来判断敌方的子力分布情况和棋子大小的概率。 当棋子产生碰撞后，可能的判决结果有吃子、打兑、撞死3种结果，有时还会附加是否亮军旗的信息，之前的处理只是简单的把所有情况取平均值，这是不对的，因为某些情况虽然存在，但是概率特别小，如果取平均值就会对着法评分的准确性造成很大的影响，所以更好的方式应该是对每一种情况生成...
四国军棋引擎开发（12）关键步加深搜索
test
03-17 648
调了很久终于能够更新一个版本了，这东西是越来越难调了，每一次输棋都要处理茫茫多的复杂逻辑，而且有些bug隐藏在递归的最深处很难定位，真希望软件可以像人一样自己学会想算法调代码做验证。 这次更新大的框架没有什么改动，只是调了很多很多的bug，最主要添加的功能是在搜索时记录一些关键步，在关键步如威胁到军旗时，再加深2层，从而在残局中能调集一些子力防守。 我不打算把这个软件的棋力做到顶尖，做到能稳赢...
四国军棋引擎开发（4）子力判断和局面评估初步
test
09-16 971
1.子力判断 子力判断在局面评估中起着非常重要的作用，在前一篇文章中已经介绍了子力判断的部分，那时相对还比较粗糙，这次会更细致的分析并优化上一次的不足。 pLineup-&gt;type用来代表棋子的类型，这里是用枚举变量来表示，要注意级别大的变量值小，如40的值是5，39的值是6，排长的值12，工兵的值是13，所以在级别比较的时候要注意区分变量的大小和级别的大小。本方棋子的类型是明确的，敌方...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值