C++语言设计实现五子棋

本文为大家分享了C++五子棋的设计思路和设计实现,供大家参考,具体内容如下

算法思路:

在结束了对C++的学习之后,准备自己编制一些简单的练习程序。目前初步设想是编制一个人机对战的简易五子棋软件。 以下为个人设计思考的过程。

首先,进行问题分析与设计。计划实现的功能为,开局选择人机或双人对战,确定之后比赛开始。比赛结束后初始化棋盘,询问是否继续比赛或退出。后续可加入复盘、悔棋等功能。整个过程中,涉及到了棋子和棋盘两种对象,同时要加上人机对弈时的AI对象,即涉及到三个对象。

棋盘类的设计。

数据存储:五子棋棋盘为15*15的网格结构,即一共有225个节点,每个节点有横竖坐标各一,同时每个节点状态有3种,黑,白,或者为空。可考虑采用二维数组来存储。每个节点三种状态,适合采用枚举(enum)类型。
-* 实现功能*:1. 棋盘对象应负责实时更新棋盘状态并对外显示,因此需要接收棋子对象的输入,同时需要对外输出。而棋盘对象不需要对棋子对象发送信息,所以可以设计棋盘类中更新棋盘状态的函数接收棋子对象作为形参。2. 同时,在每次走棋之后,棋盘对象都要及时更新棋盘信息,即输出棋盘状态。3. 而且,每次走棋之后更新输出之前,应该对棋子走棋是否符合规则以及输赢进行判定。若将规则判定单独封装为一个对象,则不方便调用棋盘信息,故将规则判定设计为棋盘类的成员函数,接收两个形参,一个是棋盘当前的状态,一个是即将走的下一步棋,即一个棋子对象。

设计棋子对象。棋子对象应包含两种信息。一是棋子颜色,二是当前要走的棋子的位置坐标,并保留对外输出的接口。

接下来细化规则判定函数。

  • 首先进行走棋规则判定。接收当前棋子位置信息后,判定该位置是否越界或为空,若非空或者越界,则判定违规,抛掷异常,交付上级调用处理。
  • 然后进行输赢判定。按照一定顺序对当前落子位置的相邻元素进行同色判定并计数。当发现某条直线上同色棋子超过四枚,则判定当前走棋方获胜 。判定过程中同样需要注意是否越界。若均未构成五星连珠,则进入平局判定。
  • 平局判定,遍历棋盘,统计空位,若空位为0,即棋盘已满,判定为平局。

接下来设计下棋AI。设计为一个棋子类型的函数,即接收当前棋盘状态和对方最后一次落棋,返回棋子对象类型。

对弈算法设计。

  • 首先进行先后手判定:若棋盘为空则直接落子(8,8),正中开局。
  • 然后进行防守判定:针对对方上次落棋进行活棋检测,在横、竖、左斜、右斜四条直线上依次进行检测。在任意方向检测到四或活三,即可进行 封堵操作,给出所有可行的封堵位置。若未检测到四或活三,则统计活二并给出所有可能的封堵位置。然后针对所有可能的封堵位置进行评分,选取分数最高的位置进行落子。若上述检测均未找到防守点,则转入进攻算法。
  • 进攻算法:采用枚举,即暴力破解的方法。遍历整个棋盘的所有空位,并给出每个空位的评分,选取最高分进行落子。
  • 活棋检测算法:给定参照棋子,在四个方向上分别检测。以横向检测为例,设参照棋子坐标为(x,y),设定同色计数器count=1(计算同色棋子数目),设定封锁端统计量lock=0,设定已判断的方向统计judge=0。对x-1,判断节点状态,若同色计数器加1,继续判断x-2;若异色,则lock+1,judge+1,若judge=2,终止判断,若judge<2,反向判断x+1;若空白,judge+1,若judge=2,终止判断,若judge<2,反向判断。最后得到被封堵的端口数lock和同色数count。若lock=0,count=3或2,判定为活3或活2。若lock=1,count=4,判定为4,若lock=1,count=3,判定为半3。但是在这种算法中,关于空白的判定存在着一些问题。用0代表空白,用+代表同色,-代表异色,则当出现下列情况时:-0++0-,-+++0-,事实上是死棋,而+0++0,+0+++-,实际上相当于活3或半4。为此,需要对活2和半3的情况进行进一步筛选,即空白端应保证连续两个空白。在活棋检测过程中,如果遇到活3或者半4,则立即终止检测,返回落子的可能位置。若没有则记录活2半3的防守位置,换方向检测。最后返回一个棋子类的数组,包含所有建议的落子位置。若均无,则遍历棋盘,统计所有空白位置,返回。
  • 落子位置评分算法:对活棋检测返回数组中的每个位置进行评分,即以该点为己方参照点,进行活棋检测,若有count=5,直接返回该落子位置。有活三或者半4,分数加20,有活2,分数加5,对角线有相邻同色,分数+2,有异色,分数-2,横竖有同色,分数+1,有异色,分数-1。最后排序,取最高分对应的落子,返回该落子。

