围棋游戏，有人写过吗？用什么算法判断有没气？

[zette]

我想写一围棋游戏，两人在同一机器上玩的就行？不会写自动提子的算法

[o3y]

这是我刚学Pascal时写的一个程序，做得特别烂，所以叫PoorGo，后来还发现Undo时有两个Bug，也懒得改了。提子的函数是EatChess，不知你是否需要。


文件UPoorGo.pas

Unit
UPoorGo;

Interface

Uses
Crt,Graph;
Const
RecordFileName='PoorGo.';
TempRecordFileName='PoorGo.Tmp';
TempFileName='PoorGo.$$$';
Size=19;
DX:Array [1..4] Of Integer=(-1,0,1,0);
DY:Array [1..4] Of Integer=(0,-1,0,1);
Style=20;
Type
BoardType=Array [0..Size-1,0..Size-1] Of Integer;
Var
Board:BoardType;
BoardGraph:Array [0..Size-1,0..Size-1] Of Pointer;
Step,NowX,NowY,MemSize:Integer;
Pattern:FillPatternType;
BOrW:Boolean;
TempFile,TempRecordFile:Text;
Function ActualXY(xy:Integer):Integer;
Function InKey:Char;
Procedure EatChess(x,y:Integer);
Procedure EndGame;
Procedure GoChess(x,y:Integer);
Procedure InitGame;
Procedure KeyManage(Key:Char);
Procedure MoveCursor(Direction:Integer);
Procedure PutChess(x,y,ChessType:Integer);
Procedure PutCursor(x,y:Integer);
Procedure UndoChess;

Implementation

