MFC随机博弈黑白棋

随机博弈黑白棋

随机博弈黑白棋

TxyITxs | 随机博弈黑白棋 | 2019.04.21

摘要

通过随机落子，实现黑白棋的博弈。无任何落子规则，棋子死活与围棋中棋子的死活一致，即存在至少一口气。动态模拟双方博弈，但棋盘无落子位置时停止。

设计思路

主要基于时钟来实现动态博弈，考虑博弈的持续性数据修改，黑白双方需要互斥访问数据以及正确界面绘制，通过设置两个时钟，一个时钟主要负责界面背景，棋盘网格，黑白棋子绘制，绘制完后，释放数据使用权；另一个时钟主要负责博弈落子（即修改数据），通过在可落子位置随机选择一个，然后释放数据使用权。

棋盘数据使用N*N大小的一维数组Tdata存储，棋子坐标（x,y）对应的数组通过x*N+y计算。棋盘所用可落子位置通过向量vector<CPoint>Tpos来存储，通过随机产生一个索引来得到一个落子位置，然后将该索引对应Tpos的位置删除，修改Tdata中对应位置的值。

1. UI设计

1.1 利用基于对环框的MFC程序框架来搭建UI界面，主要涉及到界面背景色绘制，棋盘网格绘制，以及通过访问数据绘制棋子。

1.2 棋盘背景绘制

void TChessBgUI(CClientDC *dc)

{

CPen pen(PS_SOLID, 1, RGB(0, 0, 0));

CBrush *pbrush = CBrush::FromHandle((HBRUSH)GetStockObject(GRAY_BRUSH));

dc->SelectObject(&pen);

dc->SelectObject(pbrush);

CRect bg;

GetClientRect(bg);

dc->FillRect(bg, pbrush);

}

1.3 棋盘网格绘制，绘制的起始位置CPoint Tst，绘制的结束位置CpointTed，网格间距Tchline，网格的大小N*N。

void TChessUI(CClientDC *dc)

{

CPen pen(PS_SOLID, 1, RGB(0, 0, 0));

dc->SelectObject(&pen);

for (int i = Tst.x; i <= Ted.x; i += Tchline)

{

dc->MoveTo(i, Tst.y);

dc->LineTo(i, Ted.y);

}             

for (int j = Tst.y; j <= Ted.y; j += Tchline)

{

dc->MoveTo(Tst.x, j);

dc->LineTo(Ted.x, j);

}

}

 

1.4 绘制棋子

void TshowLayout(CClientDC *dc)

{

CPen pen(PS_SOLID, 1, RGB(0, 0, 0));

CBrush *pbrush = NULL;

dc->SelectObject(&pen);

int PieceSize = 10;

for (int i = 0; i < Tcount; i++)

{

for (int j = 0; j < Tcount; j++)

{

        if (Tdata[i*Tcount + j] ==1)

        {

               pbrush = CBrush::FromHandle((HBRUSH)GetStockObject(WHITE_BRUSH));

        dc->SelectObject(pbrush);

        dc->Ellipse(Tst.x+Tchline*i-PieceSize, Tst.y+Tchline *j- PieceSize, Tst.x + Tchline*i + PieceSize, Tst.y + Tchline *j + PieceSize);

        }

        if (Tdata[i*Tcount + j] == -1)

        {

               pbrush = CBrush::FromHandle((HBRUSH)GetStockObject(BLACK_BRUSH));

        dc->SelectObject(pbrush);

        dc->Ellipse(Tst.x + Tchline*i - PieceSize, Tst.y + Tchline *j - PieceSize, Tst.x + Tchline*i + PieceSize, Tst.y + Tchline *j + PieceSize);

        }

}

}

}

2.数据存储

  2.1 全局变量，需要初始化。

vector<int> Tdata;数值0、1、-1，0代表该位置为空，1代表白棋，-1代表黑棋

       vector<CPoint> Tpos;棋盘可落子位置

       int Tcount =19;棋盘大小

       int Tchline = 30;网格间距

       CPoint  Tst;棋盘起始位置

       CPoint Ted;1棋盘结束位置

       int Twhite = -1;先手指示器

       bool Ttime = false;时钟调度指示器

3.博弈算法

3.1 随机落子模拟

void SimulationData()

