Qt实现简单五子棋小游戏

c++代码简单实现五子棋功能，主要是分为窗口绘图的显示，横、纵、斜三个方面计算的功能代码实现，即能连续出现5个相同棋子就为赢。在这里就简单讲解一下这三个方面的功能实现(主要是通过qt实现)。

下图为游戏主窗口页面：

第一步：窗口绘图的实现（qpaintevent绘图事件 和 qmouseevent鼠标事件）

①鼠标事件（这里我的是mousedoubleclickevent()双击事件）

void gamepage::mousedoubleclickevent(qmouseevent *event)//鼠标双击事件
{
 m_dx = event->x();
 m_dy = event->y();
 //避免乱点时存入坐标 需添加：标志符--》game状态 坐标的界限（点）
 if(m_dx < point_x_max && m_dy < point_y_max && m_brunstate == true)
 {
  //如果点在交叉点周围则设置点在交叉点上（判断点位置）
  qpointf newpoint(gainpointposition(qpointf(m_dx,m_dy)));
 
  if(!m_vectorredpoint.contains(newpoint) &&       
   !m_vectorblackpoint.contains(newpoint))//判断点是否已经存在
  {
   if(m_iflagwho == 0)//红棋
   {
    m_vectorredpoint.append(newpoint);
    m_iflagwho = 1;
   }
   else//黑棋
   {
    m_vectorblackpoint.append(newpoint);
    m_iflagwho = 0;
   }
  }
 
 }
}

在这里窗口网格图是通过直接绘画以及鼠标双击选择坐标来存储棋子和绘画棋子，因此对点进行了一个设置位置函数以便处于两线之间的交接处，代码如下：

qpointf gamepage::gainpointposition(qpointf srcpoint)//返回一个处于格子两线交接处的坐标点
{
 qpointf tmp;
 for(int i = 0;i < 12;i++)
 {
  if(srcpoint.x() >= 50*i && srcpoint.x() <= (50*i+25))//x判断
  {
   tmp.setx(50*i);//如果处于50*i ~ 50*i+25）之间则设置点坐标点为50*i
  }
  else if (srcpoint.x() >= (50*i + 25) && srcpoint.x() <= 50*(i+1))
  {
   tmp.setx(50*(i+1));//如果处于50*i+25 ~ 50*(i+1)之间则设置点坐标点为50*(i+1)
  }
  if(srcpoint.y() >= 50*i && srcpoint.y() <= (50*i+25))//y判断
  {
   tmp.sety(50*i);//同上
  }
  else if (srcpoint.y() >= (50*i + 25) && srcpoint.y() <= 50*(i+1))
  {
   tmp.sety(50*(i+1));//同上
  }
 
 }
 return tmp;
}

②绘图事件( 主要是网格图、黑棋、红棋的绘画 )

棋子坐标的存储主要是通过qvector容器来实现,并对容器进行迭代循环绘图，实现代码如下：

void gamepage::paintevent(qpaintevent *event)//绘画事件
{
 qpainter *pater = new qpainter(this);
 pater->begin(this);
 //网格图
 pater->setpen(qt::black);
 for(int i = 0;i <= 12;i++)
 {
  pater->drawline(0,50*i,600,50*i);
  pater->drawline(50*i,0,50*i,600);
 }
 
 //红色棋绘画
 qvector<qpointf>::iterator iter;
 for(iter = m_vectorredpoint.begin();iter != m_vectorredpoint.end();iter++)
 {
  pater->setbrush(qbrush(qt::red, qt::solidpattern));
  pater->setpen(qt::red);
  pater->drawellipse(*iter,15,15);
 }
 //黑色棋绘画
 qvector<qpointf>::iterator iter1;
 for(iter1 = m_vectorblackpoint.begin();iter1 != m_vectorblackpoint.end();iter1++)
 {
  pater->setbrush(qbrush(qt::black, qt::solidpattern));
  pater->setpen(qt::black);
  pater->drawellipse(*iter1,15,15);
 }
 pater->end();
 update();
 
}

第二步：输赢的计算

上图列出了计算的关系规律，下面就用代码分别实现三个不同方向的计算：

