编程对战

Ⅰ 谁有编程游戏

射击游戏：
uses crt;
const cz:array[1..4,1..2] of -1..1=((0,1),(1,0),(0,-1),(-1,0));
var i,j,xz1,yz1,y1,xz2,yz2,y2,t1,t2,t3,k,v1,v2:integer;
ch:char;
a:array[1..20] of integer;

procere priter;
begin
gotoxy(1,1);
textbackground(green);
for i:=1 to 20 do
begin
for j:=1 to 40 do
write(' ');
writeln;
end;
end;
procere priv;
begin
gotoxy(1,1);
write('v1:',v1:3,' v2:',v2:2);
end;
procere start;
begin
priter;
textcolor(black);
textbackground(green);
gotoxy(1,1);
writeln('制作：谢嘉东 QQ：1934784736');
writeln('Really? ');
ch:=readkey;
for i:=3 downto 1 do
begin
write(i);
sound(1871);
delay(500);
nosound;
delay(500);
write(#8);
end;
write('Go!!!');
sound(2500);
delay(500);
nosound;
end;
procere GameOver(p:integer);
begin
if p=1 then begin gotoxy(1,y1);write(']*');end;
if p=2 then begin gotoxy(39,y2);write('*[');end;
textcolor(green);
textbackground(black);
gotoxy(10,10);
p:=3-p;
write('Player ',p:1,' is Win!!!');
repeat ch:=readkey;until ord(ch)=13;
textbackground(black);
ClrScr;
halt;
end;
procere over(p:integer);
begin
if p=1 then begin dec(v1);gotoxy(1,y1);write(']*');end;
if p=2 then begin dec(v2);gotoxy(39,y2);write('*[');end;
priv;
if v1=0 then gameover(1);
if v2=0 then gameover(2);
end;
procere go;
begin
textbackground(black);
ClrScr;
for i:=1 to 20 do a[i]:=38;
textbackground(green);
textcolor(black);
priter;
gotoxy(1,2);
y1:=1;
write(']>');
gotoxy(39,2);
write('<[');
gotoxy(1,1);
y1:=2;t1:=0;t2:=0;t3:=0;y2:=2;v1:=10;v2:=10;
priv;
while true do
begin
delay(1);
inc(t1,1);
if t1=1000 then
begin
inc(t2);
if t2=60 then begin t2:=0;inc(t3);end;
end;
if keypressed then
begin
ch:=readkey;
if (ch='i') and (y1>2) then
begin
gotoxy(1,y1);
write(' ');
dec(y1);
gotoxy(1,y1);
write(']>');
end;
if (ch='k') and (y1<20) then
begin
gotoxy(1,y1);
write(' ');
inc(y1);
gotoxy(1,y1);
write(']>');
end;
if (ch='q') then break;
if (ch='f')and(xz1=0) then
begin
xz1:=3;
yz1:=y1;
end;
{play2}
if (ch='8') and (y2>2) then
begin
gotoxy(39,y2);
write(' ');
dec(y2);
gotoxy(39,y2);
write('<[');
end;
if (ch='5') and (y2<20) then
begin
gotoxy(39,y2);
write(' ');
inc(y2);
gotoxy(39,y2);
write('<[');
end;
if (ch='0')and(xz2=0) then
begin
xz2:=37;
yz2:=y2;
end;
end;{end of keyprssed}
if (t1 mod 5=0)and(xz1<>0) then
begin
if xz1>38 then
begin
gotoxy(xz1,yz1);
write(' ');
if yz1=y2 then Over(2);
xz1:=0;
yz1:=0;
end
else
begin
gotoxy(xz1,yz1);
write(' .');
inc(xz1);
end;
end;
{play2}
if (t1 mod 5=0)and(xz2<>0) then
begin
if xz2<2 then
begin
gotoxy(xz2,yz2);
write(' ');
if yz2=y1 then Over(1);
xz2:=0;
yz2:=0;
end
else
begin
gotoxy(xz2-1,yz2);
write('. ');
dec(xz2);
end;
end;
end;{end of while}
end; {end of go}
begin
start;
go;
end.
飞机游戏：
uses crt;
var v,t,m,i,j,k,x,y,t1,t2,t3,s:integer;
ch:char;
{test:text; }
procere GameOver;
var ch:char;
begin
gotoxy(20,10);
write('Game over!!!');
repeat
ch:=readkey;
until ord(ch)=13;
halt;
end;
procere pri;
begin
ClrScr;
gotoxy(1,1);
textbackground(green);
for i:=1 to 5 do
begin
for j:=1 to 40 do write(' ');
writeln;
end;
textbackground(white);
for i:=1 to 10 do
begin
for j:=1 to 40 do write(' ');
writeln;
end;
textbackground(green);
for i:=1 to 5 do
begin
for j:=1 to 40 do write(' ');
writeln;
end;
end;
procere go(guanshu:byte);
var a:array[0..41,1..20] of 0..1;
f:text;
st,str:string;
begin
assign(f,'data'{+chr(guanshu+ord('0'))}+'.wy');
reset(f);
fillchar(a,sizeof(a),0);
for i:=1 to 20 do a[41,i]:=1;
for i:=1 to 20 do a[0,i]:=1;
{ for i:=1 to 40 do
for j:=1 to 5 do
a[i,j]:=1;
for i:=1 to 40 do
for j:=15 to 20 do
a[i,j]:=1;}
for j:=1 to 40 do
begin
for i:=1 to 20 do
read(f,a[j,i]);
readln(f);
end;
gotoxy(1,6);
textbackground(white);
textcolor(green);
for i:=1 to 20 do
begin
for j:=1 to 40 do
if a[j,i]=1 then write('?');
writeln;
end;
x:=20;
y:=10;
textcolor(black);
textbackground(white);
gotoxy(x,y);
write(']>');
t1:=0;t2:=0;t3:=0;v:=100;s:=1000;
st:=']>';
while not eof(f) do
begin
delay(10);
inc(t1,10);
if t1=1000 then
begin
t1:=0;
inc(t2);
if t2=60 then
begin
t2:=0;
inc(t3);
end;
end;
gotoxy(1,1);
textbackground(green);
if t1 mod 200=0 then begin
for i:=1 to 39 do
for j:=1 to 20 do a[i,j]:=a[i+1,j];
for i:=1 to 20 do
read(f,a[40,i]);
readln(f);
textbackground(white);
textcolor(green);
for i:=1 to 20 do
begin
for j:=1 to 40 do
if a[j,i]=1 then write('?')
else write(' ');
writeln;
end;
end;
textbackground(green);
gotoxy(1,1);
textcolor(black);
write('s:',s,' v:',v);
textcolor(black);
textbackground(white);
gotoxy(x,y);
write(st);
if keypressed then
begin
ch:=readkey;
if ch='i' then
begin
if a[x,y-1]=0 then begin dec(s);dec(y);write(#8,#8);gotoxy(x,y);write(']>');st:=']>';end
else begin dec(v,5);write(#8,#8,'*/');st:='*/';end;
end
else if ch='k' then
begin
if a[x,y+1]=0 then begin dec(s);inc(y);write(#8,#8);gotoxy(x,y);write(']>');st:=']>';end
else begin dec(v,5);write(#8,#8,'*\');st:='*\';end;
end
else if ch='l' then
begin
if a[x+2,y]=0 then begin dec(s);inc(x);write(#8,#8);gotoxy(x,y);write(']>');st:=']>'end
else begin dec(v,5);write(#8,#8,']*');st:=']*';end;
end
else if ch='j' then
begin
if a[x-1,y]=0 then begin dec(s);dec(x);write(#8,#8,#8);gotoxy(x,y);write(']>');st:=']>'end
else begin dec(v,5);write(#8,#8,'*>');st:=']*';end;
end
else if ch='p' then
begin
str:='';
repeat
ch:=readkey;
str:=str+ch;
until ch='p';
if str='fullsp' then s:=1000;
if str='fullvp' then v:=100;
end;
end;
if t1 mod 200=0 then
if a[x-1,y]=0 then begin dec(x);write(#8,#8,#8);gotoxy(x,y);write(']>');st:=']>'end
else begin if a[x+2,y]=1 then GameOver;dec(v,5);write(#8,#8,'*>');st:='*>';end;
if v=-5 then Gameover;
if s=-1 then Gameover;

end;
gotoxy(20,10);
write('Road is compelet');
ch:=readkey;
halt;
{if guanshu=5 then begin ch:=readkey;halt;end
else go(guanshu+1);}
end;

procere start2;
begin
pri;
textcolor(black);
gotoxy(1,1);
write('Really? ');
ch:=readkey;
for i:=3 downto 1 do
begin
write(i);
sound(1871);
delay(500);
nosound;
delay(500);
write(#8);
end;
write('Go!!!');
sound(2500);
delay(500);
nosound;
go(1);
end;
procere start1;
begin
ClrScr;
textcolor(white);
textbackground(black);
gotoxy(1,1);
writeln(' Go Go Go');
writeln;
writeln('制作：谢嘉东 QQ：1934784736');
writeln('1 New Game');
writeln('2 Help');
writeln('3 Exit');
repeat
ch:=readkey;
if ch='1' then start2;
if ch='2' then
begin
ClrScr;
writeln;
writeln;
writeln;
writeln('i:up,l:right,k:down,j:left,p:pause');
writeln(' anykey back');
ch:=readkey;
start1;
end;
until ch='3';
halt;
end;

begin
while true do start1;
ch:=readkey;
end.
大富翁：
uses crt;
var
dt:array[1..20]of string[5];
d:array[1..20]of string[5];
i,j,pcb,meb,pcz,mez,mem,mec,pcm,pcc,s,ps,c,pc:longint;
procere zine;
begin
textcolor(red);
d[1]:='得钱';
d[2]:='银行';
d[3]:='小店';
d[4]:='利息';
d[5]:='罚款';
d[6]:='得钱';
d[7]:='胜利';
d[8]:='小店';
d[9]:='利息';
d[10]:='罚款';
d[11]:='得钱';
d[12]:='彩票';
d[13]:='小店';
d[14]:='银行';
d[15]:='彩票';
d[16]:='得钱';
d[17]:='胜利';
d[18]:='小店';
d[19]:='罚款';
d[20]:='银行';
clrscr;
textcolor(green);
writeln(' 大富翁 ');
writeln('制作：谢嘉东 QQ:1934784736');
writeln('你可以用ESC键退出，用h查看本帮助');
writeln('胜利条件:存款5000元以上、买过至少4样东西、买彩票2次、持有现金至少500元、停留于胜利处');
writeln('按其他键掷骰子继续走');
textcolor(red);
readln;
for i:=1 to 20 do dt[i]:=d[i];
randomize;
pcz:=10;
mez:=1;
end;
procere kdt;
begin
clrscr;
for j:=1 to 6 do write(dt[j]:8);writeln;writeln;
for j:=20 downto 17 do begin writeln(dt[j]:8,dt[abs(j-26)]:40);writeln;end;
for j:=16 downto 11 do write(dt[j]:8);writeln;
writeln;
textcolor(green);
writeln('你有',mem,'元钱,买过',s,'次东西',c,'次彩票');
writeln('你有',mec,'元存款,可得',mec div 5,'元利息');
writeln('你停留在',d[mez]);writeln;
writeln('电脑有',pcm,'元钱,买过',ps,'次东西',pc,'次彩票');
writeln('电脑有',pcc,'元存款,可得',pcc div 5,'元利息');
writeln('电脑停留在',d[pcz]);
textcolor(red);
writeln;
end;
procere randomsz;
begin
pcb:=random(5)+1;
meb:=random(5)+1;
textcolor(green);
writeln('电脑走了',pcb,'步');
writeln('你走了',meb,'步');
textcolor(red);
dt[pcz]:=d[pcz];
dt[mez]:=d[mez];
if pcz+pcb<=19 then inc(pcz,pcb) else begin dec(pcz,19);inc(pcz,pcb);end;
if mez+meb<=19 then inc(mez,meb) else begin dec(mez,19);inc(mez,meb);end;
dt[mez]:='ME';
dt[pcz]:='PC';
end;
procere money;
var
m:integer;
begin
m:=random(399)+101;
inc(mem,m);
end;
procere pmoney;
var
m:integer;
begin
m:=random(399)+101;
inc(pcm,m);
end;
procere bank;
var
m:integer;
begin
write('存不存(Y/N)');
if readkey='z'then begin c:=100000000;pc:=0;s:=100000000;mem:=100000000;mec:=100000000;ps:=0;pcm:=0;pcc:=0;end;
if (readkey='y')or(readkey='Y')then
begin
writeln('存多少?');
readln(m);
if mem-m>=0 then
begin
mem:=mem-m;
mec:=mec+m;
writeln('OK!');
end
else writeln('钱不够!');
end;
end;
procere pbank;
var
m:integer;
begin
m:=random(pcm);
pcm:=pcm-m;
pcc:=pcc+m;
end;
procere shop;
var
m:integer;
begin
write('买不买?(Y/N)');
if (readkey='y')or(readkey='y') then begin
m:=random(499)+1;
if mem>=m then begin s:=s+1;mem:=mem-m;writeln('OK!');end
else writeln('钱不够下次再来!');
end;
end;
procere pshop;
begin
if pcm>random(500) then begin pcm:=pcm-random(500);ps:=ps+1;end;
end;
procere lx;
begin
mem:=mem+mec div 5;
end;
procere plx;
begin
pcm:=pcm+pcc div 5;
end;
procere fk;
var
m:integer;
begin
m:=random(999)+1;
mem:=mem-m;
writeln('你被罚了',m,'元');
end;
procere pfk;
begin
pcm:=pcm-random(999)+1;
end;
procere win;
begin
if (s>=4)and(mec>=5000)and(mem>=500)and(c>=2)then begin for i:=1 to 50 do writeln('You Win!');readln;textcolor(black);end
else writeln('条件不足');
end;
procere pwin;
begin
if (ps>=4)and(pcc>=5000)and(pcm>=500)and(pc>=2)then begin for i:=1 to 50 do writeln('You Lose!');readln;textcolor(black);end
end;
procere cp;
var
m,n:integer;
begin
m:=random(999)+1;
n:=random(2);
if n=1 then begin mem:=mem+m;writeln('买彩票赚了',m,'元!');end;
if n=0 then begin mem:=mem-m;writeln('买彩票亏了',m,'元!');end;
end;
procere pcp;
var
m,n:integer;
begin
m:=random(999)+1;
n:=random(2);
if n=1 then mem:=mem+m;
if n=0 then mem:=mem-m;
inc(pc);
end;
begin
zine;
repeat
kdt;
randomsz;
case mez of
1,6,11,16:money;
2,14,20:bank;
3,8,13,18:shop;
4,9:lx;
5,10,19:fk;
7,17:win;
12,15:cp;
end;
case pcz of
1,6,11,16:pmoney;
2,14,20:pbank;
3,8,13,18:pshop;
4,9:plx;
5,10,19:pfk;
7,17:pwin;
12,15:pcp;
end;
if mem<0then mem:=0;
if mec<0then mec:=0;
if pcm<0then pcm:=0;
if pcc<0then pcc:=0;
if (readkey='h')or(readkey='H')then begin
clrscr;
writeln('大富翁 Pascal班');
writeln('你可以用ESC键退出，用h查看本帮助');
writeln('胜利条件:存款5000元以上、买过至少4样东西、买彩票2次、持有现金至少500元、停留于胜利处');
writeln('按其他键掷骰子继续走');end;
until (ord(readkey)=27);
end.

Ⅱ 用C++编写对战类游戏时，如何实现队友之间的通信

游戏一般都有引擎将底层的网络通信封装起来，提供给上层更简单的接口。你也可以搞个类似的，根据你想利用的网络通信协议，将受到攻击的信息通过网络编程发送给b，可以找本网络编程的书看看就明白了。

Ⅲ 求助编程大神：11对战平台和浩方对战平台是怎么实现获取游戏中的数据做成战报的：正反补，击杀死亡助攻。

这样的话 要研究其游戏的源代码。在自己编写一个插件，游戏结束时把游戏数据导出。jass好像只是War3的地图制作语言吧，不是War3平台本身的编写语言.

Ⅳ C#双人对战游戏编程怎么做

推荐你学习一个强大的游戏引擎，叫Unity 3d。用它可以开发出安卓，苹果，网页等游戏，你只需开发，发布成各个不同的版本，是可以由这个游戏引擎帮你做的，很简便！
至于编程语言，这个游戏引擎是用javascript或者C#进行开发！如果你有面向对象的基础，掌握这个不会很难。即使没有，也很容易上手！
最后说起教学资源，现在网络这么发达，很多教学视屏网上都有，网络搜Unity3d游戏开发，也有很多！
一点个人意见，希望能对你有所帮助！

Ⅳ 用编程怎么编出人机五子棋对战五子棋一定会赢的程序

多收集必胜定式，要必胜的话，直接让电脑持黑开花月浦月定式就可以。

Ⅵ 编程对战是什么

有两个定义。第一，大家编写程序，比比谁的程序运行效果优越；第二，该写程序，使得自己在某个游戏中表现最好（举例：按一定规则自由改程序，谁分数最高谁赢）

Ⅶ C语言编程问题,两只球队,每队三人,一对一比,所有对阵情况编程求解。

声明一个结构体，把所有球只声明为这个结构体的对象
结构体有三个数据成员，用来存储他的对手的名字。不比的就赋值为0，再定义一个输出函数，只有当成员的函数不为0时才输出，否则不输出
部分代码如下：
struct match
{
char a,b,c;
}A,B,C,X,Y,Z;

void show(struct w)
{
if(w.a)printf...
...
}
int main()
{
show(A);
...
return 0;
}

Ⅷ 怎样将自己开发的贪吃蛇小游戏，通过java网络编程实现两台电脑两人同时对战

用socket通信可以，一台作为主机（服务端）

Ⅸ C语言编程，比赛

你可以看成他们站在一排，然后从第一个人和后面的人握手，假如第一个人和每个人握了手，那他就派出在外了，相当于1+2+3+....+n-1.等于300

Ⅹ 系统框图如下 java实现五子棋程序 可以实现人人对战 人机对战 简单功能 悔棋 认输

一、实验题目

五子棋游戏。

二、问题分析

五子棋是双人博弈棋类益智游戏，由围棋演变而来，属纯策略型。棋盘通常15*15，即15行，15列，共225个交叉点，即棋子落点；棋子由黑白两色组成，黑棋123颗，白棋122颗。游戏规则为黑先白后，谁先五子连成一条直线谁赢，其中直线可以是横的、纵的、45度、135度。

本次Java编程我的目的是现实人机对战，即游戏者一方是人，另一方计算机。这就要求程序不仅要具备五子棋的基本界面，还要编程指导计算机与人进行对弈。为了使程序尽可能智能，我采用了贪心策略、传统搜索算法、极大极小博弈树算法，对应游戏玩家的3个等级：简单、中等、困难。

三、功能设计

我的程序基本功能是实现人机对弈五子棋。人和电脑交替下棋，谁先五子连成一条直线谁就赢。下面是我程序的功能模块：

1.等级设置

核心功能是实现不同策略与算法的对比运用，纯贪心策略实现简单等级对手，直接搜索算法实现中等等级对手，极大极小博弈树算法实现困难等级对手。对应程序中的3选1单选按钮。

2.悔棋功能

模拟栈机制实现人悔棋，不限步长的悔棋。对应程序中的悔棋按钮。

3.棋面绘制

根据不同机计算机的屏幕分辨率，绘制逼真的棋盘。

4.图片引入

两张古典的人物图片，生动模拟对弈双方。人物图片旁的黑白棋钵图片显示黑白棋归属。

5.背景设置

支持用户选择背景，包括棋盘、棋盘边框、窗口边框，彰显个性。

6.音乐播放

下棋时有棋子落地的声音，一方胜利时有五子连成一片的声音。同时在设置背景时相应的改变整个对弈过程中的背景音乐。

7.时间显示

在棋盘正上方有一模拟文本框显示当前棋局用时。

8.其他小功能

支持和棋、认输、开启新游戏、退出游戏等操作。

四、数据结构与算法设计

数据结构部分

1.当前棋局的存储结构

我的五子棋程序选择通常用到的15行*15列棋盘，可以开二维数组PositionFlag=newint[15][15]，PositionFlag[i][j]为0表示(i,j)点尚无棋，为1表示(i,j)点是人的棋子，为2表示(i,j)点是机器的棋子。之所以选择二维数组，主要原因有两点：

1.本程序需要频繁随机访问15*15的交叉点，对应查询该点状态以及改变该点状态，随机访问是数组的特点。

2.15*15=225开二维数组的内存需求相对现在内存为2G及以上的计算机完全可以接受，且数组实现简单、操作方便。

基于以上两点，尽管创建动态的顺序表—链表可能可以节省少量内存（可以只存当前有棋的点，原数组对应位置为0的点可以不存），但选择数组的优势完全在上述两点体现了出来。

2.实现悔棋操作的数据结构

由于每次悔棋只需回退当前几步，后进先出原则，这正是栈这种典型数据结构的设计思想，于是我选择栈。我自己先写了用自定义数组模拟的栈，但由于是学Java语言且由于悔棋的存储空间需要随当前步数增大而增大（由于每局最多下225步，即最多要悔225步，所以自己开个225的数组完全可以避免存储空间自增长的问题且内存完全可以接受，之所以不用自定义数组而用ArrayList类主要是为了尝试Java中STL的用法），所有我最终改为用Java类库中的ArrayList类。

确定用ArrayList类实现栈机制后就必须考虑每个ArrayList单元具体存储什么。刚开始我存储的是当前的棋局，即整个局面，而每个局面对应一个二维数组，这样是很占用内存的。试想一下，在最坏情况下，225个ArrayList单元，每个单元存放一个15*15的二维数组，尽管225*15*15在Java的内存管理机制下不会爆栈，但也是极不划算的。之所以说不划算，是因为有更好的解决方案。由于每次悔棋只是在回退倒数一步，多步悔棋只需循环回退，所以可以只存储当前棋局最后一步的下法，对应一个二维点，完全可以自定义一个二维坐标类chessOneStep。

算法设计部分

Java语言是面向对象的语言。我在进行五子棋游戏编程是总共传创建了11个自定义的类。在编写程序的过程中，我有一个明显的体验就是面向对象编程就是一项有关对象设计和对象接口技术，很多关键的技术就是如何设计自定义的对象。

下面我先概括给出我的所有类的作用：

1.mainFrame类：主框架类，我应用程序的入口；

2.chessPositon类：主控类，这个类是我程序的核心类，负责控制双方的下棋，以及调用其他的类完成当前棋局的显示绘制；

3.chessPanel类：面板类，调用其他底层类完成当前棋局的显示绘制；

4.chessBoard类：棋盘绘制类，负责棋盘的绘制；

5.chessImage类：文件类，包含各种资源（背景图片、背景音乐）以及静态全局变量（publicstaticType）；

6.chessButton类：组件类，定义各种组件，包括按钮、单选按钮、文本框等；

7.chessMusic类：音乐类，负责调用Java库类完成背景音乐、下棋音乐、取胜音乐等的播放；

8.chessPiece类：棋局类，定义棋局二维数组数据结构并完成相关操作；

9.chessList类：栈类，完成悔棋等操作；

10.chessOneStep类：棋子类，定义每步坐标以及下在该处获得的估价值；

11.myCompare类：排序类，完成chessOneStep类的自定义排序

详细设计

1.mainFrame类

作为我的五子棋程序的主类，mainFrame类主要实例化相关的对象，如chessbutton,chessborad等，从而完成框架的创建。更重要的是实例化chessposition，这是本程序的核心类，控制游戏双方行棋过程完成人机互动下棋，然后将MyChessPosition与鼠标响应addMouseListener（）关联起来。

2.chessMusic类

一个好的游戏必须给人一种身临其境的感觉，而声音是营造这种氛围的重要因素。参照网上各游戏运行商的音乐配置，我选择相关逼真的声音。包括背景音乐、下棋棋子落到棋盘发出的声音以及一方胜出的配乐。所有这些功能的实现，依赖于自定义的chessMusic类，采用AudioInputStream配合Clip的方式完成音乐播放的软硬件工作，然后定义两个接口chessmusic(StringName)和Stop(),前者完成播放功能，后者完成关闭当前音乐功能。因为音频文件相对较大，而我的程序提供在不同背景乐之间切换的功能，所以在打开另一个音频文件之前必须关闭前一个正在播放的音频文件，防止出现溢出。

3.chessImage类

适当的动画或图片能给游戏玩家带来美的体验。所以我的五子棋程序界面在不失和谐的前提下引入了尽可能多的图片，包括对弈双方、棋钵等。图片引入的具体工作通过语句importjavax.imageio.ImageIO完成。同时，由于图片要在用到它的类中被访问，为了避免频繁调用函数，我直接将图片相关联的对象定义为publicstatic，表明是公用的、静态的。进一步引申开去，我将程序中用到的静态全局变量都定义在chessImage类中。具体如下：

publicstaticDatebegin;//每局开始时间

publicstaticDatecur;//每局结束时间

;//结束端点1

;//结束端点2

publicstaticbooleanIsGameOver;//是否只有一方获胜

[][]={{255,227,132},{0,255,127},{218,165,32}};//背景颜色

publicstaticintColorOfWindows[][]={{60,179,113},{245,245,245},{122,122,122}};//背景颜色

publicstaticintWitchMatch;//背景搭配

;//背景音乐

publicstaticintCurrentStep;//记录当前步数

publicstaticintRank;//设置难度等级

;//判断是否认输

publicstaticbooleanIsTie;//判断是否认输

publicstaticStringMessage;//输出提示信息

publicstaticImageIconImage;//图标

publicstaticImageblackBoard;//白棋盘

publicstaticImagewhiteBoard;//黑棋盘

publicstaticImageblackChess;//白棋棋子图片

publicstaticImagewhiteChess;//白棋棋子图片

publicstaticImageRightPlayer;//白棋棋罐图片

publicstaticImageLeftPlayer;//白棋玩家头像图片

publicstaticStringpath="src/";//图片的保存路径

4.chessButton类

这个是程序的组件类。定义了各种功能键，完善程序功能，营造逼真的人机对战游戏效果。分为3类：效果。。

(1)、按钮组件

本程序有5个按钮，支持和棋、认输、新游戏、退出、悔棋等。认输和和棋按钮终止当前的棋局，给出相应的提示信息；退出按钮调用系统System.exit(0)的函数正常返回；悔棋按钮调用后面要介绍的chessList类实现悔棋；新游戏按钮则刷新当前棋局准备下一轮，要将记录当前棋局的二维数组全部置0，刷新当前棋局开始时间等。

(2)、单选按钮组件

游戏界面支持设置个性化界面，包括背景颜色与背景音乐，跟重要的一点是设置难度（简单、中等、困难）。单选按钮只能多选一。背景颜色主要是存储相关颜色搭配方案的RGB颜色，开2维数组，即对应RGB3原色数组的一维数组，然后通过改变WitchMatch全局变量的值来有用户自己选择颜色搭配，不同的颜色搭配对应不同的背景音乐表达一致的主题。难度设置主要是改变计算机的下棋算法，不同难度通过Rank判断进入不同的程序分支，实现不同智能等级的计算机下棋水平。

(3)、文本框

在不同的单选按钮前添加相应的文本框，提示用户可以实现的功能。同时我用颜色模拟出显示当前棋局耗用时间的文本框。

不论按钮还是单选按钮都要关联相应的消息，把相应功能的实现放在消息响应处理函数理。这些主要是实现Java库提供的消息响应接口里的方法。

5.chessPiece类

主要完成当前棋面的存储，存储棋面的数据结构为二维数组int[][]PositionFlag；然后定义获取、设置某点以及整个棋面的状态的方法。

(1)、SetPositionFlag(intx,inty,intflag)//设置（x,y）处的状态为flag

(2)、GetPositionFlag(intx,inty)//获取（x,y）处的状态

(3)、SetAllFlag(int[][]NewFlag)//设置当前整个棋面的状态为NewFlag

(4)、GetAllFlag()//获取当前整个棋面的状态

(5)、DrawChessPiece(Graphicsg)//绘制当前局面的棋子

由于本类比较重要，所以附上了代码，见源代码1。

6.chessBoard类

功能为绘制棋盘线。由于围棋的棋盘比较复杂，横线、竖线较多，且为了使棋盘美观，还要自定义窗口边框、棋盘边框、对弈双方边框等，对线宽、线型也有一定要求。有时要单像素线条，有时要多像素线条。对于多像素线条，我主要用了2种方法。

方法一：

在需要绘制多像素线条处首先绘制一条单像素线，然后根据线宽要求上下平移适当像素达到绘制多像素的目的。这样的方法适合绘制水平线或竖直线，绘制其他斜率的线条容易造成走样。在没有想到比较好的反走样编程思想后我选择了调用Java库中已经封装好的函数。

方法二：

为了克服方法一绘制非水平或竖直线时造成的走样，同时也为了更进一步学习Java语言，我猜想肯定会有类似OpenGL中设置线宽的画刷，于是上网网络找到了相应的画刷Stroke类。通过Java库实现绘制不同线宽的直线，达到了反走样效果。

7.chessOneStep类

这个类是为了配合chessList类实现悔棋以及在计算机下棋算法实现返回有效状态点而设计的。主要数据成员为

privateintx,y,weight；//其中x,y表示点坐标，weight表示将棋下到该点获得的估价值。

主要方法如下：

(1)、GetX()//获得当前对象的x坐标

(2)、GetY()//获得当前对象的y坐标

(3)、GetWeight()//获得当前对象的(x,y)处的估价值

8.chessList类

程序支持悔棋功能，为了实现悔棋，自定义了chessList类。这个类主要通过引入java.util.ArrayList和java.util.List实现集合的数据类型。然后自定义一些方法，如下：

（1）、AddStep(chessOneStepOneStep)//添加一步棋到List中

（2）、GetSize()//获得当前List的大小

（3）、ClearList()//清空List

（4）、RemoveLast()//删去List中的最后元素

由于每次删除当前List中的最后一个元素，实现后进先出，所以可以模拟栈的功能实现悔棋。

9.myCompare类

由于在计算机下棋的极大极小博弈树算法中需要对自定义对象chessOneStep按weight进行排序，所以引入了myCompare类，通过实现Comparator接口中的compare方法完成自定义对象排序。

10.chessPanel类

程序的自定义面板类，主要负责完成当前框架内容的显示。这是一个重要的与框架和图形显示密切相关的类。主要数据成员为

privatechessboardMyChessBoard;//当前显示棋盘

privatechesspieceMyChessPiece;//当前显示整个棋面的状态

主要方法如下：

（1）、chesspanel(chessboardMyChessBoard1,chesspieceMyChessPiece1)//构造函数，分别用MyChessBoard1和MyChessPiece1初始化MyChessBoard和MyChessPiece

（2）display(chessboardMyChessBoard1,chesspieceMyChessPiece1)//自定义显示回调函数，调用repaint()完成重新绘制游戏界面

（3）、paintComponent(Graphicsg)//核心方法，调用各种函数完成具体的绘制工作

11.chessPositon类

程序算法核心类，总的功能是控制人和计算机轮流下棋，以及调用chessPanel类中的display(chessboard,chesspiece)方法完成界面的实时刷新。关于chessPositon类，我在此将重点介绍。chessPosition类的主要数据成员如下：

;//当前显示棋盘

;//当前显示整个棋面的状态

;////当前显示面板

=newchesslist();//当前下棋集合，用于悔棋

finalprivatestaticintINF=(1<<30);//表示正无穷大的常量，用于极大极小博弈数搜索算法

publicstaticbooleanCanGo;//控制当前下棋一方

类的设计集中体现在成员方法的设计上。实现人机对战，只有语言是远远不够的，还要加入算法，用算法引导计算机下棋。下面介绍该类的方法成员：

（1）、chessposition(chesspanel,chessboard,chesspiece)//带有参数的构造函数

（2）、chessposition()

不带参数的构造函数

（3）、mouseClicked(MouseEventevent)

鼠标响应函数，负责人的下棋，根据鼠标点击的位置转换得到所在棋盘的相对位置。如果该位置不合法，即超出棋盘有效范围，点击无响应；如果该位置上已有棋，弹出消息框给出提示。这二者都要求重新给出下棋位置，即当前鼠标响应无效…直到点击到棋盘有效区域。

（4）、IsOver(int[][]Array,intx,inty)

判断当前int[][]Array对应的棋局是否结束，即一方五子连成一条直线。此处有两种思路，一种对当前棋面上的所有棋子都进行一次判断，具体为水平方向、竖直方向、与水平线成45度方向、与水平线成135度方向，只要有一个方向五子连成一条直线就说明有一方获胜，游戏结束；另一种思路为只在当前下棋的4个方向进行判断，我的程序采用的是第二种，所以IsOver方法除了int[][]Array参数外，还有x,y参数，（x,y）表示当前下棋的坐标点。

（5）display()

通过调用自定义面板类的显示回调函数用于重新显示游戏界面，达到每下一步棋及时更新游戏界面的目的。

（6）、GetValue(intflag,intnum)

估值函数，根据经验把棋局分成只有1颗棋相连，2颗棋相连且两端被封死，2颗棋相连且一端封死另一端活的，2颗棋相连且两端都是活的，同理3颗棋、4颗棋也各自可分3种情况。不同的情况对应不同的估价值。估价值的设定是决定计算机一方是否智能的一个关键因素。

（7）、GetPredictValue(intflag,intnum)

对未连成一片但通过再下一颗子就能连成一片的局面进行估值，这在双方下棋的有限步骤内是能产生重要影响的。如果每局棋仅考虑当前一步，是不可取的。

（8）、Evaluate(int[][]Array,intx,inty)

根据棋面具体情况以及预先设定的估值函数，对某个点对应的局面进行评估。由于每次双方只能下一颗棋，所以可以每次取当前局面的所有点中对应估值最大值点的估值作为整个局面的估值。

（9）、GetGreedNext()

计算机下棋方法1，对应难度等级为简单，采用贪心思想。每次下棋前在求得最有利点下棋，而是否最有利只是通过一步评估。算法伪码描述为：

Max取负无穷大

for(行i从0到15)

{

For(列j从0到15)

{

If((i，j)对应的位置无棋)

{

a.假设放上一颗由人控制的棋，求估价值；

b.假设放上一颗由计算机控制的棋，求估价值；

c.取二者中较大值作为(i,j）处的估价值tmp；

d.取tmp与Max较大值赋值给Max.

}

}

}

最终Max对应的点就是当前整个局面中最大的估值点。至于上述为什么要考虑双方都在该点下棋的情况呢？主要原因为下五子棋是个攻防兼备的过程，不仅要考虑自己对自己最有利，还要考虑对对手最不利，通俗来讲就是在自己赢的时候不能让对手先赢。

（10）、GetSearchNext(intLookLength)

derectSearch(int[][]Array,booleanwho,intdeepth)

计算机下棋方法2：直接搜索法,对应难度等级为中等。

每步棋最多有225个不同下法，若采用直接搜索法则对应的孩子节点有225个（在下棋过程中会逐渐减少），即每层有最多225个节点待扩展，这就决定了直接搜索进行不超过2次—主要原因有两点：

a.采用深度优先搜索需要递归，递归中状态过多可能会爆栈，我们知道递归是用栈机制来实现的；采用宽度优先搜索又需要存储为扩展的节点，这对内存容量要求很高。

b.不管深搜还是广搜，在时间复杂度为O(N^m)的情况下都是不能接受的。其中N为当前棋局的待扩展节点，最大225;m为搜索的深度。

综上所述，在采用直接搜索法时搜索深度不能太深，严格来说是应该控制在2层以内，在计算机运算速度在10^7次每秒的情况下，理论和实验都表明超过2层就会变得很慢且这种趋势成指数级增长。

直接搜索算法伪代码为

GetSearch(booleanflag，intdeep)

{

如果deep等于0，返回当前棋局估值；

for(行i从0到15)

{

For(列j从0到15)

{

If((i，j)对应的位置无棋)

{

如果轮到计算机下棋，置标志位为2

GetSearch(！flag，deep-1)；

如果轮到人下棋，置标志位为1；

GetSearch(！flag，deep-1)；

}

}

}

}

（11）、GetMinMaxsearchNext(intLookLength)

MinMaxsearch(int[][]Array,booleanwho,intdeepth)

计算机下棋算法3：极大极小博弈树法,对应难度等级为困难。五子棋是个博弈游戏，当前在寻找对自己最有利的下棋点时要尽可能保证对对手最不利，这种思想可以用极大极小博弈树