接下来则是数据结构和对象设计及主函数调用实现:

类及类的实现

#define RENJU_H
#include <iostream>
#include <windows.h>
#include <string>
#define hor 7
#define ver 4
using namespace std;

//用于记录坐标
struct position
{
 int x;
 int y;
 position()
 {
 x = 0;
 y = 0;
 }
 position(int a,int b)
 {
 x = a;
 y = b;
 }
};

//用于记录棋子颜色和节点状态
enum state
{
 blank=0,black=1,white=2

};

//用于存储棋局分析信息:未完赛,犯规,平局,黑方胜,白方胜
enum result
{
 go_on,error,draw,black_win,white_win
};

// 设置光标
void setpos(COORD a)
{
 HANDLE out = GetStdHandle(STD_OUTPUT_HANDLE);
 SetConsoleCursorPosition(out, a);
}

// 设置光标
void setpos(int i, int j)
{
 COORD pos = { i, j };
 setpos(pos);
}

//绘图函数,用于在指定坐标输出指定字符
inline void gps(int x,int y,char c)
{
 setpos(y,x);
 cout<<c;
}

//绘图函数,用于在指定坐标输出整数
inline void gps(int x,int y,int i)
{
 setpos(y,x);
 if(i>=10)
 cout<<i;
 else
 cout<<0<<i;
}

//绘图函数,用于在指定坐标输出字符串
inline void gps(int x,int y,string s)
{
 setpos(y,x);
 cout<<s;
}

//绘图函数,用于在给定坐标打印棋盘中的一格
void tab(int x,int y,state str)
{
 string s;
 switch (str)
 {
 case blank:
 s=" ";
 break;
 case black:
 s="黑";
 break;
 case white:
 s="白";
 break;
 default:
 break;
 }
 setpos(y,x);
 cout<<" ------ ";
 setpos(y,x+1);
 cout<<"|   |";
 setpos(y,x+2);
 cout<<"| "<<s<<" |";
 setpos(y,x+3);
 cout<<"|   |";
 setpos(y,x+4);
 cout<<" ------ ";
}

//查找最大值
int MAX(const int *a,int n)
{
 int max = a[0];
 for(int i =1; i < n ;i++)
 {
 if(a[i] > max)
  max = a[i];
 }
 return max;
}

//检测是否符合胜利条件

//棋子类
class chess
{
public:
 inline chess(int x=0,int y=0,state c=blank)
 { point.x=x,point.y=y;
 color=c;
 };
 inline chess(chess &ch)
 { point=ch.drop_point();
 color=ch.get_color();
 }
 ~chess(){};
 struct position drop_point()const;//用于向外部提供棋子位置
 inline state get_color() const { return color;}//提供棋子颜色信息
 void set_point();//用于从外部获取棋子位置
 void set_point(int x,int y){ point.x=x,point.y=y;}
 void set_point(position p){ point.x=p.x,point.y=p.y;}
 void set_color(state c){ color=c;}//设置棋子颜色
private:
 position point;
 enum state color;
 };