①横向

bool gamepage::checkxpointf(qvector<qpointf> vector) //检查x轴方向的
{
  int num_l= 1;
  int num_r = 1;
  qvector<qpointf>::iterator iter;
  qvector<qpointf>::iterator itertmp;
  for(iter = vector.begin();iter != vector.end();iter++)
  {
   qpointf tmp = *iter;
   for(int k = 1;k < 5;k++)//左方向的查找
   {
    for(itertmp = vector.begin();itertmp != vector.end();itertmp++)
    {
 
     qdebug()<<*itertmp<<"x compare"<<tmp;
     if((*itertmp).x() - tmp.x() == k*50)
     {
      num_l ++;
     }
    }
    //qdebug()<<"count:"<<num;
    if(num_l == k+1)//寻找过程中找到几个点相连
    {
     if(num_l == 5)
     {
      return true;
     }
    }
    else
    {
     break;
    }
   }
 
   for(int k = 1;k < 5;k++)//右方向的查找
   {
    for(itertmp = vector.begin();itertmp != vector.end();itertmp++)
    {
     qdebug()<<*itertmp<<"x compare"<<tmp;
     if((*itertmp).x() - tmp.x() == -k*50)
     {
      num_r ++;
     }
   }
    //qdebug()<<"count:"<<num;
   if(num_r == k+1)//寻找过程中找到几个点相连
   {
    if(num_r == 5)
    {
     return true;
    }
   }
   else
   {
    break;
   }
  }
  if(num_r + num_l == 5+1)//5+1 因为左右方向都是从1开始计算 重复了原点tmp坐标
  {
   return true;
  }
  else
  {
   num_r = 1;
   num_l = 1;
 
  }
 }
 return false;
}

②纵向（与横向同理）

bool gamepage::checkypointf(qvector<qpointf> vector)
{
  qdebug()<<"enter y***************";
 int num_u = 1;
   int num_d = 1;
  qvector<qpointf>::iterator iter;
  qvector<qpointf>::iterator itertmp;
  for(iter = vector.begin();iter != vector.end();iter++)
  {
   qpointf tmp = *iter;
   for(int k = 1;k < 5;k++)//上
   {
    for(itertmp = vector.begin();itertmp != vector.end();itertmp++)
    {
 
     qdebug()<<*itertmp<<"y compare"<<tmp;
     if((*itertmp).y() - tmp.y() == k*50)
     {
      num_u ++;
     }
    }
    qdebug()<<"num_u:"<<num_u;
    if(num_u == k+1)//寻找过程中找到几个点相连
    {
     if(num_u == 5)
     {
      return true;
     }
    }else{break;}
   }
   for(int k = 1;k < 5;k++)//下
   {
    for(itertmp = vector.begin();itertmp != vector.end();itertmp++)
    {
     qdebug()<<*itertmp<<"y compare"<<tmp;
     if((*itertmp).y() - tmp.y() == -k*50)
     {
      num_d ++;
     }
 
    }
   qdebug()<<"num_d:"<<num_d;
   if(num_d == k+1)//寻找过程中找到几个点相连
   {
    if(num_d == 5)
    {
     return true;
    }
   }else{break;}
  }
  if(num_d + num_u == 5 + 1)//减去一个
  {
   return true;
  }
  else
  {
   num_d = 1;
   num_u= 1;
  }
 }
 
 return false;
}

③斜向（从上图可知，以坐标系为例，分为四个象限的计算和计数来判断是否达到要求）