Function ActualXY(xy:Integer):Integer;
Begin
ActualXY:=13+xy*Style;
End;
Procedure EatChess;
Var
i,j,d,ti,tj:Integer;
More:Boolean;
Begin
If (x<0) Or (x>=Size) Or (y<0) Or (y>=Size) Or (Board[x,y]=0)
Then Exit;
Board[x,y]:=-Board[x,y];
Repeat
More:=False;
For i:=0 To Size-1 Do
For j:=0 To Size-1 Do
If Board[i,j]<0
Then For d:=1 To 4 Do
Begin
ti:=i+DX[d];
tj:=j+DY[d];
If (ti>=0) And (ti<Size) And (tj>=0) And (tj<Size)
Then If Board[ti,tj]=-Board[i,j]
Then Begin
Board[ti,tj]:=-Board[ti,tj];
More:=True;
End
Else If Board[ti,tj]=0
Then Begin
For ti:=0 To Size-1 Do
For tj:=0 To Size-1 Do
Board[ti,tj]:=Abs(Board[ti,tj]);
Exit;
End;
End;
Until Not More;
For i:=0 To Size-1 Do
For j:=0 To Size-1 Do
If Board[i,j]<0
Then Begin
PutChess(i,j,0);
Board[i,j]:=0;
Write(TempRecordFile,i,' ',j,' ');
End;
PutCursor(NowX,NowY);
End;
Function InKey;
Var
ch:Char;
Begin
ch:=Readkey;
While ch=#0 Do
ch:=Readkey;
InKey:=ch;
End;
Procedure EndGame;
Begin
CloseGraph;
Close(TempRecordFile);
End;
Procedure GoChess;
Var
i:Integer;
Begin
If Board[x,y]>0
Then Exit;
Inc(Step);
If BOrW
Then Begin
PutChess(x,y,1);
Board[x,y]:=1;
End
Else Begin
PutChess(x,y,2);
Board[x,y]:=2;
End;
PutCursor(x,y);
Write(TempRecordFile,x,' ',y,' ');
For i:=1 To 4 Do
EatChess(x+DX[i],y+DY[i]);
EatChess(x,y);
Writeln(TempRecordFile);
BOrW:=Not BOrW;
SetFillPattern(Pattern,Black);
Bar(450,150,550,200);
SetTextStyle(DefaultFont,HorizDir,2);
SetColor(White);
If BOrW
Then OutTextXY(450,150,'Black')
Else OutTextXY(450,150,'White');
End;
Procedure InitGame;
Var
Gd,Gm,i,j:Integer;
Begin
Step:=0;
Assign(TempRecordFile,TempRecordFileName);
ReWrite(TempRecordFile);
FillChar(Board,SizeOf(Board),0);
Gd:=Detect;
InitGraph(Gd,Gm,'D:\Euler\Tp\Bgi');
ClearViewPort;
GetFillPattern(Pattern);
SetFillPattern(Pattern,Blue);
Bar(3,3,Style*(Size-1)+23,Style*(Size-1)+23);
SetColor(Black);
For i:=0 To Size-1 Do
Begin
Line(13+i*Style,13,13+i*Style,Style*(Size-1)+13);
Line(13,13+i*Style,Style*(Size-1)+13,13+i*Style);
End;
Rectangle(10,10,Style*(Size-1)+16,Style*(Size-1)+16);
Rectangle(11,11,Style*(Size-1)+15,Style*(Size-1)+15);
SetFillPattern(Pattern,Black);
For i:=0 To 2 Do
For j:=0 To 2 Do
PieSlice(ActualXY(3+i*6),ActualXY(3+j*6),0,360,2);
BOrW:=True;
MemSize:=ImageSize(13-Style Div 2,13-Style Div 2,
13+Style Div 2,13+Style Div 2);
For i:=0 To Size-1 Do
For j:=0 To Size-1 Do
Begin
GetMem(BoardGraph[i,j],MemSize);
GetImage(ActualXY(i)-Style Div 2,ActualXY(j)-Style Div 2,
ActualXY(i)+Style Div 2,ActualXY(j)+Style Div 2,BoardGraph[i,j]^);
End;
NowX:=9;
NowY:=9;
PutCursor(NowX,NowY);
SetColor(White);
SetTextStyle(GothicFont,HorizDir,10);
OutTextXY(400,0,'Go!');
SetTextStyle(DefaultFont,HorizDir,2);
OutTextXY(450,150,'Black');
End;
Procedure KeyManage;
Begin
Case Key Of
#72:MoveCursor(2);
#75:MoveCursor(1);
#77:MoveCursor(3);
#80:MoveCursor(4);
#13:GoChess(NowX,NowY);
#8:UndoChess;
#27:Exit;
End;
End;
Procedure MoveCursor;
Begin
PutChess(NowX,NowY,Board[NowX,NowY]);
NowX:=(NowX+DX[Direction]+Size) Mod Size;
NowY:=(NowY+DY[Direction]+Size) Mod Size;
PutCursor(NowX,NowY);
End;
Procedure PutChess;
Begin
Case ChessType Of
0:PutImage(ActualXY(x)-Style Div 2,ActualXY(y)-Style Div 2,
BoardGraph[x,y]^,NormalPut);
1:Begin
SetColor(Black);
SetFillPattern(Pattern,Black);
PieSlice(ActualXY(x),ActualXY(y),0,360,Style Div 2-2);
End;
2:Begin
SetColor(White);
SetFillPattern(Pattern,White);
PieSlice(ActualXY(x),ActualXY(y),0,360,Style Div 2-2);
End;
End;
End;
Procedure PutCursor;
Begin
SetColor(Red);
Rectangle(ActualXY(x)-Style Div 4,ActualXY(y)-Style Div 4,
ActualXY(x)+Style Div 4,ActualXY(y)+Style Div 4);
End;
Procedure UndoChess;
Var
i,x,y:Integer;
ch:Char;
Begin
If Step=0
Then Exit;
Close(TempRecordFile);
ReSet(TempRecordFile);
Assign(TempFile,TempFileName);
Rewrite(TempFile);
For i:=1 To Step-1 Do
Begin
Read(TempRecordFile,x,y);
Write(TempFile,x,' ',y,' ');
While Not SeekEoln(TempRecordFile) Do
Begin
Read(TempRecordFile,x,y);
Write(TempFile,x,' ',y,' ');
End;
Writeln(TempFile);
End;
Read(TempRecordFile,x,y);
BOrW:=Not BOrW;
PutChess(x,y,0);
Board[x,y]:=0;
While Not SeekEoln(TempRecordFile) Do
Begin
Read(TempRecordFile,x,y);
PutChess(x,y,Ord(BOrW)+1);
Board[x,y]:=Ord(BOrW)+1;
End;
PutCursor(NowX,NowY);
Close(TempRecordFile);
Erase(TempRecordFile);
Close(TempFile);
Rename(TempFile,TempRecordFileName);
Assign(TempRecordFile,TempRecordFileName);
Append(TempRecordFile);
Dec(Step);
SetFillPattern(Pattern,Black);
Bar(450,150,550,200);
SetTextStyle(DefaultFont,HorizDir,2);
SetColor(White);
If BOrW
Then OutTextXY(450,150,'Black')
Else OutTextXY(450,150,'White');
End;

End.

文件PoorGo.pas
Uses
Crt,UPoorGo;
Var
ch:Char;
Begin
InitGame;
Repeat
ch:=InKey;
KeyManage(ch);
Until ch=#27;
EndGame;
End.

[塞纳河水]

http://www.vchelp.net/vchelp/zsrc/weiqi.zip
这是一个基于网络的围棋源代码.

[djniulihao]