position chess::drop_point()const
{
 return point;
}

void chess::set_point()
{
 if(color==black)
 {
 setpos(110,1);
 cout<<"请黑方输入落子列数和行数,空格隔开:";
 cin>>point.x>>point.y;
 while(point.x<1||point.x>15)
 {
  setpos(110,1);
  cout<<"列数输入超出范围,请重新输入1~15之间数字   ";
  cin>>point.x;
 }
 while(point.y<1||point.y>15)
 {
  setpos(110,2);
  cout<<"行数输入超出范围,请重新输入1~15之间数字  ";
  cin>>point.y;
 }
 }
 else if(color==white)
 {
 setpos(110,1);
 cout<<"请白方输入落子列数和行数,空格隔开:";
 cin>>point.x>>point.y;
 while(point.x<1||point.x>15)
 {
  setpos(110,1);
  cout<<"列数输入超出范围,请重新输入1~15之间数字   ";
  cin>>point.x;
 }
 while(point.y<1||point.y>15)
 {
  setpos(110,2);
  cout<<"行数输入超出范围,请重新输入1~15之间数字  ";
  cin>>point.y;
 }
 }
 point.x--;
 point.y--;
}

//棋盘类
class chessboard
{
public:
 chessboard()
 {
 for(int i=0;i<15;i++)
  for(int j=0;j<15;j++)
  {
  square[i][j]=blank;
  }
 }
 chessboard(chessboard *cb)
 {
 for(int i=0;i<15;i++)
  for(int j=0;j<15;j++)
  {
  square[i][j]=cb->viewboard(i,j);
  }
 }
 inline state viewboard(position p_c) const;//接收坐标,返回该位置的状态
 inline state viewboard(int x,int y) const;//接收整数坐标,返回该位置的状态
 void update(chess ch);//接收新棋子,更新棋盘状态
 void display()const;//向外输出棋盘状态
 result judge(chess ch)const;//规则函数,判断走棋是否犯规和输赢
 void clear()//清空棋盘
 {
  for(int i=0;i<15;i++)
  for(int j=0;j<15;j++)
  {
  square[i][j]=blank;
  }
 }
private:
 state square[15][15];
};
int check_five(chessboard bd,chess ch)
{
 position ori=ch.drop_point();
 int count=1;//计数器,统计同色个数
 int sum[4]={0};
 bool locked=0;//逻辑标记量,用来标记是否遇到了非同色节点
 //水平方向检测
 for(int i=0,locked=0;i<5&&((ori.x-i)>=0)&&(!locked);i++)//终止循环条件:同色超过4个或触碰到棋盘边界或遇到非同色节点
 if(ch.get_color()==bd.viewboard(ori.x-i,ori.y))
  count++;
 else
  if(i!=0)
  locked=1;
 //sum[0]=count-1;
 for(int i=0,locked=0;i<5&&((ori.x+i)<=14)&&(!locked);i++)//终止循环条件:同色超过4个或触碰到棋盘边界或遇到非同色节点
 if(ch.get_color()==bd.viewboard(ori.x+i,ori.y))
  count++;
 else
  if(i!=0)
  locked=1;
 //sum[1]=count-sum[0]-2;
 sum[0]=count;
 if(count>=5)
 return count;
 //竖直方向检测
 count=1;
 for(int i=0,locked=0;i<5&&((ori.y-i)>=0)&&(!locked);i++)//终止循环条件:同色超过4个或触碰到棋盘边界或遇到非同色节点
 if(ch.get_color()==bd.viewboard(ori.x,ori.y-i))
  count++;
 else
  if(i!=0)
  locked=1;
 //sum[2]=count-1;
 for(int i=0,locked=0;i<5&&((ori.y+i)<=14)&&(!locked);i++)//终止循环条件:同色超过4个或触碰到棋盘边界或遇到非同色节点
 if(ch.get_color()==bd.viewboard(ori.x,ori.y+i))
  count++;
 else
  if(i!=0)
  locked=1;
 //sum[3]=count-sum[2]-2;
 sum[1]=count;
 if(count>=5)
 return count;
 //左上到右下斜向检测
 count=1;
 for(int i=0,locked=0;i<5&&((ori.y-i)>=0)&&((ori.x-i)>=0)&&(!locked);i++)//终止循环条件:同色超过4个或触碰到棋盘边界或遇到非同色节点
 if(ch.get_color()==bd.viewboard(ori.x-i,ori.y-i))
  count++;
 else
  if(i!=0)
  locked=1;
 //sum[4]=count-1;
 for(int i=0,locked=0;i<5&&((ori.x+i)<=14)&&((ori.y+i)<=14)&&(!locked);i++)//终止循环条件:同色超过4个或触碰到棋盘边界或遇到非同色节点
 if(ch.get_color()==bd.viewboard(ori.x+i,ori.y+i))
  count++;
 else
  if(i!=0)
  locked=1;
 //sum[5]=count-sum[4]-2;
 sum[2]=count;
 if(count>=5)
 return count;
 //左下到右上斜向检测
 count=1;
 for(int i=0,locked=0;i<5&&((ori.y+i)<=14)&&((ori.x-i)>=0)&&(!locked);i++)//终止循环条件:同色超过4个或触碰到棋盘边界或遇到非同色节点
 if(ch.get_color()==bd.viewboard(ori.x-i,ori.y+i))
  count++;
 else
  if(i!=0)
  locked=1;
 //sum[6]=count-1;
 for(int i=0,locked=0;i<5&&((ori.x+i)<=14)&&((ori.y-i)>=0)&&(!locked);i++)//终止循环条件:同色超过4个或触碰到棋盘边界或遇到非同色节点
 if(ch.get_color()==bd.viewboard(ori.x+i,ori.y-i))
  count++;
 else
  if(i!=0)
  locked=1;
 //sum[7]=count-sum[6]-2;
 sum[3]=count;
 if(count>=5)
 return count;
 return MAX(sum,4);
}