int gamepage::findseriespointf(bool flag, qpointf tmp, qvector<qpointf> vector)
{
  bool flag_iter = false;
  int forward_count = 1;//一象限的数量
  int reverse_count = 1;
  int forward_count2 = 1;
  int reverse_count2 = 1;
  qvector<qpointf>::iterator iter= vector.begin();
 
  while(iter != vector.end())
  {
   qdebug()<<*iter<<"compare"<<tmp;
   switch(forward_count)//一象限
   {
    case 1:
     if((*iter).x() - tmp.x() == 50 && (*iter).y() - tmp.y() == -50)
     {
      forward_count ++;
 
      flag_iter = true;
     }
     break;
    case 2:
     if((*iter).x() - tmp.x() == 50*forward_count && (*iter).y() - tmp.y() == -50*forward_count)
     {
      forward_count++;
      flag_iter = true;
     }
     break;
    case 3:
     if((*iter).x() - tmp.x() == 50*forward_count && (*iter).y() - tmp.y() == -50*forward_count)
     {
      forward_count++;
      flag_iter = true;
     }
     break;
    case 4:
     if((*iter).x() - tmp.x() == 50*forward_count && (*iter).y() - tmp.y() == -50*forward_count)
     {
      forward_count++;
      flag_iter = true;
     }
     break;
 
   }
   switch(reverse_count)//三象限
   {
    case 1:
     if((*iter).x() - tmp.x() == -50 && (*iter).y() - tmp.y() == 50)
     {
      reverse_count=2;
      flag_iter = true;
     }
     break;
    case 2:
     if((*iter).x() - tmp.x() == -50*reverse_count && (*iter).y() - tmp.y() == 50*reverse_count)
     {
      reverse_count++;
      flag_iter = true;
     }
     break;
    case 3:
     if((*iter).x() - tmp.x() == -50*reverse_count && (*iter).y() - tmp.y() == 50*reverse_count)
     {
      reverse_count++;
      flag_iter = true;
     }
     break;
    case 4:
     if((*iter).x() - tmp.x() == -50*reverse_count && (*iter).y() - tmp.y() == 50*reverse_count)
     {
      reverse_count++;
      flag_iter = true;
     }
     break;
 
   }
   qdebug()<<forward_count<<"+"<<reverse_count;
   if(forward_count + reverse_count == 6)//未加上点本身
   {
    return 5;
 
   }
 
   switch(forward_count2)//2象限
   {
    case 1:
     if((*iter).x() - tmp.x() == -50 && (*iter).y() - tmp.y() == -50)
     {
      forward_count2++;
      flag_iter = true;
     }
     break;
    case 2:
     if((*iter).x() - tmp.x() == -50*forward_count2 && (*iter).y() - tmp.y() == -50*forward_count2)
     {
      forward_count2++;
      flag_iter = true;
     }
     break;
    case 3:
     if((*iter).x() - tmp.x() == -50*forward_count2 && (*iter).y() - tmp.y() == -50*forward_count2)
     {
      forward_count2++;
      flag_iter = true;
     }
     break;
    case 4:
     if((*iter).x() - tmp.x() == -50*forward_count2 && (*iter).y() - tmp.y() == -50*forward_count2)
     {
      forward_count2++;
      flag_iter = true;
     }
     break;
   }
 
   switch(reverse_count2)//4象限
   {
    case 1:
     if((*iter).x() - tmp.x() == 50 && (*iter).y() - tmp.y() == 50)
     {
      reverse_count2++;
      flag_iter = true;
     }
     break;
    case 2:
     if((*iter).x() - tmp.x() == 50*reverse_count2 && (*iter).y() - tmp.y() == 50*reverse_count2)
     {
      reverse_count2++;
      flag_iter = true;
     }
     break;
    case 3:
     if((*iter).x() - tmp.x() == 50*reverse_count2 && (*iter).y() - tmp.y() == 50*reverse_count2)
     {
      reverse_count2++;
      flag_iter = true;
     }
     break;
    case 4:
     if((*iter).x() - tmp.x() == 50*reverse_count2 && (*iter).y() - tmp.y() == 50*reverse_count2)
     {
      reverse_count2++;
      flag_iter = true;
     }
     break;
   }
   qdebug()<<forward_count2<<"+"<<reverse_count2;
   if(forward_count2 + reverse_count2 == 6)//未加上点本身
   {
    return 5;
   }
   if(flag_iter)
   {
     iter = vector.begin();//目的是返回首个点，重头存货在后 不错过
     flag_iter = false;
   }
   else {
     iter++;
   }
 
  }
 
  return 0;
}

以上横、纵、斜三个方向的运算都是通过最简单的算法是实现，易于理解。

④定时器实现红黑旗的定时检查功能