“手谈”的编程技术
“手谈”的走棋主要决定于静态评价。直至1994年的早期版本, 走棋选点没有用到搜索法。1995年试把搜索法用于走棋选点, 但棋力未见提高。近年虽有些提高, 搜索法的作用还是不能满意的。最近我做了一个选点不用搜索的“手谈”版本。它在与有选点搜索法的版本对弈时似乎差些, 但对其他程序时显得与有选点搜索法的版本一样强。

“手谈”的棋力主要依靠静态评价的精细计算。关键是棋子分块和块安全性的估计。

棋子的分块
“手谈”的棋子分块与陈克训提出的相似, 首先决定于棋子的“影响”, 再辅之以某些连接模式。
**影响
“手谈”的影响函数与陈克训的明显不同。一个正常白子的影响是：
对其邻位为 4;
对其斜邻位为 3;
对其关位和小飞位为 2;
比关和小飞稍远的某些位置，影响为 1。
黑子辐射出负数的影响。
死子辐射出反号的影响。半死或受伤的棋子辐射出较少的影响。

多个棋子对一个点的影响可以叠加，但非线性叠加。例如，某点若同时与黑子和白子相邻，则其值为０，不问有多少个黑子和白子。若某点影响的代数和为 1 或 -1, 则取为 0 (保留 1|-1 表示假眼位)。若影响值大于 2, 则先作为白方的全控制点, 再作圆滑处理(见下); 若影响值小于-2, 则先作为黑方的全控制点再作圆滑处理。黑|白全控制点取值 6|-6。

影响的单位称为小点(dot)。

圆滑处理方案包括如下规则：

与０或负影响相邻的点，不得超过３小点；
与１或２小点相邻的点，不得超过５小点；
负值(黑影响)有类似的规则;
1|-1小点代表白|黑假眼位。
**块的构成
相互邻接的白非死子、黑死子、以及 1 或超过 3 小点的空点合并成一白块; 邻近的、相互不能分割的白块再合成一白块。黑块亦按类似的方法构成。
块危险性估算
块危险性可表为有适当单位的一个量。围棋中常用于形势判断的单位为目。块危险性也可以用目为单位。

块危险性的因素为：1. 不足两眼, 2. 没有足够的自由度。作定量估算时, 还要计及块的大小。因此, 块危险值应为３个自变量的函数：欠眼数、自由度、大小。函数的具体形式应经验地确定，并可在调整时改变。

**自由度
陈克训把自由度解释为块周围的敞开程度。
块的自由度可表为封锁它所需的手数。业已探明，有关的函数应为指数型的：封锁手数每增１，块危险值应减半。

然而，封锁手数恐怕不容易由程序计算。这就有必要设计适当的方案来计算自由度，以代替封锁手数。

“手谈”有两个自由度方案。

早期方案：自由度由与块（棋子或空点）的邻位和斜邻位计算。

第二方案：自由度由属于块的棋子的关位和小飞位计算。

第二方案视野较广，似较合理。然而围棋编程中，模糊的估算常会有某些优越性，故第一方案在某些情况下会较合适，并使棋走得更好。“手谈”的近年版本计算越来越精细，就需要更精细的自由度第二方案。

近年还用过一个第三方案，但已发现它有错误。修正了的方案已用于另一程序“弈侣”的新版本。

模式与效率
“手谈”棋力的另一关键是进子价值的效率修改。好着点（急所、手筋等）设为正效率，而坏着点（愚形、俗手等）设为负效率。
进子价值被乘以一个因子：正效率对应的因子大于１，负效率对应的因子小于１。

效率主要由模式识别来赋值。不过“手谈”用了笨拙的模式识别方法：只用指令来处理而没有用模式库。这就使模式难以修改补充，只能包括少量模式。

模式的大小是不固定的，但不超过下列范围：

...
.....
.......
...*...
.......
.....
...


这份材料由“手谈”的作者陈志行提供。

[springleo]

用递归很容易实现的

[dcyu]

用递归很容易实现，这是我和同学以前一起做的一个围棋程序，只能双人对下：
http://vip.6to23.com/dcyu/download/围棋.zip

[dcyu]

改一下：
http://vip.6to23.com/dcyu/download/weiqi.zip

[xd_fei]

别相信DCYU，是个病毒

[dcyu]

不好意思，学校机房中了folder病毒，我没有发现，谢谢楼上的提醒。
现在已经把病毒删了。
http://vip.6to23.com/dcyu/download/weiqi.zip

[ywqzxj]

算起应该不难吧
人机对战研究中...

www.smiling.com.cn "围棋程序"小组

[journay]

回嗍就可以了！

[Liusp]

gz