五子棋游戏设计（C语言AI智能板）

五子棋游戏程序设计（C语言AI智能版）

近来发现编制五子棋游戏很有趣，尤其是AI智能算法很烧脑。网上介绍有什么贪心算法，剪枝算法，博弈树算法等等，不一而足。

前些天我在站内发布了一款双人对弈版的五子棋游戏程序。接下来在研究人机对战的电脑智能应子算法，参阅很多五子棋书籍棋谱和五子棋竞赛的对抗棋谱。我感到白棋的后手防御算法很难取胜，棋界有黑棋高手先手必胜一说。算法么想了很多，既然是人工智能下棋就得按人的思路来算计。棋书阐述有许多思路和棋局解说。如活四冲四，嵌五，活三嵌四，活二嵌二。这些是高级棋手的总结。我就按此思路用加权计权方法来表现此类各种情况。下面程序中写出了基本算法。代码是function testAIq ( )。另外代码中有一算法测试的方法autotest( ) 可供参考。
此测试黑白双方用同一算法互斗难分胜负，这就像周伯通双手互搏，难分高下。想来要另写白棋防守算法，设置白棋VS黑棋才可看出哪个算法好。我的思路是博弈双方的白棋后手防守点也就是黑棋的加权高分点，白棋加权高分点就是进攻点。我就以计算的高分点为AI下子点。
还有一种说法五子棋博弈要算杀，算杀就是计算必杀之局，如嵌四加活三，冲四加活三，嵌五加活三，嵌五加冲四，这些就是必杀局，就是必胜法宝。算杀的最高境界是做杀，预判算出必杀点提前几子做出必杀局。此谓奕道高手中的高手，乃高高手也。此种算法也就是编程界的高手，是谓大咖也。我望之有些高仰，自感境界还没到。锲而不舍，持之以恒，努力吧。

为了摆谱，就在原已发布的游戏程序上添加了复盘功能。程序没退出就能复现出上一次的盘面。另外还加了记录功能和显示下子序号，每盘棋都打印黑白双方下子记录，界面上也显示记录。有一点就是程序退出记录也就没了。解决的方法是把记录存为文本文件，需要时可作为复盘数据。也可以采用截屏方法保存棋局图片，以便以后复盘研究。

大家都玩过手机的小游戏吧。我是编程爱好者，喜欢动脑筋研究一些算法，编程做出小游戏程序，很有趣很有成就感。在学习VB6编程时就编制过钻石棋和伤脑筋十二块那样的游戏，都是标准Windows图形界面的。现在有空闲时就玩手机上编译手机游戏，也是图形界面的。

