简单的五子棋小游戏（Qt实现）

最新推荐文章于 2024-07-24 03:29:35 发布
最新推荐文章于 2024-07-24 03:29:35 发布
阅读量4.3k 收藏 57
点赞数 11
分类专栏： Qt 文章标签： Qt
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Fallinlove520/article/details/100402643
版权

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，还请见谅 ，希望对初学者有所帮助。    加油 ！

 

 

Tjmies
关注
专栏目录
QT实现五子棋小游戏
09-26
QT实现五子棋小游戏，初学QT时的练手作品之一，纯自己设计，代码简单直观。可以学习一些基本QT相关的技术。
Qt实现简单版炫舞小游戏
10-24
一个用Qt实现的简单版炫舞小游戏，基本实现了炫舞的功能。
[源码和文档分享]基于QT实现的扫雷小游戏
qq_38474647的博客
06-14 636
一、需求和规格说明 本题目做一个N x M 的扫雷游戏，每个方格包含两种状态：关闭（closed）和打开（opened），初始化时每个方格都是关闭的，一个打开的方格也会包含两种状态：一个数字（clue）和一个雷（bomb）。你可以打开（open）一个方格，如果你打开的是一个bomb，那么就失败；否则就会打开一个数字，该数字是位于[0，8]的一个整数，该数字...
Qt进阶版五子棋
最新发布
weixin_36723647的博客
07-24 27
五子棋是一种两人对弈的棋类游戏，目标是在横、竖、斜任意方向上连成五个子。在Qt中实现五子棋程序，你需要设计棋盘界面、处理下棋逻辑、判断胜负等。以下是实现一个基本五子棋程序的步骤：创建项目和界面 使用Qt Creator创建一个新的Qt Widgets Application项目。设计棋盘界面，可以使用QGridLayout...
Qt5.6.1下写的一个简单的打飞机小游戏，哈哈 。或者说是简单版的鼠标准度练习器，无聊的时候可以小小的娱乐一下，初学者也可以体验一下，希望可以勾起你们学习Qt的兴趣。不洗勿喷，相互学习嘛。
孙诚昊的博客
05-07 2655
主要用到的是Qt绘图，QTimer，styleSheet，QLabel的简单设置，和简单的QSound音效，以及鼠标事件的处理。适合初学Qt者娱乐学习。需要注意的问题：使用QSound类是要在pro文件中加上，不然的话在#include&lt;QSound&gt;的时候会出现找不到头文件的现象。设置QLabel适应图片大小的方法：以下贴出几张运行时的截图：附源码和打包好的可执行程序。https:/...
QT实现的五子棋
01-26
使用QT5编写的五子棋，可以选择游戏模式（人机或者人人）以及棋子颜色，AI是参考别人的
Qt项目(10)Qt实现五子棋小游戏
余生芳华，灵魂共舞
11-07 5609
用11个清晰明了的步骤实现五子棋小游戏，展示效果，提供源码。
QT项目实战: 五子棋小游戏
qq_48597462的博客
06-07 1335
简单的五子棋游戏MainWindow类继承自，用于创建游戏窗口。函数使用QPainter绘制棋盘的网格线。函数根据当前的棋子颜色在鼠标位置绘制一个棋子。函数遍历所有已经放置的棋子并绘制它们。函数在指定的位置绘制一个棋子。函数处理鼠标点击事件，判断点击位置是否已经有棋子，如果没有，则放置一个新棋子并检查是否胜利。函数用于计算在特定方向上连续相同颜色的棋子数量。paintEvent函数是重绘事件，它调用其他函数来绘制整个棋盘和棋子。：定义了棋盘的行数，这里是12行。
Qt实现简单五子棋小游戏
01-19
在这里就简单讲解一下这三个方面的功能实现(主要是通过QT实现)。 下图为游戏主窗口页面： 第一步：窗口绘图的实现（QPaintEvent绘图事件 和 QMouseEvent鼠标事件） ①鼠标事件（这里我的是mouseDoubleClickEvent()...
Qt实战Qt项目(10)Qt实现五子棋小游戏
05-28
总的来说，Qt实现五子棋小游戏涉及到GUI设计、事件处理、游戏逻辑等多个方面，既锻炼了C++编程能力，也加深了对Qt框架的理解。通过这个项目，开发者可以更好地掌握Qt的使用技巧，为后续的复杂应用开发打下坚实的基础...
基于QT的五子棋系统
04-20
基于QT的五子棋系统，包括人人对战，人机对战和局域网联机对战三种模式。还包括悔棋，提示，计时，截图，即时聊天，背景音乐，背景图片。页面简洁美观。个人作业，可能写得不太清晰，请多多包涵~
基于Qt的简单算术测试小游戏
06-20
基于qt的下的简单算术测试游戏，帮助练习主窗口布局与随机数的使用，比较简单 欢迎大家下载参考
基于QT和OpenCV的五子棋实现源码
05-20
一个简单的五子棋应用，基于QT和OpenCV的实现源码，通过相邻棋子判断是否获胜，不包含人工智能算法，适合新手入门
简易五子棋qt实现
11-03
简易的五子棋qt creator 实现,可在此基础之上实现五子棋算法。
Qt实现五子棋游戏（含功能按钮）
04-30
程序设计实践，开发五子棋小游戏程序，其中包含功能按钮，可以满足基础需求，界面上有一定优化
C++ Qt 实现 经典五子棋小游戏
12-28
在本文中，我们将深入探讨如何使用C++与Qt框架实现一个经典的五子棋小游戏。五子棋是一款简单而富有策略性的两人对弈游戏，对于学习C++编程和Qt界面设计的初学者来说，是一个很好的实践项目。让我们逐一解析实现这个...
qt实现五子棋小游戏.rar
02-25
在本项目中，"qt实现五子棋小游戏.rar" 是一个使用Qt框架开发的五子棋游戏。Qt是一个跨平台的C++图形用户界面应用程序开发框架，它为开发者提供了丰富的API，可以方便地创建出美观且功能强大的桌面应用。五子棋游戏...
Qt中绘制五子棋棋盘
weixin_30735391的博客
07-08 524
一个需要做大作业的同学问我相关内容，就顺手写了一个，贴出来。 项目包含头文件 mainwindowh,源文件mainwindow.cpp和主函数main.cpp。 如下： mainwindow.h #ifndef MAINWINDOW_H #define MAINWINDOW_H #include <QWidget> #include <QPainter...
评论 19
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值