state chessboard::viewboard(position p_c) const
{
 return square[p_c.x][p_c.y];
}
state chessboard::viewboard(int x,int y) const
{
 return square[x][y];
}
void chessboard::update(chess ch)
{
 position pos=ch.drop_point();
 square[pos.x][pos.y]=ch.get_color();
}

void chessboard::display()const
{
 system("cls");

 for(int i=0;i<15;i++)//打印列坐标说明
 {
 gps(0,6+i*hor,i+1);
 }
 for(int i=0;i<15;i++)//打印列坐标说明
 {
 gps(16*ver,6+i*hor,i+1);
 }
 for(int i=0;i<15;i++)//打印行坐标说明
 {
 gps(3+i*ver,1,i+1);
 }
 for(int i=0;i<15;i++)//打印行坐标说明
 {
 gps(3+i*ver,1+16*hor,i+1);
 }
 for(int i=0,j=0;i<15;i++)
 {
 for(j=0;j<15;j++)
  tab(1+i*ver,3+hor*j,square[j][i]);
 }
 cout<<endl;
}
result chessboard::judge(chess set)const
{
 bool full=1;
 if(viewboard(set.drop_point())!=blank)
 {
 return error;
 }

 if(check_five(*this,set)>=5&&(set.get_color()==black))
 return black_win;

 if(check_five(*this,set)>=5&&(set.get_color()==white))
 return white_win;

 for(int i=0;i<15;i++)
 for(int j=0;j<15;j++)
 {
  if(square[i][j]==blank)
  full=0;
 }
 if(full==1)
 return draw;
 else
 return go_on;
}
#endif

主函数,应该再定义game类进行优化,不过设计的时候没有考虑周全,还是按照C的思想写了。

#include "ai.h"
#include <stdlib.h>