void gamepage::slotcheckwhetherwin()//定时器检查是否输赢功能
{
  m_pvervector.clear();
  m_pvervectorb.clear();
  m_phervector.clear();
  m_phervectorb.clear();
 
  qvector<qpointf>::iterator iterred;
  for(iterred = m_vectorredpoint.begin();iterred != m_vectorredpoint.end();iterred++)
  {
   qdebug()<<*iterred;
  }
  qvector<qpointf> tmpred = m_vectorredpoint;
  //红棋判断
  if(m_vectorredpoint.size() >= 5)
  {
   for(iterred = m_vectorredpoint.begin();iterred != m_vectorredpoint.end();iterred++)
   {
 
    qpointf tmp = *iterred;//获取第一个点
    qdebug()<<"tmp:"<<tmp;
    qvector<qpointf>::iterator itertmp;
    for(itertmp = tmpred.begin();itertmp != tmpred.end();itertmp++)
    {
     qdebug()<<"tmpred:"<<*itertmp;
     //横向连续5个点
     if((*itertmp).y() - tmp.y() >= -0.000001 && (*itertmp).y() - tmp.y() <= 0.000001)//先判断y是同一坐标
     {
       m_phervector.append(*itertmp);
     }
     //纵向连续5个点
     if((*itertmp).x() - tmp.x() >= -0.000001 && (*itertmp).x() - tmp.x() <= 0.000001)//先判断y是同一坐标
     {
       m_pvervector.append(*itertmp);
     }
 
    }
    //对容器进行操作
    if(checkxpointf(m_phervector) || checkypointf(m_pvervector))
    {
     qmessagebox::warning(nullptr,"warning","红方xy赢了!");
     m_ptimer->stop();
     return;
    }
    else
    {
     m_phervector.clear();//清空
     m_pvervector.clear();//清空
     count = 0;
    }
 
    //其他都是斜向
    if(findseriespointf(true,tmp,m_vectorredpoint) == 5)
    {
     qmessagebox::warning(nullptr,"warning","红方斜线赢了!");
     m_ptimer->stop();
     return;
    }
   }
 
  }
  //黑棋判断
  qvector<qpointf>::iterator iterblack;
  qvector<qpointf> tmpblack = m_vectorblackpoint;
  if(m_vectorblackpoint.size() >= 5)
  {
   for(iterblack = m_vectorblackpoint.begin();iterblack != m_vectorblackpoint.end();iterblack++)
   {
 
    qpointf tmp = *iterblack;//获取第一个点
    qdebug()<<"tmp:"<<tmp;
    qvector<qpointf>::iterator itertmp;
    for(itertmp = tmpblack.begin();itertmp != tmpblack.end();itertmp++)//正向
    {
     qdebug()<<"tmpred:"<<*itertmp;
     //横向连续5个点
     if((*itertmp).y() - tmp.y() >= -0.000001 && (*itertmp).y() - tmp.y() <= 0.000001)//先判断y是同一坐标
     {
       m_phervectorb.append(*itertmp);
     }
     //纵向连续5个点
     if((*itertmp).x() - tmp.x() >= -0.000001 && (*itertmp).x() - tmp.x() <= 0.000001)//先判断y是同一坐标
     {
       m_pvervectorb.append(*itertmp);
     }
 
    }
    //对容器进行操作
    if(checkxpointf(m_phervectorb) || checkypointf(m_pvervectorb))
    {
     qmessagebox::warning(nullptr,"warning","黑方xy赢了!");
     m_ptimer->stop();
     return;
    }
    else
    {
     m_phervectorb.clear();//清空
     m_pvervectorb.clear();//清空
     count = 0;
    }
 
    //其他都是斜向
    if(findseriespointf(true,tmp,m_vectorblackpoint) == 5)
    {
     qmessagebox::warning(nullptr,"warning","黑方斜线赢了!");
     m_ptimer->stop();
     return;
    }
   }
 
  }
 
}

以上就是实现简单的五子棋功能，初步实现一些简单的计算功能，能正常运行小游戏，没花太多时间进行检查，可能会存在一些bug，还请见谅 ，希望对初学者有所帮助。

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。