{

default_random_engine dre;//随机数引擎

dre.seed((unsigned)time(NULL));

int pos = -1;

if(!Tpos.empty())

{

pos = dre() % Tpos.size();

if (Twhite==1)

{

        Tdata[Tpos[pos].x*Tcount + Tpos[pos].y] = 1;

        Twhite = -Twhite;//此时指示需提子的棋子颜色，以及下次落子的颜色

}

else if(Twhite == -1)

{

        Tdata[Tpos[pos].x*Tcount + Tpos[pos].y] = -1;

        Twhite = -Twhite;

}

Tpos.erase(Tpos.begin() + pos);

}

}

 

随机索引位置的产生，利用C++ 11新特性，使用随机数random类来产生，头文件#include<random>。

 

 

 

3.2  提子过程，将棋盘上Twhite指示的棋子的死子提出，增加棋盘落子可用位置；

 

void grape()

{

if (Twhite == 0)return;

else

{

vector<CPoint> grap;

vector<bool> visi;

visi.resize(Tcount*Tcount, false);

grap.clear();

for (int i = 0; i < Tcount; i++)

{

        for (int j = 0; j < Tcount; j++)

        {

               if (Tdata[i*Tcount + j] == Twhite)

               {

                   visi.resize(Tcount*Tcount, false);  

                    if (TisLive(i, j,visi) == false)

                             grap.push_back(CPoint(i, j));

               }

        }

}

while (!grap.empty())

{

        CPoint p=grap.front();

        Tdata[p.x*Tcount+p.y] = 0;

        Tpos.push_back(p);

        grap.erase(grap.begin());

}

}

 }

 

3.3 提子过程需要判断棋子的死活，利用深度搜索算法，判断棋子s(x,y)的死活，则需判断其四邻接棋子的死活，若s，为活棋，无需提子，返回ture，若s为死棋，则返回false；通过递归来实现。

bool TisLive(unsigned int i, unsigned int j, vector<bool>& visi)

{

if (i<0 || i>Tcount || j<0 || j>Tcount)

              return false;

       else if (Tdata[i*Tcount + j] == -Twhite)

       {

              return false;

       }

       else if (Tdata[i*Tcount + j] == 0)

       {

              return true;

       }

       else if(Tdata[i*Tcount+j]==Twhite&&visi[i*Tcount + j]==false)

       {

              visi[i*Tcount + j] = true;

              if (TisLive(i - 1, j,visi))

return true;

              if(TisLive(i, j - 1, visi))

 return true;

              if(TisLive(i+1, j, visi))  

return true;

              if(TisLive(i , j+ 1, visi))

 return true;

       }

      

        else return false;
        return false;

      }

3.4 onTimer函数

       在初始化函数中设置两个时钟；

      SetTimer(0, 1000, NULL);
      SetTimer(1, 10, NULL);

       两个时钟总用一个onTimer，通过nIDEvent来识别执行此函数的时钟。一个时钟负责UI绘制，一个时钟模拟数据变化。

void CWhiteBlackChessDlg::OnTimer(UINT_PTR nIDEvent)
{

    CClientDC dc(this);
    switch (nIDEvent)
    {
    case 0:
    {
        if (Ttime)
        {    
                SimulationData();
                grape();
                Ttime = false;
        }
    }
        break;
    case 1:
    {    
        
        if (!Ttime)
        {        
            TChessBgUI(&dc);
            TChessUI(&dc);
            TshowLayout(&dc);
            Ttime = true;        
            if (Tpos.empty())
            {
                KillTimer(0);    
                KillTimer(1);
            }
        }
    }break;
    default:break;
    }
    CDialogEx::OnTimer(nIDEvent);
}

 

3.5 初始化函数

void TInit()
    {
        Tdata.resize(Tcount*Tcount,0);
        Tpos.resize(Tcount*Tcount);
        Tst.SetPoint(30, 30);
        Ted.SetPoint(Tchline * Tcount, Tchline * Tcount);
        for (int i = 0; i < Tcount; i++)
        {
            for (int j = 0; j < Tcount; j++)
                Tpos[i*Tcount + j] = CPoint(i, j);
        }
    }

总结

1. 在实践过程中，动态模拟的持续性，采用面向过程的算法设计思路，常常导致程序阻塞，因为动态模拟需要使用循环，这可能导致数据一直动态修改，由于循环，导致无法执行到界面绘制代码，界面的控制信息无法捕捉和执行，鉴于这种情况，可以采用时钟或者多线程来实现。
2. UI界面采用了模块化设计思路，对程序的复用提供了可能；
3. 可以利用该框架，重写提子或落子函数，模拟自然界中的动态变化现象，可以通过直观UI看到变化情况。
4. 目前程序尚不完善。