int main()
{
 system("mode con cols=150 lines=150 ");
 system("color 27");
 chessboard bd;
 chess now;
 result final;
 int mode;
 gps(5,40,"==============欢迎使用简易五子棋!==============");
 gps(10,50,">>>>输入1或2进行模式选择<<<<");
 gps(11,50,"   <1> 双人对战 ");
 gps(12,50,"   <2> 人机对战 ");
 do{
 cout<<endl<<"                 input mode:";
 cin>>mode;
 }while(mode != 1 && mode != 2);

 //双人对战
 if (mode==1)
 {
loop1: now.set_color(black);//执黑先行
 bd.clear();
 bd.display(); //初始化棋盘
 setpos(110,0);
 cout<<"对局开始,黑旗先行";
 //循环判断上一次落子结果,收集下一次输入,直到棋局出结果
 do{
 now.set_point();//输入
 final=bd.judge(now);
 //判断是否违规
 while(final==error)//犯规输入则重新输入
 {
  system("cls");
  bd.display();
  setpos(110,10);
  cout<<"犯规(输入坐标已有棋子)!";
  now.set_point();
  final=bd.judge(now);
 }
 //正确落子后更新棋盘
 bd.update(now);
 bd.display();
 //反转下一步走棋的颜色
 if(now.get_color()==black)
  now.set_color(white);
  else
  now.set_color(black);

 }while(final==go_on);
 switch (final)
 {
 case go_on:
  break;
 case error:
  break;
 case draw:
  setpos(110,10);
  cout<<"平局:游戏结束";
  break;
 case black_win:
  setpos(110,10);
  cout<<"黑旗获胜:游戏结束";
  break;
 case white_win:
  setpos(110,10);
  cout<<"白旗获胜:游戏结束";
  break;
 default:
  break;
 }
 setpos(110,11);
 cout<<"是否继续下一局?Y/N";
 char flag;
 cin>>flag;
 if(flag == 'Y')
  goto loop1;
 }
 if(mode == 2)
 {
 chess ai_ch;
 system("cls");
 gps(5,40,"==============欢迎使用简易五子棋!==============");
 gps(10,50,">>>>输入1或2进行模式选择<<<<");
 gps(11,50,"   <1> 执黑先行 ");
 gps(12,50,"   <2> 执白后行 ");
 do{
  cout<<endl<<"                 input mode:";
  cin>>mode;
 }while(mode != 1 && mode != 2);
 if(mode == 1)
 {
loop2: now.set_color(black);//执黑先行
  bd.clear();
  bd.display(); //初始化棋盘
  Ai afago(bd,white);
  setpos(110,0);
  cout<<"对局开始,请您落子";
  now.set_point();
  bd.update(now);
  ai_ch.set_color(white);
  ai_ch.set_point(left(now.drop_point(),false));
  bd.update(ai_ch);
  bd.display();
  //循环判断上一次落子结果,收集下一次输入,直到棋局出结果
  do{
  now.set_point();//输入
  final=bd.judge(now);
  //判断是否违规
  while(final==error)//犯规输入则重新输入
  {
   system("cls");
   bd.display();
   setpos(110,10);
   cout<<"犯规(输入坐标已有棋子)!";
   now.set_point();
   final=bd.judge(now);
  }
  //正确落子后更新棋盘
  bd.update(now);
  if(final != black_win)
  {
   ai_ch=afago.set_chess();
   final=bd.judge(ai_ch);
   bd.update(ai_ch);
   bd.display();
  }else{bd.display();}
  }while(final==go_on);
  switch (final)
  {
  case go_on:
   break;
  case error:
   break;
  case draw:
   setpos(110,10);
   cout<<"平局:游戏结束";
   break;
  case black_win:
   setpos(110,10);
   cout<<"恭喜您棋艺高超,战胜了AI:游戏结束";
   break;
  case white_win:
   setpos(110,10);
   cout<<"电脑获胜,请继续努力提高自己:游戏结束";
   break;
  default:
   break;
  }
  setpos(110,11);
  cout<<"是否继续下一局?Y/N";
  char flag;
  cin>>flag;
  if(flag=='Y')
  goto loop2;
 }
 if(mode == 2)
 {
loop3: ai_ch.set_color(black);//AI执黑先行
  now.set_color(white);
  bd.clear(); //初始化棋盘
  Ai afago(bd,black);
  ai_ch.set_point(7,7);
  bd.update(ai_ch);
  bd.display();
  setpos(110,0);
  cout<<"对局开始,请您落子";
  //循环判断上一次落子结果,收集下一次输入,直到棋局出结果
  do{
  now.set_point();//输入
  final=bd.judge(now);
  //判断是否违规
  while(final==error)//犯规输入则重新输入
  {
   system("cls");
   bd.display();
   setpos(110,10);
   cout<<"犯规(输入坐标已有棋子)!";
   now.set_point();
   final=bd.judge(now);
  }
  //正确落子后更新棋盘
  bd.update(now);
  if(final != white_win)
  {
  ai_ch=afago.set_chess();
  final=bd.judge(ai_ch);
  bd.update(ai_ch);
  bd.display();
  }else{bd.display();}
  }while(final==go_on);
  switch (final)
  {
  case go_on:
   break;
  case error:
   break;
  case draw:
   setpos(110,10);
   cout<<"平局:游戏结束";
   break;
  case white_win:
   setpos(110,10);
   cout<<"恭喜您棋艺高超,战胜了AI:游戏结束";
   break;
  case black_win:
   setpos(110,10);
   cout<<"电脑获胜,请继续努力提高自己:游戏结束";
   break;
  default:
   break;
  }
  setpos(110,11);
  cout<<"是否继续下一局?Y/N";
  char flag;
  cin>>flag;
  if(flag=='Y')
  goto loop3;
 }
 }
 return 0;

}

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

