`
ye_haiqiang
  • 浏览: 88252 次
  • 性别: Icon_minigender_1
  • 来自: 福州
社区版块
存档分类
最新评论

黑白棋(人人对战、简单的人机对战)

 
阅读更多

最近期末测评的题目(实现黑白棋算法)具体实现代码如下:

#include "graphics.h" /*图形系统头文件*/
#define LEFT 0x4b00 /*光标左键值*/
#define RIGHT 0x4d00 /*光标右键值*/
#define DOWN 0x5000 /*光标下键值*/
#define UP 0x4800 /*光标上键值*/
#define ESC 0x011b /* ESC键值*/
#define ENTER 0x1c0d /* 回车键值*/
/*============================*/
/*      全局变量声明          */
/*============================*/
int a[8][8]={0},key,score1,score2;/*具体分数以及按键与存放棋子的变量*/
char playone[3],playtwo[3];/*两个人的得分转换成字符串输出*/
int startx=120,starty=80;
/*============================*/
/*      函数声明              */
/*============================*/
void DrawQp(void);/*画棋盘函数*/
void playtoplay();/*人人对战*/
void resetColor(int x,int y);/*清楚移动后的痕迹*/
void setQzColor(int t);/*设置棋子颜色*/
void playtocomputer();/*人机对战*/
void menu();/*菜单*/
void countScore();/*处理分数*/
void printScore(int playnum);/*输出成绩*/
void playWin();/*输出最后的胜利者结果*/
/*============================*/
/*              主函数        */
/*============================*/
void main(void)
{
    int gd=DETECT,gr;
    initgraph(&gd,&gr,"c:\\tc"); /*初始化图形系统*/
    menu();
    getch();
    closegraph();/*关闭图形系统*/
}
/*=============================================*/
/*               初始化棋盘                    */
/*
    系统函数说明
    画线函数:line()
    设置背景颜色:setbkcolor()
    填充模式:setfillstyle()
    椭圆显示位置以及大小:fillellipse()         */
/*                                              */
/*  15:白色     8:黑色                          */
/*==============================================*/
void DrawQp()
{
   int i,j;
   /*棋手一开始得分都为0*/
   setfillstyle(SOLID_FILL,BLUE);
   bar(120,80,420,420);
   score1=0;
   score2=0;
   setbkcolor(BLUE);
   setcolor(15);
   for(i=100;i<=420;i+=40)
   {
      line(100,i,420,i);/*画水平线*/
      line(i,100,i,420); /*画垂直线*/
   }
   setcolor(0);/*取消圆周围的白圈*/
   setfillstyle(SOLID_FILL,15);/*白色实体填充模式,SOLID_FILL为填满*/
   fillellipse(500,200,15,15); /*在显示得分的位置画棋*/

   setfillstyle(SOLID_FILL,8); /*黑色实体填充模式*/
   fillellipse(500,300,15,15);

   /*棋盘初始化位置*/
   a[3][3]=a[4][4]=1;/*初始两个黑棋*/
   a[3][4]=a[4][3]=2;/*初始两个白棋*/

   setfillstyle(SOLID_FILL,15);
   fillellipse(120+3*40,120+3*40,15,15);
   fillellipse(120+4*40,120+4*40,15,15);
   setfillstyle(SOLID_FILL,8);
   fillellipse(120+3*40,120+4*40,15,15);
   fillellipse(120+4*40,120+3*40,15,15);
   score1=score2=2;
   /*有棋后改变分数*/
   countScore();

}
/*==============================================*/
/*
    函数说明:人人对战
                                                */
/*==============================================*/
void playtoplay()
{
   int x,y,t=1,i,j,cc=0;
   while(1)
   {
        x=120,y=80;/*棋子初始坐标,x为行坐标,y为列坐标*/
        while(1)
        {
            printScore(1);/*输出棋手1的成绩*/
            printScore(2);/*输出棋手2的成绩*/
            setQzColor(t);
            fillellipse(x,y,15,15);/*棋子位置*/
            key=bioskey(0);/*接收按键*/
            if(key==ESC)
            {
                break;/*跳出循环,结束游戏*/
            }
            else if(key==ENTER)/*放下棋子*/
            {
                if(y!=80&&a[(x-120)/40][(y-120)/40]!=1&&a[(x-120)/40][(y-120)/40]!=2)/*判断棋盘上有否有棋子*/
                {
                    if(t%2==1)
                    {
                        a[(x-120)/40][(y-120)/40]=1;
                        if(!changeQzColor(x,y,t))/*落子后判断棋盘的变化*/
                        {
                            a[(x-120)/40][(y-120)/40]=0;/*恢复空格状态*/
                            cc++;/*开始统计尝试次数*/
                            if(cc>=64-score1-score2) /*如果尝试超过空格数则停步*/
                            {
                                resetColor(x,y);
                                fillellipse(x,y,15,15);
                                break;
                            }
                            else
                            {
                                continue;/*如果按键无效*/
                            }
                        }

                    }
                    else
                    {
                        a[(x-120)/40][(y-120)/40]=2;
                        if(!changeQzColor(x,y,t))/*落子后判断棋盘的变化*/
                        {
                            a[(x-120)/40][(y-120)/40]=0;/*恢复空格状态*/
                            cc++;/*开始统计尝试次数*/
                            if(cc>=64-score1-score2) /*如果尝试超过空格数则停步*/
                            {
                                resetColor(x,y);
                                fillellipse(x,y,15,15);
                                break;
                            }
                            else
                            {
                                continue;/*如果按键无效*/
                            }
                        }
   
                    }
                    countScore();
                    break;
                }
                else
                {
                    continue;/*存在棋子继续循环*/
                }
            }
            else if(key==LEFT&&x>120)/*左按键*/
            {
                resetColor(x,y);
                fillellipse(x,y,15,15);/*棋子位置*/
                setQzColor(t);
                x=x-40;
                fillellipse(x,y,15,15);
            }
            else if(key==RIGHT&&x<400&&y>80)/*右*/
            {
                resetColor(x,y);
                fillellipse(x,y,15,15);/*棋子位置*/
                setQzColor(t);
                x=x+40;
                fillellipse(x,y,15,15);
            }
            else if(key==UP&&y>120)/*上*/
            {
                resetColor(x,y);
                fillellipse(x,y,15,15);/*棋子位置*/
                setQzColor(t);
                y=y-40;
                fillellipse(x,y,15,15);
            }
            else if(key==DOWN&&y<400)/*下*/
            {
                resetColor(x,y);
                fillellipse(x,y,15,15);/*棋子位置*/
                setQzColor(t);
                y=y+40;
                fillellipse(x,y,15,15);
            }
        }
        if(key==ESC)
        {
            break;
        }
        if((score1+score2)==64||score1==0||score2==0)
        {
            playWin();/*输出最后结果*/
            break;
        }
        t=t%2+1;/*换棋手*/
        cc=0;

   }
}
/*==============================================*/
/*
    函数功能:清楚移动后的痕迹
    参数:x为行坐标,y为列坐标
                                                */
/*==============================================*/
void resetColor(int x,int y)
{
    if(y<100)
    {
        setfillstyle(SOLID_FILL,BLUE);
    }
    else
    {
        if(a[(x-120)/40][(y-120)/40]==1)
        {
            setfillstyle(SOLID_FILL,15);
        }
        else if(a[(x-120)/40][(y-120)/40]==2)
        {
            setfillstyle(SOLID_FILL,8);
        }
        else
        {
            setfillstyle(SOLID_FILL,BLUE);
        }
    }
}
/*==============================================*/
/*
    函数功能:设置棋子颜色
    参数:t 为玩家
                                                */
/*==============================================*/
void setQzColor(int t)
{
    if(t%2==1)
    {
        setfillstyle(SOLID_FILL,15); /*白色*/
    }
    else
    {
        setfillstyle(SOLID_FILL,8);/*黑色*/
    }
}
/*==============================================*/
/*函数功能:8个方位的判断
    参数:x,y:棋子坐标,t: 棋手
*/
/*==============================================*/
int changeQzColor(int x,int y,int t)/*判断棋盘的变化*/
{
   int i,j,k,kk,ii,jj,yes;
   yes=0;
   i=(x-120)/40; /*计算数组元素的行下标*/
   j=(y-120)/40; /*计算数组元素的列下标*/
   setQzColor(t);/*设置棋子变化的颜色*/
   /*开始往8个方向判断变化*/
   if(j<6)/*往右边*/
   {
        for(k=j+1;k<8;k++)
        {
            if(a[i][k]==a[i][j]||a[i][k]==0)/*遇到自己的棋子或空格结束*/
            {
                break;
            }
        }
        if(a[i][k]!=0&&k<8)
        {
            for(kk=j+1;kk<k&&k<8;kk++)/*判断右边*/
            {
                a[i][kk]=a[i][j]; /*改变棋子颜色*/
                fillellipse(120+i*40,120+kk*40,15,15);
            }
            if(kk!=j+1) /*条件成立则有棋子改变过颜色*/
            {
                yes=1;
            }
        }
   }
   if(j>1)/*判断左边*/
   {
      for(k=j-1;k>=0;k--)
      {
        if(a[i][k]==a[i][j]||!a[i][k])
        {
            break;
        }
      }
      if(a[i][k]!=0&&k>=0)
      {
        for(kk=j-1;kk>k&&k>=0;kk--)
        {
            a[i][kk]=a[i][j];
            fillellipse(120+i*40,120+kk*40,15,15);
        }
        if(kk!=j-1)
        {
            yes=1;
        }
      }
   }
   if(i<6)/*判断下边*/
   {
      for(k=i+1;k<8;k++)
      {
        if(a[k][j]==a[i][j]||!a[k][j])
        {
            break;
        }
      }
      if(a[k][j]!=0&&k<8)
      {
        for(kk=i+1;kk<k&&k<8;kk++)
        {
            a[kk][j]=a[i][j];
            fillellipse(120+kk*40,120+j*40,15,15);
        }
        if(kk!=i+1)
        {
            yes=1;
        }
      }
    }
    if(i>1)/*判断上边*/
    {
      for(k=i-1;k>=0;k--)
      {
        if(a[k][j]==a[i][j]||!a[k][j])
        {
            break;
        }
      }
      if(a[k][j]!=0&&k>=0)
      {
        for(kk=i-1;kk>k&&k>=0;kk--)
        {
            a[kk][j]=a[i][j];
            fillellipse(120+kk*40,120+j*40,15,15);
        }
        if(kk!=i-1)
        {
            yes=1;
        }
      }
   }
   if(i>1&&j<6)/*右上*/
   {
      for(k=i-1,kk=j+1;k>=0&&kk<8;k--,kk++)
      {
        if(a[k][kk]==a[i][j]||!a[k][kk])
         {
            break;
         }
      }
      if(a[k][kk]&&k>=0&&kk<8)
      {
        for(ii=i-1,jj=j+1;ii>k&&k>=0;ii--,jj++)
        {
            a[ii][jj]=a[i][j];
            fillellipse(120+ii*40,120+jj*40,15,15);
        }
        if(ii!=i-1)
        {
            yes=1;
        }
      }
   }
   if(i<6&&j>1)/*左下*/
   {
      for(k=i+1,kk=j-1;k<8&&kk>=0;k++,kk--) 
      {
        if(a[k][kk]==a[i][j]||!a[k][kk])
            break;
      }
      if(a[k][kk]!=0&&k<8&&kk>=0)
      {
        for(ii=i+1,jj=j-1;ii<k&&k<8;ii++,jj--)
        {
            a[ii][jj]=a[i][j];
            fillellipse(120+ii*40,120+jj*40,15,15);
        }
        if(ii!=i+1)
        {
            yes=1;
        }
      }
   }
   if(i>1&&j>1)/*左上*/
   {
      for(k=i-1,kk=j-1;k>=0&&kk>=0;k--,kk--)
      {
        if(a[k][kk]==a[i][j]||!a[k][kk])
        {
            break;
        }
      }
      if(a[k][kk]!=0&&k>=0&&kk>=0)
      {
        for(ii=i-1,jj=j-1;ii>k&&k>=0;ii--,jj--)
        {
            a[ii][jj]=a[i][j];
            fillellipse(120+ii*40,120+jj*40,15,15);
        }
        if(ii!=i-1)
        {
            yes=1;
        }
      }
   } 
   if(i<6&&j<6)/* 右下*/
   {
      for(k=i+1,kk=j+1;kk<8&&kk<8;k++,kk++)
      {
        if(a[k][kk]==a[i][j]||!a[k][kk])
        {
            break;
        }
      }
      if(a[k][kk]!=0&&kk<8&&k<8)
      {
        for(ii=i+1,jj=j+1;ii<k&&k<8;ii++,jj++)
        {
            a[ii][jj]=a[i][j];
            fillellipse(120+ii*40,120+jj*40,15,15);
        }
        if(ii!=i+1)
        {
            yes=1;
        }
      }
   }
   return yes;/*返回是否改变过棋子颜色的标记*/
}
void countScore()/*处理分数*/
{
   int i,j;
   score1=score2=0;/*重新开始计分数*/
   for(i=0;i<8;i++)
      for(j=0;j<8;j++)
        if(a[i][j]==1)/*分别统计两个人的分数*/
            score1++;
        else if(a[i][j]==2)
            score2++;
}
void printScore(int playnum)/*输出成绩*/
{
   if(playnum==1)/*清除以前的成绩*/
   {
      setfillstyle(SOLID_FILL,BLUE);
      bar(550,100,640,400);
   }
   setcolor(RED);
   settextstyle(0,0,4);/*设置文本输出样式*/
   if(playnum==1)/*判断输出哪个棋手的分,在不同的位置输出*/
   {
      sprintf(playone,"%d",score1);
      outtextxy(550,200,playone);


   }
   else
   {
      sprintf(playtwo,"%d",score2);
      outtextxy(550,300,playtwo);

   }
   setcolor(0);
}
/*人机交互*/
void playtocomputer()
{
    int x,y,t=1,i,j,cc=0;
    while(1)
    {
        x=120,y=80;/*棋子初始坐标,x为行坐标,y为列坐标*/
        while(1)
        {
            printScore(1);/*输出棋手1的成绩*/
            printScore(2);/*输出棋手2的成绩*/
            setfillstyle(SOLID_FILL,15); /*白色*/
            fillellipse(x,y,15,15);/*棋子位置*/
            key=bioskey(0);/*接收按键*/
            if(key==ESC)
            {
                break;/*跳出循环,结束游戏*/
            }
            else if(key==ENTER)/*放下棋子*/
            {
                if(y!=80&&a[(x-120)/40][(y-120)/40]!=1&&a[(x-120)/40][(y-120)/40]!=2)/*判断棋盘上有否有棋子*/
                {
                    a[(x-120)/40][(y-120)/40]=1;
                    if(!changeQzColor(x,y,t))/*落子后判断棋盘的变化*/
                    {
                        a[(x-120)/40][(y-120)/40]=0;/*恢复空格状态*/
                        cc++;/*开始统计尝试次数*/
                        if(cc>=64-score1-score2) /*如果尝试超过空格数则停步*/
                        {
                            resetColor(x,y);
                            fillellipse(x,y,15,15);
                            break;
                        }
                        else
                        {
                            continue;/*如果按键无效*/
                        }
                    }
                     for(i=0;i<8;i++)
                     {
                        for(j=0;j<8;j++)
                        {
                            if(a[i][j]!=1&&a[i][j]!=2)
                            {
                                a[i][j]=2;
                                if(changeQzColor(120+i*40,120+j*40,2))
                                {

                                    resetColor(120+i*40,120+j*40);
                                    fillellipse(120+i*40,120+j*40,15,15);
                                    break;
                                }
                                else
                                {   a[i][j]=0;
                                    resetColor(120+i*40,120+j*40);
                                    fillellipse(120+i*40,120+j*40,15,15);
                                    continue;
                                }
                            }
                            else
                            {
                                continue;
                            }
                        }
                        if(j!=8)
                        {
                          break;
                        }
                     }
                     countScore();
                    break;

                }
                else
                {
                    continue;/*存在棋子继续循环*/
                }
            }
            else if(key==LEFT&&x>120)/*左按键*/
            {
                resetColor(x,y);
                fillellipse(x,y,15,15);/*棋子位置*/
                setQzColor(t);
                x=x-40;
                fillellipse(x,y,15,15);
            }
            else if(key==RIGHT&&x<400&&y>80)/*右*/
            {
                resetColor(x,y);
                fillellipse(x,y,15,15);/*棋子位置*/
                setQzColor(t);
                x=x+40;
                fillellipse(x,y,15,15);
            }
            else if(key==UP&&y>120)/*上*/
            {
                resetColor(x,y);
                fillellipse(x,y,15,15);/*棋子位置*/
                setQzColor(t);
                y=y-40;
                fillellipse(x,y,15,15);
            }
            else if(key==DOWN&&y<400)/*下*/
            {
                resetColor(x,y);
                fillellipse(x,y,15,15);/*棋子位置*/
                setQzColor(t);
                y=y+40;
                fillellipse(x,y,15,15);
            }
        }

        if(key==ESC)
        {
            break;
        }
        if((score1+score2)==64||score1==0||score2==0)
        {
            playWin();/*输出最后结果*/
            break;
        }
   }
}
void playWin()/*输出最后的胜利者结果*/
{
    settextstyle(0,0,4);
   setcolor(12);
   if(score2>score1)/*开始判断最后的结果*/
      outtextxy(100,200,"black win!");
   else if(score2<score1)
   {
      outtextxy(100,200,"white win!");
   }
   else
   {
     outtextxy(60,200,"you all win!");
   }

}
void menu()
{
    int x1=201,x2=349,y1=161,y2=199;
    int key1;
    int flag=1;
    while(1)
    {
        setbkcolor(BLUE);

        settextstyle(0,0,2);/*设置文本输出样式*/
        setcolor(15);
        outtextxy(50,50,"Welcome to play Black white Games");
        setcolor(0);
        setfillstyle(SOLID_FILL,15);
        bar(200,160,350,200);
        bar(200,210,350,250);
        bar(200,260,350,300);
        setcolor(RED);
        settextstyle(0,0,1);/*设置文本输出样式*/
        outtextxy(250,180,"PlayOne");
        outtextxy(250,220,"PlayTwo");
        outtextxy(250,280,"EXIT");


        setfillstyle(SOLID_FILL,BLUE);
        bar(x1,y1,x2,y2);
        settextstyle(0,0,1);/*设置文本输出样式*/
        outtextxy(250,180,"PlayOne");
        outtextxy(250,220,"PlayTwo");
        outtextxy(250,280,"EXIT");
        key1=bioskey(0);/*接收按键*/

        if(key1==DOWN)
        {
            if(y1==261 || y2==299)
            {
                y1=161;
                y2=199;
            }
            else
            {
                y1+=50;
                y2+=50;
            }

        }
        else if(key1==UP)
        {
            if(y1==161 || y2==199)
            {
                y1=261;
                y2=299;
            }
            else
            {
                y1-=50;
                y2-=50;
            }

        }
        else if(key1==ESC)
        {

            break;
        }
        if(key1==ENTER)
        {


            if(y1==161 && y2==199)
            {
                DrawQp();
                playtocomputer();break;
            }
            else if(y1==211 && y2==249)
            {
                DrawQp();
                playtoplay();break;
            }
            else
            {
               break;
            }
            break;
        }

    }
    setcolor(0);
}

 

 

请大家多多指教~

分享到:
评论

相关推荐

    C语言黑白棋人人对战+人机对战

    原创,直接在终端运行,首先make othello,然后./othello运行,输入每行每列想要下的位置回车即可。编写时的注释为法语,可以忽略,直接看代码。人机使用了Alpha-Beta算法。直接使用里面的语句时请注明出处。

    黑白棋人人对战实现(人机,网络暂不可用,自行编写)

    总的来说,这个项目提供了一个基础的黑白棋对战平台,开发者可以通过扩展其功能,增加人机对战和网络对战,来提高应用的完整性和趣味性。对于学习QT和游戏开发的初学者,这是一个很好的实践项目,能够锻炼他们的编程...

    C语言黑白棋人机对战(源程序可用)

    C语言黑白棋人机对战源程序详解 本资源提供了一个使用C语言编写的黑白棋人机对战程序,包括源代码、使用方法和游戏截图。程序使用Turbo C编译器编译,实现了人机对战的功能。 游戏规则 黑白棋是一种传统的棋盘...

    QT五子棋人机对战人人对战

    人人对战模式则主要依赖于网络编程技术,让两个玩家可以在同一网络环境下进行实时对战。这可能涉及到TCP/IP协议的使用,以及数据的序列化和反序列化,确保棋步在网络传输过程中的准确无误。如果游戏支持跨平台对战,...

    一个黑白棋游戏源码+项目说明(支持双人对战,人机对战,人机AI使用MCTS(蒙特卡洛树搜索)实现).zip

    【资源说明】 1、该资源包括项目的全部源码,下载可以直接使用! 2、本项目适合作为计算机、数学、电子信息等...一个黑白棋游戏源码+项目说明(支持双人对战,人机对战,人机AI使用MCTS(蒙特卡洛树搜索)实现).zip

    黑白棋人机对战

    这是一个人机对战的黑白棋程序。

    java黑白棋(人人对战)

    Java黑白棋游戏是一款基于Java编程语言开发的双人对战游戏。它允许两位玩家通过轮流翻转对方的棋子来争夺棋盘上的控制权。在这个游戏中,每一步操作都至关重要,因为策略性的布局和巧妙的反转是取胜的关键。下面我们...

    基于 Java 实现的黑白棋游戏,支持双人对战,人机对战,人机AI使用MCTS(蒙特卡洛树搜索)实现

    【作品名称】:基于 Java 实现的黑白棋游戏,支持双人对战,人机对战,人机AI使用MCTS(蒙特卡洛树搜索)实现 【适用人群】:适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、...

    五子棋小游戏 人人对战 跟人机对战

    一个很好的 很不错的五子棋小游戏C++代码 帮你们过课程设计没问题

    黑白棋人机对战C/C++

    在这个"黑白棋人机对战C/C++"项目中,开发者利用C语言实现了一个可以在控制台内运行的人机对战系统。下面我们将深入探讨这个项目的相关知识点。 首先,我们要了解C语言。C语言是一种强大的、低级别的编程语言,它被...

    四子棋【人人/人机对战】

    在这个项目中,我们看到的是一个用C++实现的四子棋程序,它包括了“人人对战”和“人机对战”两种模式。下面将详细探讨这些知识点。 首先,我们要理解数据结构在四子棋中的应用。在四子棋游戏中,棋盘通常被表示为...

    基于蒙特卡洛树搜索MCTS的黑白棋游戏Java源码+使用说明(支持双人对战、人机对战).zip

    基于蒙特卡洛树搜索MCTS的黑白棋游戏Java源码+使用说明(支持双人对战、人机对战).zip基于蒙特卡洛树搜索MCTS的黑白棋游戏Java源码+使用说明(支持双人对战、人机对战).zip基于蒙特卡洛树搜索MCTS的黑白棋游戏Java源码...

    一个黑白棋游戏,支持双人对战,人机对战,人机AI使用MCTS(蒙特卡洛树搜索)实现。_Othello-game.zip

    一个黑白棋游戏,支持双人对战,人机对战,人机AI使用MCTS(蒙特卡洛树搜索)实现。_Othello-game

    局域网黑白棋对弈C++实现报告

    《局域网黑白棋对弈C++实现报告》是一份详细介绍如何使用C++编程语言实现局域网内的黑白棋对战游戏的项目报告。这份报告不仅涵盖了游戏的基本规则和操作流程,还深入探讨了网络通信和多线程编程在游戏中的应用。下面...

    黑白棋人机类

    QT编程黑白棋人机对战,资源不全,小心下载

    黑白棋C++实现

    滕讯小游戏黑白棋,用C++语言实现,可实现简单的双人对战与人机对战。

    五子棋人机对战C++程序

    《五子棋人机对战C++程序》是一款在经典棋类游戏五子棋的基础上,融入人工智能元素的软件。此程序允许玩家与计算机进行对弈,为用户提供了一种娱乐和学习编程逻辑的方式。该程序是在古老的C++语言环境下,利用Visual...

    Android 五子棋人机对战

    五子棋是一种古老而简单的策略游戏,通过在棋盘上交替放置黑白棋子,目标是先连成五个同色棋子的一方获胜。 首先,我们要了解Android应用程序的基础架构。Android应用通常由多个组件构成,如Activity、Service、...

    人机大战黑白棋游戏源码

    【人机大战黑白棋游戏源码】是一种编程实践,它涉及到计算机编程、人工智能以及游戏设计等多个领域的知识。在这个项目中,我们将深入探讨以下几个关键知识点: 1. **游戏规则与算法**:黑白棋(也称为翻转棋或...

Global site tag (gtag.js) - Google Analytics