程序主要部分介绍：
main ( ) 主程序，初始界面
gamestart ( ) 开始游戏
board ( ) 绘制棋盘，标志下子序号和标记，显示记录
detect ( ) 胜负判断
replay ( ) 复盘设置
undo ( ) 悔棋设置
testAIq ( ) 人机模式加权算法
autotest ( ）算法测试

MySpringC是一种简单的C语言编译器，它能读取手机中各种传感器的数值，控制各种多媒体设备，从而实现让普通用户用C语言控制手机，编写出意想不到的适合自己使用的应用程序。v.2.7是目前的完善版本。下面的游戏代码就是用它在安卓手机上编写的，可制作成安卓手机桌面app应用程序。此样例可复制黏贴到编译器直接使用，亦可用 VB6 ，C++ , java 改写。

以下是源码：
// 最简单的 C 语言编程
// myspringc v2.7 可编译安卓本机 app 应用
// 此样例可复制黏贴到 myspringc 编译
// 此文档可用 VB，VC , java 改写
//**********************************
//**** 五子棋 Gobang AI 版 ******
//**** 人机对战双人对奕 ********
//**********************************
Canvas cs; //画布
string sBarDes[10];
int nBarId[10];
string sMenu[50];
int nMenu[50];
float src[4]; //ClearDraw (cls) clear screen
int size[2]; //load picture size
string s1,s2,s3,s4,s5,s6,s7; //显示
string s,ss,ss1,ss2,ss3,ss4;
int dx,dy; //draw X, Y 坐标
FileInput filebox; //file Input box
string fname; //filename
int i,j,t,a; //t = times
int pn[225]; // pn 0=" " , 1=black , 2=white
int n; // 225 棋子编码号
int px,py; // piece x,y 刚下子标记
int context; //canvasProc 触控
int obj;
int id;
int event;
int dn,dn1 ; //下子计数
int isDo; //游戏操作控制 1=可下子，0=不可下
int B,W,k; //detect win Black White
string cordp,cordp1; //record pn & G9
int cord; //record switch
int mode; //0=人人，1=人机
int wn; //演示测试 AI
int sn;
int dwn[120]; //记录，下子60回合120子为和棋
int col,row ; //行列
int cn,kn; //show record num
int gn ; //game round number
int fudat[200]; //复盘数据
int fusum; //复盘记录总数
int sd; //复盘
int jqn[255]; //计权数
int jqf,jqfn ; //计权分，优选点位码
//**********

main(){
setDisplay(1);
cs.SetBackground(200,200,200);
cs.Active();
sBarDes[0]="开始游戏";
nBarId[0]=100;
sBarDes[1]="选择模式";
nBarId[1]=101;
sBarDes[2]="黑棋下子";
nBarId[2]=102;
sBarDes[3]="白棋下子";
nBarId[3]=103;
sBarDes[4]="退出程序";
nBarId[4]=104;
sBarDes[5]="记录";
nBarId[5]=105;
setToolBarHeight(6);
setButtonTextSize(13);
setToolBarBackgroundColor(255,220,220,220);
setButtonColor(255,0,0,240);
setButtonTextColor(255,255,255,0);
setToolBar(100,myToolBarProc,sBarDes,nBarId,6);
setTitle("五子棋 (智能版) V.1.1.6 ");
//*************************
cs.SetProc (context, mycanvasProc);
mode=0 ;
s7="游戏模式：双人对奕";
wn=0 ; //测试演示
gn=0; //round number
gamestart (); //游戏初始界面
//draw title ****
ss3="五子棋 (智能版)";
cs.SetTextSize (60);
cs.SetTextStyle (1);
cs.SetFillMode (1);//0不填色，1填色
cs.SetColor(255,160,60,40);
cs.DrawText (ss3,124,504);
cs.SetColor(255,0,250,0);
cs.DrawText (ss3,120,500);
cs.SetFillMode (0);//0不填色，1填色
cs.SetColor(255,250,250,0);
cs.DrawText (ss3,120,500);
cs.Update();
while (){}
}//main ()

mycanvasProc (int context,int obj,int id,int event,float x,float y){
if (isDo==0) return ; //结束标志
kn=kn+1; //延时, 减少闪屏
if ((kn-kn/2*2)==0){ kn=0; }else{ return; }
board (); //redraw board
//** get chess pieces position X , Y
if (x>40&&x<610&&y>40&&y<610){
px=(int)(x/40)*40; //棋盘区棋位取整数
py=(int)(y/40)*40;
s=intToString (px);
s1= "px = "+s;
s=intToString (py);
s2= "py = "+s;
dx=px/40; dy=py/40;
s=intToString (dx);
s3= "dx = "+s;
s=intToString (dy);
s4= "dy = "+s;
n=(dy-1)*15+dx; //pn number
s5="选定落子位 >> "+intToString (n);
cs.SetFillMode (0);//0不填色，1填色
cs.SetColor (255,250,0,0); //chess flag选子标记
cs.DrawRect (px-20,py-20,px+20,py+20);
}
//复盘和悔棋按钮，屏幕触控按钮热点区
if (x>40&&x<180&&y>900&&y<960){
replay () ; } //复盘
if (x>210&&x<350&&y>900&&y<960){
undo () ; } //悔棋
if (x>380&&x<520&&y>900&&y<960){
if (mode==0) autotest () ; } //双人模式可算法测试演示
cs.SetFillMode (1);//0不填色，1填色
cs.SetColor (255,230,230,230); //clear n
cs.DrawRect (525,770,600,810);
// cs.SetColor(255,255,0,0);
// cs.SetTextSize (24);
//cs.DrawText (s1,50,700); //测试 dx , dy
//cs.DrawText (s2,50,740);
//cs.DrawText (s3,200,700);
//cs.DrawText (s4,200,740);
cs.SetColor(255,0,0,180);
cs.SetTextSize (30);
cs.DrawText (s5,330,800);
cs.Update ();
}//mycanvasProc

//AI智能下子算法求解方案：
//(一) 四连情况，黑棋下子，黑冲四嵌五，白必应子，若白无活四 022220 冲四 22220 02222 和嵌五 22022 22202 20222 则必应，有则先着取胜

//(二) 三连情况，黑棋下子，黑成活三嵌四，
// 若白无活三 02220 嵌四 2022 2202 则必应，
// 有则先着下子成活四

//(三) 二连情况，黑棋下子，
// 有活二 01100 嵌三 01010 基本都是这样，
// 二连应子：抢先手原则，白棋先找自己的活二嵌三
// 先下子成活三嵌四

//(四) 开局应首子，定标黑子 pn113，白应首子
// 大多棋谱是应 G7 , G9 , H9 , 暂定此
// 白应起首三子：按棋谱法

autotest (){
//用于检测AI智能下子算法 testAIq ()
//黑白棋用同一个算法下子很难区分算法的优劣，
//要设计二种算法分别以黑棋VS白棋才能显示出
//算法的优劣。下面代码只可检测算法的可行性。

if (isDo==0||dn>50) return ; //结束标志，测试50子
if (mode==1) return ; //双人对弈模式可演示
wn=wn+1 ;
if (dn==0) { //设定首子黑先天元位
n=113; black_do () ;
cs.Update () ; }
testAIq () ; //智能计权取得下子点位
if (wn>1) wn=0 ; //轮流下子
if (wn==1) white_do () ; //白棋下子
if (wn==0) black_do () ; //黑棋下子
}//autotest ()

testAIq (){
//人机对战AI选子，加权计算
for (i=1;i<=225;i++) {
jqn[i]=0 ; } //scan init
//遍历加权
for (i=1;i<=15;i++){ //遍历scan B & W 子
for (j=1;j<=15;j++){
k=(i-1)*15+j ; //pn(n) number
//独子左右上下二对角八方
if (pn[k]==2){
if (pn[k-1]==0) jqn[k-1]= jqn[k-1]+10 ;
if (pn[k+1]==0) jqn[k+1]= jqn[k+1]+10 ;
if (pn[k-15]==0) jqn[k-15]= jqn[k-15]+10 ;
if (pn[k+15]==0) jqn[k+15]= jqn[k+15]+10 ;
if (pn[k+14]==0) jqn[k+14]= jqn[k+14]+10 ;
if (pn[k+16]==0) jqn[k+16]= jqn[k+16]+10 ;
if (pn[k-14]==0) jqn[k-14]= jqn[k-14]+10 ;
if (pn[k-16]==0) jqn[k-16]= jqn[k-16]+10 ;
}//pn
//连二
if (pn[k]==2&&pn[k+1]==2){ //左右
if (pn[k-1]==0) jqn[k-1]= jqn[k-1]+50 ;
if (pn[k+2]==0) jqn[k+2]= jqn[k+2]+50 ; }
if (pn[k]==2&&pn[k+15]==2){ //上下
if (pn[k-15]==0) jqn[k-15]= jqn[k-15]+50 ;
if (pn[k+30]==0) jqn[k+30]= jqn[k+30]+50 ; }
if (pn[k]==2&&pn[k+14]==2){ //左对角
if (pn[k-14]==0) jqn[k-14]= jqn[k-14]+50 ;
if (pn[k+28]==0) jqn[k+28]= jqn[k+28]+50 ; }
if (pn[k]==2&&pn[k+16]==2){ //右对角
if (pn[k-16]==0) jqn[k-16]= jqn[k-16]+50 ;
if (pn[k+32]==0) jqn[k+32]= jqn[k+32]+50 ; }

//嵌三嵌四 02020
if (pn[k]==2&&pn[k+1]==0&&pn[k+2]==2){ //左右
jqn[k+1]= jqn[k+1]+80 ;
if (pn[k-1]==0) jqn[k-1]= jqn[k-1]+100 ;
if (pn[k+3]==0) jqn[k+3]= jqn[k+3]+100 ; }

if (pn[k]==2&&pn[k+15]==0&&pn[k+30]==2){ //上下
jqn[k+15]= jqn[k+15]+80 ;
if (pn[k-15]==0) jqn[k-15]= jqn[k-15]+100 ;
if (pn[k+45]==0) jqn[k+45]= jqn[k+45]+100 ; }

if (pn[k]==2&&pn[k+14]==0&&pn[k+28]==2){//左对角
jqn[k+14]= jqn[k+14]+80 ;
if (pn[k-14]==0) jqn[k-14]= jqn[k-14]+100 ;
if (pn[k+42]==0) jqn[k+42]= jqn[k+42]+100 ; }

if (pn[k]==2&&pn[k+16]==0&&pn[k+32]==2){//右对角
jqn[k+16]= jqn[k+16]+80 ;
if (pn[k-16]==0) jqn[k-16]= jqn[k-16]+100 ;
if (pn[k+48]==0) jqn[k+48]= jqn[k+48]+100 ; }

//三连，眠三12220 02221
if (pn[k]==2&&pn[k+1]==2&&pn[k+2]==2){ //左右
if (pn[k-1]==0) jqn[k-1]= jqn[k-1]+200 ;
if (pn[k+3]==0) jqn[k+3]= jqn[k+3]+200 ; }
if (pn[k]==2&&pn[k+15]==2&&pn[k+30]==2){ //上下
if (pn[k-15]==0) jqn[k-15]= jqn[k-15]+200 ;
if (pn[k+45]==0) jqn[k+45]= jqn[k+45]+200 ; }
if (pn[k]==2&&pn[k-14]==2&&pn[k-28]==2){//左对角
if (pn[k+14]==0) jqn[k+14]= jqn[k+14]+200 ;
if (pn[k-42]==0) jqn[k-42]= jqn[k-42]+200 ; }
if (pn[k]==2&&pn[k+16]==2&&pn[k+32]==2){//右对角
if (pn[k-16]==0) jqn[k-16]= jqn[k-16]+200 ;
if (pn[k+48]==0) jqn[k+48]= jqn[k+48]+200 ; }
//三连，活三 02220
if ( pn[k-1]==0&&pn[k]==2&&pn[k+1]==2&&pn[k+2]==2&&pn[k+3]==0){ //左右
if (pn[k-1]==0) jqn[k-1]= jqn[k-1]+280 ;
if (pn[k+3]==0) jqn[k+3]= jqn[k+3]+280 ; }

if (pn[k-15]==0&&pn[k]==2&&pn[k+15]==2&&pn[k+30]==2&&pn[k+45]==0){ //上下
if (pn[k-15]==0) jqn[k-15]= jqn[k-15]+280 ;
if (pn[k+45]==0) jqn[k+45]= jqn[k+45]+280 ; }

if (pn[k-14]==0&&pn[k]==2&&pn[k+14]==2&&pn[k+28]==2&&pn[k+42]==0){//左对角
if (pn[k-14]==0) jqn[k-14]= jqn[k-14]+280 ;
if (pn[k+42]==0) jqn[k+42]= jqn[k+42]+280 ; }

if (pn[k-16]==0&&pn[k]==2&&pn[k+16]==2&&pn[k+32]==2&&pn[k+48]==0){//右对角
if (pn[k-16]==0) jqn[k-16]= jqn[k-16]+280 ;
if (pn[k+48]==0) jqn[k+48]= jqn[k+48]+280 ; }
//*********
//白子算杀，做杀，找活三嵌四交点 +800

//嵌四 020220 022020 +500
// if (col<13) { //边上不下子
if(pn[k-1]==0&&pn[k]==2&&pn[k+1]==0&&pn[k+2]==2&&pn[k+3]==2&&pn[k+4]==0){ //左右
jqn[k+1]= jqn[k+1]+500 ; }
if ( pn[k-1]==0&&pn[k]==2&&pn[k+1]==2&&pn[k+2]==0&&pn[k+3]==2&&pn[k+4]==0){ //左右
jqn[k+2]= jqn[k+2]+500 ; }

if ( pn[k-15]==0&&pn[k]==2&&pn[k+15]==0&&pn[k+30]==2&&pn[k+45]==2&&pn[k+60]==0){ //上下
jqn[k+15]= jqn[k+15]+500 ; }
if ( pn[k-15]==0&&pn[k]==2&&pn[k+15]==2&&pn[k+30]==0&&pn[k+45]==2&&pn[k+60]==0){ //上下
jqn[k+30]= jqn[k+30]+500 ; }

if ( pn[k-14]==0&&pn[k]==2&&pn[k+14]==0&&pn[k+28]==2&&pn[k+42]==2&&pn[k+56]==0){ //斜左
jqn[k+14]= jqn[k+14]+500 ; }
if ( pn[k-14]==0&&pn[k]==2&&pn[k+14]==2&&pn[k+28]==0&&pn[k+42]==2&&pn[k+56]==0){ //斜左
jqn[k+28]= jqn[k+28]+500 ; }

if ( pn[k-16]==0&&pn[k]==2&&pn[k+16]==0&&pn[k+32]==2&&pn[k+48]==2&&pn[k+64]==0){ //右斜
jqn[k+16]= jqn[k+16]+500 ; }
if ( pn[k-16]==0&&pn[k]==2&&pn[k+16]==2&&pn[k+32]==0&&pn[k+48]==2&&pn[k+64]==0){ //右斜
jqn[k+32]= jqn[k+32]+500 ; }
// } //col 列

//活四冲四 022220 122220 022221 +1200
if ( pn[k]==2&&pn[k+1]==2&&pn[k+2]==2&&pn[k+3]==2){ //左右
if (pn[k-1]==0) jqn[k-1]= jqn[k-1]+1500 ;
if (pn[k+4]==0) jqn[k+4]= jqn[k+4]+1500 ; }

if (pn[k]==2&&pn[k+15]==2&&pn[k+30]==2&&pn[k+45]==2){ //上下
if (pn[k-15]==0) jqn[k-15]= jqn[k-15]+1500 ;
if (pn[k+60]==0) jqn[k+60]= jqn[k+60]+1500 ; }
if(pn[k]==2&&pn[k-14]==2&&pn[k-28]==2&&pn[k-42]==2){//左对角
if (pn[k+14]==0) jqn[k+14]= jqn[k+14]+1500 ;
if (pn[k-56]==0) jqn[k-56]= jqn[k-56]+1500 ; }

if (pn[k]==2&&pn[k+16]==2&&pn[k+32]==2&&pn[k+48]==2){//右对角
if (pn[k-16]==0) jqn[k-16]= jqn[k-16]+1500 ;
if (pn[k+64]==0) jqn[k+64]= jqn[k+64]+1500 ; }

//嵌五 20222 22022 22202 +1200
if ( pn[k]==2&&pn[k+1]==0&&pn[k+2]==2&&pn[k+3]==2&&pn[k+4]==2){ //左右 20222
jqn[k+1]= jqn[k+1]+1200 ; }
if ( pn[k]==2&&pn[k+1]==2&&pn[k+2]==0&&pn[k+3]==2&&pn[k+4]==2){ //左右 22022
jqn[k+2]= jqn[k+2]+1200 ; }
if ( pn[k]==2&&pn[k+1]==2&&pn[k+2]==2&&pn[k+3]==0&&pn[k+4]==2){ //左右 22022
jqn[k+3]= jqn[k+3]+1200 ; }

if ( pn[k]==2&&pn[k+15]==0&&pn[k+30]==2&&pn[k+45]==2&&pn[k+60]==2){ //上下 20222
jqn[k+15]= jqn[k+15]+1200 ; }
if ( pn[k]==2&&pn[k+15]==2&&pn[k+30]==0&&pn[k+45]==2&&pn[k+60]==2){ //上下 22022
jqn[k+30]= jqn[k+30]+1200 ; }
if ( pn[k]==2&&pn[k+15]==2&&pn[k+30]==2&&pn[k+45]==0&&pn[k+60]==2){ //上下 22202
jqn[k+45]= jqn[k+45]+1200 ; }

if ( pn[k]==2&&pn[k+14]==0&&pn[k+28]==2&&pn[k+42]==2&&pn[k+56]==2){ //斜左 20222
jqn[k+14]= jqn[k+14]+1200 ; }
if ( pn[k]==2&&pn[k+14]==2&&pn[k+28]==0&&pn[k+42]==2&&pn[k+56]==2){ //斜左 22022
jqn[k+28]= jqn[k+28]+1200 ; }
if ( pn[k]==2&&pn[k+14]==2&&pn[k+28]==2&&pn[k+42]==0&&pn[k+56]==2){ //斜左 22202
jqn[k+42]= jqn[k+42]+1200 ; }

if ( pn[k]==2&&pn[k+16]==0&&pn[k+32]==2&&pn[k+48]==2&&pn[k+64]==2){ //右斜 20222
jqn[k+16]= jqn[k+16]+1200 ; }
if ( pn[k]==2&&pn[k+16]==2&&pn[k+32]==0&&pn[k+48]==2&&pn[k+64]==2){ //右斜 22022
jqn[k+32]= jqn[k+32]+1200 ; }
if ( pn[k]==2&&pn[k+16]==2&&pn[k+32]==2&&pn[k+48]==0&&pn[k+64]==2){ //右斜 22202
jqn[k+48]= jqn[k+48]+1200 ; }

//****************************
//以下是黑棋估权计分
//独子左右上下二对角八方
if (pn[k]==1){
if (pn[k-1]==0) jqn[k-1]= jqn[k-1]+10 ;
if (pn[k+1]==0) jqn[k+1]= jqn[k+1]+10 ;
if (pn[k-15]==0) jqn[k-15]= jqn[k-15]+10 ;
if (pn[k+15]==0) jqn[k+15]= jqn[k+15]+10 ;
if (pn[k+14]==0) jqn[k+14]= jqn[k+14]+10 ;
if (pn[k+16]==0) jqn[k+16]= jqn[k+16]+10 ;
if (pn[k-14]==0) jqn[k-14]= jqn[k-14]+10 ;
if (pn[k-16]==0) jqn[k-16]= jqn[k-16]+10 ;
}//pn
//连二
if (pn[k]==1&&pn[k+1]==1){ //左右
if (pn[k-1]==0) jqn[k-1]= jqn[k-1]+50 ;
if (pn[k+2]==0) jqn[k+2]= jqn[k+2]+50 ; }
if (pn[k]==1&&pn[k+15]==1){ //上下
if (pn[k-15]==0) jqn[k-15]= jqn[k-15]+50 ;
if (pn[k+30]==0) jqn[k+30]= jqn[k+30]+50 ; }
if (pn[k]==1&&pn[k+14]==1){ //左对角
if (pn[k-14]==0) jqn[k-14]= jqn[k-14]+50 ;
if (pn[k+28]==0) jqn[k+28]= jqn[k+28]+50 ; }
if (pn[k]==1&&pn[k+16]==1){ //右对角
if (pn[k-16]==0) jqn[k-16]= jqn[k-16]+50 ;
if (pn[k+32]==0) jqn[k+32]= jqn[k+32]+50 ; }
//嵌三 02020
if (pn[k]==1&&pn[k+1]==0&&pn[k+2]==1){ //左右
jqn[k+1]= jqn[k+1]+80 ; }
if (pn[k]==1&&pn[k+15]==0&&pn[k+30]==1){ //上下
jqn[k+15]= jqn[k+15]+80 ; }
if (pn[k]==1&&pn[k+14]==0&&pn[k+28]==1){//左对角
jqn[k+14]= jqn[k+14]+80 ; }
if (pn[k]==1&&pn[k+16]==0&&pn[k+32]==1){//右对角
jqn[k+16]= jqn[k+16]+80 ; }

//三连，眠三12220 02221
if (pn[k]==1&&pn[k+1]==1&&pn[k+2]==1){ //左右
if (pn[k-1]==0) jqn[k-1]= jqn[k-1]+200 ;
if (pn[k+3]==0) jqn[k+3]= jqn[k+3]+200 ; }
if (pn[k]==1&&pn[k+15]==1&&pn[k+30]==1){ //上下
if (pn[k-15]==0) jqn[k-15]= jqn[k-15]+200 ;
if (pn[k+45]==0) jqn[k+45]= jqn[k+45]+200 ; }

if (pn[k]==1&&pn[k-14]==1&&pn[k-28]==1){//左对角
if (pn[k+14]==0) jqn[k+14]= jqn[k+14]+200 ;
if (pn[k-42]==0) jqn[k-42]= jqn[k-42]+200 ;
if (pn[k+2]==0) jqn[k+2]= jqn[k+2]+300 ;
if (pn[k-30]==0) jqn[k-30]= jqn[k-30]+300 ;
} //破梅花阵
if (pn[k]==1&&pn[k+16]==1&&pn[k+32]==1){//右对角
if (pn[k-16]==0) jqn[k-16]= jqn[k-16]+200 ;
if (pn[k+48]==0) jqn[k+48]= jqn[k+48]+200 ;
if (pn[k+2]==0) jqn[k+2]= jqn[k+2]+300 ;
if (pn[k+32]==0) jqn[k+32]= jqn[k+32]+300 ;
} //破梅花阵

//三连，活三 02220
if ( pn[k-1]==0&&pn[k]==1&&pn[k+1]==1&&pn[k+2]==1&&pn[k+3]==0){ //左右
if (pn[k-1]==0) jqn[k-1]= jqn[k-1]+280 ;
if (pn[k+3]==0) jqn[k+3]= jqn[k+3]+280 ; }

if (pn[k-15]==0&&pn[k]==1&&pn[k+15]==1&&pn[k+30]==1&&pn[k+45]==0){ //上下
if (pn[k-15]==0) jqn[k-15]= jqn[k-15]+280 ;
if (pn[k+45]==0) jqn[k+45]= jqn[k+45]+280 ; }

if (pn[k-14]==0&&pn[k]==1&&pn[k+14]==1&&pn[k+28]==1&&pn[k+42]==0){//左对角
if (pn[k-14]==0) jqn[k-14]= jqn[k-14]+280 ;
if (pn[k+42]==0) jqn[k+42]= jqn[k+42]+280 ; }

if (pn[k-16]==0&&pn[k]==1&&pn[k+16]==1&&pn[k+32]==1&&pn[k+48]==0){//右对角
if (pn[k-16]==0) jqn[k-16]= jqn[k-16]+280 ;
if (pn[k+48]==0) jqn[k+48]= jqn[k+48]+280 ; }

//活四冲四 122220 022221 +1200
if ( pn[k]==1&&pn[k+1]==1&&pn[k+2]==1&&pn[k+3]==1){ //左右
if (pn[k-1]==0) jqn[k-1]= jqn[k-1]+1200 ;
if (pn[k+4]==0) jqn[k+4]= jqn[k+4]+1200 ; }

if (pn[k]==1&&pn[k+15]==1&&pn[k+30]==1&&pn[k+45]==1){ //上下
if (pn[k-15]==0) jqn[k-15]= jqn[k-15]+1200 ;
if (pn[k+60]==0) jqn[k+60]= jqn[k+60]+1200 ; }
if(pn[k]==1&&pn[k-14]==1&&pn[k-28]==1&&pn[k-42]==1){//左对角
if (pn[k+14]==0) jqn[k+14]= jqn[k+14]+1200 ;
if (pn[k-56]==0) jqn[k-56]= jqn[k-56]+1200 ; }

if (pn[k]==1&&pn[k+16]==1&&pn[k+32]==1&&pn[k+48]==1){//右对角
if (pn[k-16]==0) jqn[k-16]= jqn[k-16]+1200 ;
if (pn[k+64]==0) jqn[k+64]= jqn[k+64]+1200 ; }

//嵌四 010110 011010 +500
if ( pn[k-1]==0&&pn[k]==1&&pn[k+1]==0&&pn[k+2]==1&&pn[k+3]==1&&pn[k+4]==0){ //左右
jqn[k+1]= jqn[k+1]+500 ; }
if ( pn[k-1]==0&&pn[k]==1&&pn[k+1]==1&&pn[k+2]==0&&pn[k+3]==1&&pn[k+4]==0){ //左右
jqn[k+2]= jqn[k+2]+500 ; }

if ( pn[k-15]==0&&pn[k]==1&&pn[k+15]==0&&pn[k+30]==1&&pn[k+45]==1&&pn[k+60]==0){ //上下
jqn[k+15]= jqn[k+15]+500 ; }
if ( pn[k-15]==0&&pn[k]==1&&pn[k+15]==1&&pn[k+30]==0&&pn[k+45]==1&&pn[k+60]==0){ //上下
jqn[k+30]= jqn[k+30]+500 ; }

if ( pn[k-14]==0&&pn[k]==1&&pn[k+14]==0&&pn[k+28]==1&&pn[k+42]==1&&pn[k+56]==0){ //斜左
jqn[k+14]= jqn[k+14]+500 ; }
if ( pn[k-14]==0&&pn[k]==1&&pn[k+14]==1&&pn[k+28]==0&&pn[k+42]==1&&pn[k+56]==0){ //斜左
jqn[k+28]= jqn[k+28]+500 ; }

if ( pn[k-16]==0&&pn[k]==1&&pn[k+16]==0&&pn[k+32]==1&&pn[k+48]==1&&pn[k+64]==0){ //右斜
jqn[k+16]= jqn[k+16]+500 ; }
if ( pn[k-16]==0&&pn[k]==1&&pn[k+16]==1&&pn[k+32]==0&&pn[k+48]==1&&pn[k+64]==0){ //右斜
jqn[k+32]= jqn[k+32]+500 ; }

//嵌五 10111 11011 11101 +1200
if ( pn[k]==1&&pn[k+1]==0&&pn[k+2]==1&&pn[k+3]==1&&pn[k+4]==1){ //左右 10111
jqn[k+1]= jqn[k+1]+1200 ; }
if ( pn[k]==1&&pn[k+1]==1&&pn[k+2]==0&&pn[k+3]==1&&pn[k+4]==1){ //左右 11011
jqn[k+2]= jqn[k+2]+1200 ; }
if ( pn[k]==1&&pn[k+1]==1&&pn[k+2]==1&&pn[k+3]==0&&pn[k+4]==1){ //左右 11101
jqn[k+3]= jqn[k+3]+1200 ; }

if ( pn[k]==1&&pn[k+15]==0&&pn[k+30]==1&&pn[k+45]==1&&pn[k+60]==1){ //上下 10111
jqn[k+15]= jqn[k+15]+1200 ; }
if ( pn[k]==1&&pn[k+15]==1&&pn[k+30]==0&&pn[k+45]==1&&pn[k+60]==1){ //上下 11011
jqn[k+30]= jqn[k+30]+1200 ; }
if ( pn[k]==1&&pn[k+15]==1&&pn[k+30]==1&&pn[k+45]==0&&pn[k+60]==1){ //上下 11101
jqn[k+45]= jqn[k+45]+1200 ; }

if ( pn[k]==1&&pn[k+14]==0&&pn[k+28]==1&&pn[k+42]==1&&pn[k+56]==1){ //斜左 10111
jqn[k+14]= jqn[k+14]+1200 ; }
if ( pn[k]==1&&pn[k+14]==1&&pn[k+28]==0&&pn[k+42]==1&&pn[k+56]==1){ //斜左 11011
jqn[k+28]= jqn[k+28]+1200 ; }
if ( pn[k]==1&&pn[k+14]==1&&pn[k+28]==1&&pn[k+42]==0&&pn[k+56]==1){ //斜左 11101
jqn[k+42]= jqn[k+42]+1200 ; }

if ( pn[k]==1&&pn[k+16]==0&&pn[k+32]==1&&pn[k+48]==1&&pn[k+64]==1){ //右斜 10111
jqn[k+16]= jqn[k+16]+1200 ; }
if ( pn[k]==1&&pn[k+16]==1&&pn[k+32]==0&&pn[k+48]==1&&pn[k+64]==1){ //右斜 11011
jqn[k+32]= jqn[k+32]+1200 ; }
if ( pn[k]==1&&pn[k+16]==1&&pn[k+32]==1&&pn[k+48]==0&&pn[k+64]==1){ //右斜 11101
jqn[k+48]= jqn[k+48]+1200 ; }

} } //test i , j
//******************************
//测试：显示加权计分情况，最高分白下子
if (isDo==0) return ;
cs.SetTextSize (16);
cs.SetTextStyle (0);
cs.SetColor (255,0,150,0) ;
for (i=1;i<=225;i++){ //test scan
if (jqn[i] !=0) {
//print i," qn= ",jqn[i] ; //测试
s=intToString ( jqn[i]) ;
dx=(i-(i/15*15))*40;
dy=(i/15)*40+40;
if (dx==0){ dx=15*40; dy=dy-40; }
cs.DrawText (s,dx,dy) ;
} }

//计算最高分
jqf=0 ;
for (i=1;i<=225;i++){
k= jqn[i] ;
if ( k>jqf) { jqf=k ; jqfn=i ; }
} //计算最高分

sn=jqfn ; //计权最高分点位转坐标
if (dn==1) { //首子黑先 pn 113 , 白应子 pn 97 - 99
if (gn==1) sn=98 ;
if (gn==2) sn=97 ;
if (gn==3) sn=99 ; }
// print " sn= ",jqfn ," jqf= ",jqf ;
dx=(sn-(sn/15*15))*40;
dy=(sn/15)*40+40;
if (dx==0) {dx=15*40; dy=dy-40; }
cs.SetColor (255,250,250,0);
cs.DrawCircle (dx,dy,5); //标记下子点
cs.Update () ;
sleep (500) ;
n=sn ; //下子点号转换
px=dx ; py=dy ; //board ()标记下子点

//**** AI 走子 **********************
}//testAIq ()

swapabc (){
string abc$ ;
abc$="sABCDEFGHIJKLMNO" ;
ss=subString (abc$,col,1) ;
}//swapabc ()

black_do (){ //黑棋下子
pn[n]=1;
s6="白棋选子";
row=15-(n/15) ;
col=(n-(n/15*15)) ;
if (col==0){ col=15 ; row=row+1 ; }
swapabc () ; //return ss
cordp=" B "+intToString (n); //走子记录
cordp1=" B "+ss+intToString (row) ;
if (cordp != ss2) { //不重复记录
dn=dn+1; //print dn;
print dn," ",cordp," " , ss,row ; //打印记录
ss2=cordp;
dwn[dn]=n ; //print play number
fudat[dn]=n; fusum=dn; //复盘数据
s5="选定落子位 >> "+intToString (n);
board ();
}
testAIq (); //test AI 计权 ****

if (mode==1) { //人机模式下子
white_do () ; } // AI Do
}//black_do ()

white_do (){ //白棋下子
pn[n]=2;
s6="黑棋选子";
row=15-(n/15) ;
col=(n-(n/15*15)) ;
if (col==0){ col=15 ; row=row+1 ; }
swapabc () ; //return ss
cordp=" W "+intToString (n); //走子记录
cordp1="W "+ss+intToString (row) ;
if (cordp != ss2) {
dn=dn+1;
print dn," ",cordp," " , ss,row ; //打印记录
ss2=cordp;
dwn[dn]=n ; //print play number
fudat[dn]=n; fusum=dn; //复盘数据
s5="选定落子位 >> "+intToString (n);
board () ;
}
}//white_do ()

board (){
if (isDo==0) return ; //结束标志
// draw board grids 棋盘方格
cs.SetFillMode (1);//0不填色，1填色
cs.SetColor (255,250,250,250); //backcolor
cs.DrawRect (0,0,650,850);
cs.SetColor (255,110,110,110); //pad
cs.DrawRect (10,10,637,638);
cs.SetColor (255,220,150,50); //pad
cs.DrawRect (8,8,632,632);
cs.SetColor (255,250,180,100); //pad
cs.DrawRect (20,20,620,620);
cs.SetFillMode (0);//0不填色，1填色
for (i=1;i<15;i++){ //draw grids
for (j=1;j<15;j++){
cs.SetColor (255,150,150,150); //grid color
cs.DrawRect(i*40-1,j*40-1,i*40+39,j*40+39);
cs.SetColor (255,250,250,250); //grid color
cs.DrawRect(i*40,j*40,i*40+40,j*40+40);
} }
cs.SetColor (255,0,0,0); // rectangle line
cs.DrawRect (21,21,620,620);
cs.DrawRect (20,20,620,620);

//draw flag points
cs.SetFillMode (1);//0不填色，1填色
cs.SetColor (255,140,140,140); //
cs.DrawCircle(160,160,5); //星
cs.DrawCircle(480,160,5);
cs.DrawCircle(160,480,5);
cs.DrawCircle(480,480,5);
cs.DrawCircle(320,320,5); //中元
cs.SetColor (255,240,240,240); //
cs.DrawCircle(161,161,5); //星
cs.DrawCircle(481,161,5);
cs.DrawCircle(161,481,5);
cs.DrawCircle(481,481,5);
cs.DrawCircle(321,321,5); //中元
// 绘出棋盘坐标编码
cs.SetColor (255,180,80,50);
cs.SetTextStyle (1);
cs.SetTextSize (14);
string abc$ ;
abc$="sABCDEFGHIJKLMNO" ;
a=0 ; //set print tab
for (i=1;i<=15;i++){
ss1=intToString (i) ;
if (i>9) a=4 ; //tab for print number
cs.DrawText (ss1,25-a,645-i*40) ;
ss=subString (abc$,i,1) ;
cs.DrawText (ss,i*40-5,615) ; }

//draw button 绘制按钮
cs.SetColor (255,250,250,250);
cs.DrawRect (40,900,181,961);
cs.DrawRect (210,900,351,961);
cs.DrawRect (380,900,521,961);
cs.SetColor (255,250,0,0);
for (i=1;i<60;i++){ //按钮渐变色
cs.SetColor (255,240-i*4,240-i*3,250-i*4);
cs.DrawLine (41,900+i,180,900+i);
cs.DrawLine (211,900+i,350,900+i);
cs.DrawLine (381,900+i,520,900+i);
}
cs.SetColor(255,255,250,0);
cs.SetTextStyle (1);
cs.SetTextSize (32);
cs.DrawText ("复盘",72,940);
cs.DrawText ("悔棋",242,940);
cs.DrawText ("演示",412,940);
//print title
cs.SetTextSize (80);
cs.SetTextStyle (1);
cs.SetColor (255,100,100,100);
cs.DrawText ("五子棋",50,770);
cs.DrawText ("Gobang",50,870);
cs.SetColor (255,220,220,220);
cs.DrawText ("五子棋",52,772);
cs.DrawText ("Gobang",52,872);

for (i=1;i<=225;i++){
//draw chess pieces 画出已下黑白子
dx=(i-(i/15*15))*40;
dy=(i/15)*40+40;
if (dx==0){ dx=15*40; dy=dy-40; }
if ( pn[i]==2){ //white
cs.SetColor (255,140,80,40); //piecesW
cs.DrawCircle(dx+2,dy+2,17);
cs.SetColor (255,220,220,220); //pieceW
cs.DrawCircle(dx,dy,17);
cs.SetColor (255,250,250,250); //pieceW
cs.DrawCircle(dx-6,dy-6,2); }
if (pn[i]==1){ //black
cs.SetColor (255,220,100,40); //piecesB
cs.DrawCircle(dx+1,dy+1,17);
cs.SetColor (255,0,0,0); //pieceB
cs.DrawCircle(dx,dy,17);
cs.SetColor (255,200,200,200); //pieceB
cs.DrawCircle(dx-6,dy-6,2); }
} //draw chess pieces
cs.SetColor (255,240,0,0); //刚落子标记
cs.DrawCircle(px,py,5);
//提示选子
cs.SetTextSize (42);
cs.SetColor(255,255,120,250);
cs.DrawRect (390,670,600,740);
cs.SetColor(255,255,250,0);
cs.DrawText (s6,415,720); //pn(n) num
cs.SetTextSize (36);
if (mode==0) cs.SetColor(255,205,200,80);
if (mode==1) cs.SetColor(255,250,150,0);
cs.DrawText (s7,20,680); //mode
cs.SetTextStyle (0);
cs.SetTextSize (16);
cs.SetColor(255,255,250,250);
cs.DrawText (cordp1,665,dn*16); //record G8

//draw pieces number 画出下子序号*****
for (i=1;i<=dn;i++){
cn=i ;
s=intToString(cn) ;
kn=dwn[i] ;
dx=(kn-(kn/15*15))*40;
dy=(kn/15)*40+40;
if (dx==0){ dx=15*40; dy=dy-40; }
cs.SetTextSize (16);
cs.SetColor (255,0,160,0);
cs.DrawText (s,dx-5,dy+11);
}
cs.Update ();
detect (); //检测胜负
}//board ()

detect (){
//detect Black chess 判胜 ******
for (i=1;i<16;i++){ // B 黑子
for (j=1;j<12;j++){
k=(i-1)*15+j ; //pn(B) number
if (pn[k]==1){
if ( pn[k+1]==1&&pn[k+2]==1&&pn[k+3]==1&&pn[k+4]==1){ goto showwin ; } //右
} } }
for (i=1;i<12;i++){ // B 黑子
for (j=1;j<16;j++){
k=(i-1)*15+j ; //pn(B) number
if (pn[k]==1){
if ( pn[k+15]==1&&pn[k+30]==1&&pn[k+45]==1&&pn[k+60]==1){ goto showwin ; } //下
} } }
for (i=1;i<12;i++){ // B 黑子
for (j=1;j<12;j++){
k=(i-1)*15+j ; //pn(B) number
if (pn[k]==1){
if ( pn[k+16]==1&&pn[k+32]==1&&pn[k+48]==1&&pn[k+64]==1){ goto showwin ; } //右斜
} } }
for (i=1;i<12;i++){ // B 黑子
for (j=5;j<16;j++){
k=(i-1)*15+j ; //pn(B) number
if (pn[k]==1){
if ( pn[k+14]==1&&pn[k+28]==1&&pn[k+42]==1&&pn[k+56]==1){ goto showwin ; } //斜左
} } }
//********************************
//detect White chess 判胜 ******
for (i=1;i<16;i++){ // W 白子
for (j=1;j<12;j++){
k=(i-1)*15+j ; //pn(W) number
if (pn[k]==2){
if ( pn[k+1]==2&&pn[k+2]==2&&pn[k+3]==2&&pn[k+4]==2){ goto showwin ; } //右
} } }
for (i=1;i<12;i++){ // W 白子
for (j=1;j<16;j++){
k=(i-1)*15+j ; //pn(W) number
if (pn[k]==2){
if ( pn[k+15]==2&&pn[k+30]==2&&pn[k+45]==2&&pn[k+60]==2){ goto showwin ; } //下
} } }
for (i=1;i<12;i++){ // W 白子
for (j=1;j<12;j++){
k=(i-1)*15+j ; //pn(W) number
if (pn[k]==2){
if ( pn[k+16]==2&&pn[k+32]==2&&pn[k+48]==2&&pn[k+64]==2){ goto showwin ; } //右斜
} } }
for (i=1;i<12;i++){ // W 白子
for (j=5;j<16;j++){
k=(i-1)*15+j ; //pn(W) number
if (pn[k]==2){
if ( pn[k+14]==2&&pn[k+28]==2&&pn[k+42]==2&&pn[k+56]==2){ goto showwin ; } //斜左
} } }
//*****************************
if (dn>100) {
ss="( 和棋 )"; goto heqi; }
return;
//show win flag 判胜负
showwin:
if (pn[k]==1) {
ss="黑棋胜 ! !"; print ss;
// cs.SetTextStyle (0);
cs.SetTextSize (16);
cs.SetColor(255,255,250,250);
cs.DrawText (ss,665,(dn+2)*16); }
if (pn[k]==2) {
ss="白棋胜 ! !"; print ss;
// cs.SetTextStyle (0);
cs.SetTextSize (16);
cs.SetColor(255,255,250,250);
cs.DrawText (ss,665,(dn+2)*16); }

heqi: //和棋
cs.SetTextSize (60);
cs.SetTextStyle (1);
cs.SetFillMode (1);//0不填色，1填色
cs.SetColor(255,180,90,40);
cs.DrawText (ss,204,504);
cs.SetColor(255,255,0,0);
cs.DrawText (ss,200,500);
cs.SetFillMode (0);//0不填色，1填色
cs.SetColor(255,250,250,0);
cs.DrawText (ss,200,500);
cs.Update ();
isDo=0; //结束标志
}//detect ()

gamestart (){
setDisplay (1);
cord=1 ; //记录开关
for (i=1;i<226;i++){ pn[i]=0; } //init pn (n)
for (i=0;i<=90;i++){ dwn[i]=0; } //init dwn (n)
isDo=1; //游戏操作控制
s6="黑棋选子"; //init
px=320 ; py=320 ; //标记
dn=0; wn=0 ; //计数清零
gn=gn+1; //game round + 1
clearOutput(); //清除记录
cs.SetBackground(200,200,200); //清记录
board (); //绘出棋板
}//gamestart ()

undo(){ //悔棋，可选子连续清除
if (isDo==1) {
pn[n]=0; fudat[dn]=0;
//print "悔 "+intToString (n);
cs.SetTextStyle (0);
cs.SetTextSize (16);
cs.SetColor(255,250,0,0);
cs.DrawText ("悔",652,dn*16);
//dn=dn-1 ; //序号减 1
cs.Update ();
board (); }
}//undo ()

replay (){ //复盘
gamestart ();
setDisplay (1);
print "fusum= " ,fusum;
for (i=1;i<=fusum;i++){
//draw chess pieces 画出复盘黑子白子
kn=fudat[i] ; //取得数据
sd=i-i/2*2 ; //mod 0=白棋， 1=黑棋
dx=(kn-(kn/15*15))*40;
dy=(kn/15)*40+40;
if (dx==0){ dx=15*40; dy=dy-40; }
if ( sd==0){ //white
ss=intToString (kn);
cordp=" W "+ss;
row=15-(kn/15) ;
col=(kn-(kn/15*15)) ;
swapabc () ;
print i," ",cordp," " , ss,row ; //打印记录
ss4="W "+ss+intToString (row) ;
cs.SetColor (255,140,80,40); //piecesW
cs.DrawCircle(dx+2,dy+2,17);
cs.SetColor (255,220,220,220); //pieceW
cs.DrawCircle(dx,dy,17);
cs.SetColor (255,250,250,250); //pieceW
cs.DrawCircle(dx-6,dy-6,2); }
if ( sd==1){ //black
ss=intToString (kn);
cordp=" B "+ss;
row=15-(kn/15) ;
col=(kn-(kn/15*15)) ;
swapabc () ;
print i," ",cordp," " , ss,row ; //打印记录
ss4=" B "+ss+intToString (row) ;
cs.SetColor (255,220,100,40); //piecesB
cs.DrawCircle(dx+1,dy+1,17);
cs.SetColor (255,0,0,0); //pieceB
cs.DrawCircle(dx,dy,17);
cs.SetColor (255,200,200,200); //pieceB
cs.DrawCircle(dx-6,dy-6,2); }

if (i==fusum){
cs.SetColor (255,0,250,0); //标志最末胜子点
cs.DrawCircle(dx,dy,5);
cs.SetTextStyle (1);
cs.SetTextSize (60);
cs.SetFillMode (1);//0不填色，1填色
cs.SetColor (255,160,70,40);
cs.DrawText ("复盘",253, 553) ;
cs.SetColor (255,250,250,0);
cs.DrawText ("复盘",250, 550) ;
cs.SetFillMode (0);//0不填色，1填色
cs.SetColor (255,50,250,0);
cs.DrawText ("复盘",250, 550) ;
if ( sd==0) print "白棋胜！ " ;
if ( sd==1) print "黑棋胜！ " ;
}

cs.SetFillMode (1);//0不填色，1填色
cs.SetTextStyle (0);
cs.SetTextSize (16);
s=intToString (i); //标记序号
cs.SetColor (255,250,0,0);
cs.DrawText (s,dx-2,dy+5);
//界面显示记录
cs.SetTextSize (16);
cs.SetColor(255,255,250,250);
cs.DrawText (ss4,665,i*16); //界面显示记录
cs.Update ();
sleep (1000);
} //draw replay chess pieces
isDo=0 ; //结束标志
}//replay ()

myToolBarProc(int nBtn,int nContext){
if(nBtn==100){//开始游戏
gamestart ();
}
if(nBtn==101){//选择模式
mode=mode+1; //0=人人, 1= 人机
if (mode>1) mode=0 ;
if (mode==0) s7="游戏模式：双人对弈 ";
if (mode==1) s7="游戏模式：人机模式 ";
gamestart ();
}
if(nBtn==102){//黑棋下子
if ( pn[n]==0) black_do() ;
}
if(nBtn==103){//白棋下子，双人对弈模式
if (mode==0&&pn[n]==0) white_do () ;
}
if(nBtn==104){//退出程序
clearOutput();
cs.ClearDraw (0,src);
setDisplay (0);
exit (0);
}
if(nBtn==105){//查看记录
cord=cord+1;
if (cord>1) cord=0 ;
if (cord==0) setDisplay (0); //查看记录
if (cord==1) setDisplay (1); //显示棋板
}
}//myToolBar ()

loadpic (){ //可用于装载预设棋盘底图
//use filebox open a file and load a picture
filebox.SetTitle("装载图片(*.bmp;*.jpg;*.png)");
filebox.SetFilter(".bmp;.jpg;.png");
filebox.Show();
if(filebox.GetCount()==1){
fname=filebox.GetFileName(0);
if(getPicSize(fname,size)<0){
return; }
cs.ClearDraw (0,src);
cs.DrawBitmap(fname,0,2);
cs.Update ();
}
}//loadpic ()

//********End******

五子棋游戏设计（C语言AI智能板）相关推荐

五子棋游戏设计VHDL语言
本设计实现五子棋游戏设计,使用VHDL语言 quartusII 或者 vivado均可通过VGA显示实时的棋盘,双方可以通过按键来控制黑棋和白棋的位置,实现五子棋游戏的功能. 开始和胜利的界面如下: ...
Unity 五子棋游戏设计和简单AI（2）
上文我们实现了基本五子棋的下棋的基本功能,这次我们来判断五子棋的胜负条件.逻辑是这样的:每次下棋后之后对这个棋子进行8个方向的检测,如果有相同类型的棋子则沿着棋子继续判断直到5个为止.介绍完基本思路, ...
Unity五子棋游戏设计和简单AI实现（1）
1 准备工作: vs unity ,棋子,一张15*15的棋局. 我们先把准备好的图直接拖上来,将左下方的点设为(0,0),因此将中心点设为(7,7),由于图中的中心和图片pivot不完全吻合,所以 ...
C++毕业设计——基于C+++EasyX+剪枝算法的能人机对弈的五子棋游戏设计与实现（毕业论文+程序源码）——五子棋游戏
基于C+++EasyX+剪枝算法的能人机对弈的五子棋游戏设计与实现(毕业论文+程序源码) 大家好,今天给大家介绍基于C+++EasyX+剪枝算法的能人机对弈的五子棋游戏设计与实现,文章末尾附有本毕业设 ...
android五子棋设计模板,基于android的五子棋游戏设计
内容介绍原文档由会员 hfnmb 发布基于Android的五子棋游戏设计软件工程 [摘要]本论文主要阐述以面向对象的程序开发语言eclipse为开发工具, 基于智能手机Android之上设计一 ...
基于STM32F407的五子棋游戏设计
本博客为资源:基于STM32F407的五子棋游戏设计内的说明文档. 目录一.设计目标三.设计方案 1.游戏模式 2.游戏过程 3.游戏设计四.硬件配置 1.TFT-LCD液晶屏模块 (1)工作原 ...
iOS简易蓝牙对战五子棋游戏设计思路之一——核心蓝牙通讯类的设计
iOS简易蓝牙对战五子棋游戏设计思路之一--核心蓝牙通讯类的设计一.引言本系列博客将系统的介绍一款蓝牙对战五子棋的开发思路与过程,其中的核心部分有两个,一部分是蓝牙通讯中对战双方信息交互框架的设计 ...
iOS简易蓝牙对战五子棋游戏设计思路之二——核心棋盘逻辑与胜负判定算法
2019独角兽企业重金招聘Python工程师标准>>> iOS简易蓝牙对战五子棋游戏设计思路之二--核心棋盘逻辑与胜负判定算法一.引言上一篇博客我们介绍了在开发一款蓝牙对战五子棋 ...
基于C语言的五子棋游戏设计与实现课程报告+项目源码及可执行exe文件
资源下载地址:https://download.csdn.net/download/sheziqiong/85680476 资源下载地址:https://download.csdn.net/downl ...
C语言程序设计-五子棋游戏设计系统01
第一部分: 引言五子棋是一个家喻户晓的游戏,在棋盘上,黑白方互相落子,哪方先将至少五个棋子连成一条线哪方就获得胜利.现在,五子棋更是成为了一款竞技游戏,各种游戏策略层出不穷. 第二部分:系统功能和原 ...

五子棋游戏设计（C语言AI智能板）

五子棋游戏设计（C语言AI智能板）相关推荐

最新文章

热门文章