(0)

相关推荐

  • C++实现五子棋小程序

    这是一个用C++写的五子棋的小程序,关于A若是占据了已经下了的位置处理的不好.改动 hight,与width ,与q[][] 可以将棋盘扩大. #include<iostream> #include<vector> using namespace std; class qipan { public: qipan() {} ~qipan() {}; //向上下左右,斜的方向 char left(int x, int y) {//检查是否合适 if (x >= 1 &&a

  • 基于C++实现五子棋AI算法思想

    今天我想要分享一下我做五子棋AI的思路.因为在做这个之前,我没有接触过任何像这种类似的东西.通过这一次,我也算是有所了解,我的思路也是来自很多网络上的博客,看了很多,最终总结出了自己的这样一个. 那我的五子棋是15*15的大小(一般也就是这样的一个大小).我的AI算法要求每一次落子之后都要去计算每一个空暇的位置的"分值",简单的说,我们需要一个存放棋子的数组,表示是否存放了棋子,还要一个计算每一个空格的数组来记录"分数",这个分数是后期AI用来运算的基础,也是你AI

  • C++实现五子棋游戏

    三子棋.五子棋之类的游戏,非常简单,对于初学者来说是一个不错的练手的小项目,以前用C语言写过三子棋游戏.最近在看C++,所以就想到在三子棋的基础上利用C++语言实现五子棋游戏. 主要功能: 有3个模式:0表示退出.1表示电脑vs玩家.2表示玩家vs玩家. 当一局完成之后选择'y'则又会进入选择模式. 源代码(VS2013编译器下写的): #include<iostream> #include<stdio.h> #include<stdlib.h> #include &l

  • 基于c++ ege图形库实现五子棋游戏

    本文分享的五子棋实例,制作基于ege图像库, 首先需要安装配置ege环境 就可以编写小游戏了. 用到的ege库函数不多 , 主要是基于c++的. 先看界面效果: 输入界面:(就是控制台) 游戏胜利界面: 文档如下: 关于五子棋的构思: 实现人人对战的五子棋游戏.使用面向对象的c++ 和 ege库实现. ege的安装过程不在说明 , 在添加编译链接时去掉 -mwindows 选项. dev c++ 的运行环境设置为 TDM-GCC 4.8.1.32-bit Debug 为保险起见,编译时选择菜单栏

  • C++面向对象实现五子棋小游戏

    尽量将面向对象的思想融入进程序中 ChessBoard.h //ChessBoard.h #pragma once #define ROW 15 #define COL 15 #include<iostream> using namespace std; class ChessBoard//棋盘类 { public: char m_cSquare[ROW][COL]; public: ChessBoard(); void show(); }; ChessBoard.cpp //ChessBoa

  • C++程序设计-五子棋

    前言:很多刚刚接触编程的人都不知道怎么下手编写程序,特别是学习了新的知识点,不知道有什么用,那么本文将以简单的存储结构及简单的运算,条件语句,分支语句,循环语句结合,带来一个双人对战版五子棋,这是一个简单的模型,实现了五子棋最最基本的功能,还有好多地方需要补全,如边界问题,设计问题,游戏逻辑问题,希望读者阅读后能够注意,通过自己的努力来完善它,还能扩展各种功能,如悔棋,网络对战等,有时候写程序和小生命一样,慢慢会成长,而我们作为"父母"的看到自己的小宝宝成为有用之才,过程之欣喜特别棒!

  • C++简单五子棋的AI设计实现

    本文实例为大家分享了C++五子棋的AI设计实现代码,供大家参考,具体内容如下 设计思路:通过接口获取信息来确定颜色,通过set_chess函数来确定落点. 对每个点位给出两种颜色棋子的打分,分别存在两个15*15的数组里,数组下标代表点的位置. 确定最大值所在数组之后,遍历该数组找出所有最大值对应的位置,然后对这些位置统计另一种颜色的棋子的分数,再选取一次最大值,从而确定要落点的位置. 打分函数的设计:在四个方向分别统计然后相加.对于某一个方向的分数统计,则分为正反两个方向进行,统计的时候如果有

  • C++语言设计实现五子棋

    本文为大家分享了C++五子棋的设计思路和设计实现,供大家参考,具体内容如下 算法思路: 在结束了对C++的学习之后,准备自己编制一些简单的练习程序.目前初步设想是编制一个人机对战的简易五子棋软件. 以下为个人设计思考的过程. 首先,进行问题分析与设计.计划实现的功能为,开局选择人机或双人对战,确定之后比赛开始.比赛结束后初始化棋盘,询问是否继续比赛或退出.后续可加入复盘.悔棋等功能.整个过程中,涉及到了棋子和棋盘两种对象,同时要加上人机对弈时的AI对象,即涉及到三个对象. 棋盘类的设计. 数据存

  • C语言实现简易五子棋小游戏

    本文实例为大家分享了C语言实现简单五子棋小游戏的具体代码,供大家参考,具体内容如下 效果图如下: 设计思路: 棋盘设计为15×15格,初始状态光标在棋盘的中央,白棋先走,轮流落子,当一方连成五子或下满棋盘时,游戏结束(连成五子的一方获胜,下满棋盘为和棋).当游戏一方胜利后显示胜利信息,提示信息利用汉字点阵输出.程序游戏是一个二维平面图,可用二维数组来实现,数组两个下标可以表示棋盘上的位置,数组元素的值代表棋格上的状态,共有三种情况,分别是0代表空格,1代表白棋,2代表黑棋.程序的主要工作是接收棋

  • C语言设计一个闪闪的圣诞树

    控制台打印一个圣诞树:简简单单的C语言知识,真的很基础,小白也能看得懂哦 /******************************* 圣诞树 byC语言小白入门 *******************************/ #include<stdio.h> #include <stdlib.h> #include <time.h> #include<Windows.h> #define X 25 //画面长度 int background[20]

  • C语言实现简易五子棋

    本文实例为大家分享了C语言实现简易五子棋的具体代码,供大家参考,具体内容如下 #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<stdlib.h> #include<time.h> #define ROW 5 #define COL 5 char g_broad[ROW][COL]; void menu(); void menu() { printf("--------------------

  • C语言实现双人五子棋游戏

    本文实例为大家分享了C语言实现双人五子棋游戏的具体代码,供大家参考,具体内容如下 实现功能 生成棋盘玩家1与玩家2对战,哪个玩家率先有连续5子连线,哪个玩家赢. 如何实现 组成: 二维数组:board[ROW][COL],定义一个ROW*COL的棋盘. 主要逻辑: 显示棋盘,提示用户下子,下子后判断 1.显示棋盘很简单,慢慢凑棋盘就好 2. 用户下子,注意两个条件:棋子在棋盘里,下子位置未被占用. 3.判断是最难的, 方法:从下子位置的8个方向(上,下,左,右,右上,右下,左上,左下)计算相同棋

  • 用C语言实现简单五子棋小游戏

    本文实例为大家分享了C语言实现简单五子棋小游戏的具体代码,供大家参考,具体内容如下 在vs2019创建新项目,然后添加两个源文件test.c和game.c,接着创建一个头文件game.h. test.c: #include "game.h" void game() { char board[ROW][COL]; InitBoard(board, ROW, COL); DisplayBoard(board, ROW, COL); char ret = 0; while (1) { Pla

  • 如何利用最简单的C语言实现AI五子棋

    目录 一.如何实现 二.实现代码及分析 (1)菜单的制作 (2)棋盘的初始化和打印 (3)玩家下子 (4)电脑下子 (5)判断输赢 三.整个代码 (1)test.c文件下代码: (2)game.c下的代码 (3)game.h下的代码 四.具体效果 1.棋盘打印以及选择先后手 2.玩家和电脑下子 3.判断输赢 总结 一.如何实现 1.说明:由于本文只是对初学C语言的人学习,所以将不会涉及任何算法,电脑将采用随机下子的方式.(后期会为大家介绍Alpha-Beta剪枝算法实现人工智能AI) 2.主要部

  • C语言设计前中后队列实例代码

    目录 队列基本概念 1,数组实现  2,链表实现  总结 队列基本概念 队列是最常见的概念,日常生活经常需要排队,仔细观察队列会发现,队列是一种逻辑结构,是一种特殊的线性表.特殊在: 只能在固定的两端操作线性表 只要满足上述条件,那么这种特殊的线性表就会呈现出一种"先进先出"的逻辑,这种逻辑就被称为队列. 由于约定了只能在线性表固定的两端进行操作,于是给队列这种特殊的线性表的插入删除,起个特殊的名称: 队头:可以删除节点的一端 队尾:可以插入节点的一端 入队:将节点插入到队尾之后,函数

  • 基于C语言实现简单五子棋游戏

    本文实例为大家分享了C语言实现简单五子棋游戏的具体代码,供大家参考,具体内容如下 五子棋大家都玩儿过,所以规则就不介绍了 今天遇到一个学弟在实现的时候遇到一些问题,所以将实现的过程记录下 水平有限,仅供参考,互相交流,共同进步. #include<stdio.h> #include<windows.h>   int main() {       int i,j;//表示棋盘横纵坐标     /*********************************************

  • Go语言设计实现在任务栏里提醒你喝水的兔子

    目录 前言 详细设计 安装包 效果展示 前言 之前看到 RunCat 一只可以在电脑上奔跑猫,其主要的功能是监控电脑的CPU.内存的使用情况,使用越多跑的越快.所以准备做一只在任务栏里的兔子,主要使用 Go 语言实现一个简单的到点拜年的兔子. 详细设计 基本需求: 打开应用时可以在任务栏里显示 实现动态兔子生成 实现一只在任务栏里的兔子.基本就是一个应用的图标,并且图标是动态变化的.使用 Go 开发的话可以使用 systray 工具包,能够支持在任务栏里显示图标. go get github.c

随机推荐