你还要掌握一些 Linux C编程的一些图形函数,
像 画直线,一些的函数,基本都没什么差别,都和
windows 的差不多.
其实鼠标没有控制什么,只是计算机鼠标的位置,然后画图而已.
五子棋的核心算法五子棋是一种受大众广泛喜爱的游戏，其规则简单，变化多端，非常富有趣味性和消遣性。这里设计和实现了一个人机对下的五子棋程序，采用了博弈树的方法，应用了剪枝和最大最小树原理进行搜索发现最好的下子位置。介绍五子棋程序的数据结构、评分规则、胜负判断方法和搜索算法过程。
一、相关的数据结构
关于盘面情况的表示，以链表形式表示当前盘面的情况，目的是可以允许用户进行悔棋、回退等 *** 作。
CList StepList
其中Step结构的表示为：
struct Step
{
int m//m,n表示两个坐标值
int n
char side//side表示下子方
}
以数组形式保存当前盘面的情况，
目的是为了在显示当前盘面情况时使用：
char FiveArea[FIVE_MAX_LINE][FIVE_MAX_LINE]
其中FIVE_MAX_LINE表示盘面最大的行数。
同时由于需要在递归搜索的过程中考虑时间和空间有效性，只找出就当前情况来说相对比较好的几个盘面，而不是对所有的可下子的位置都进行搜索，这里用变量CountList来表示当前搜索中可以选择的所有新的盘面情况对象的集合：
CList CountList
其中类CBoardSituiton为:
class CBoardSituation
{
CList StepList//每一步的列表
char FiveArea[FIVE_MAX_LINE][FIVE_MAX_LINE]
struct Step machineStep //机器所下的那一步
double value//该种盘面状态所得到的分数
}
二、评分规则
对于下子的重要性评分，需要从六个位置来考虑当前棋局的情况，分别为：-,¦,/,\,//,\\
实际上需要考虑在这六个位置上某一方所形成的子的布局的情况，对于在还没有子的地方落子以后的当前局面的评分，主要是为了说明在这个地方下子的重要性程度，设定了一个简单的规则来表示当前棋面对机器方的分数。
基本的规则如下：
判断是否能成5, 如果是机器方的话给予100000分，如果是人方的话给予－100000 分；
判断是否能成活4或者是双死4或者是死4活3，如果是机器方的话给予10000分，如果是人方的话给予－10000分；
判断是否已成双活3，如果是机器方的话给予5000分，如果是人方的话给予－5000 分；
判断是否成死3活3，如果是机器方的话给予1000分，如果是人方的话给予－1000 分；
判断是否能成死4，如果是机器方的话给予500分，如果是人方的话给予－500分；
判断是否能成单活3，如果是机器方的话给予200分，如果是人方的话给予－200分；
判断是否已成双活2，如果是机器方的话给予100分，如果是人方的话给予－100分；
判断是否能成死3，如果是机器方的话给予50分，如果是人方的话给予－50分；
判断是否能成双活2，如果是机器方的话给予10分，如果是人方的话给予－10分；
判断是否能成活2，如果是机器方的话给予5分，如果是人方的话给予－5分；
判断是否能成死2，如果是机器方的话给予3分，如果是人方的话给予－3分。
实际上对当前的局面按照上面的规则的顺序进行比较，如果满足某一条规则的话，就给该局面打分并保存，然后退出规则的匹配。注意这里的规则是根据一般的下棋规律的一个总结，在实际运行的时候，用户可以添加规则和对评分机制加以修正。
三、胜负判断
实际上，是根据当前最后一个落子的情况来判断胜负的。实际上需要从四个位置判断，以该子为出发点的水平，竖直和两条分别为 45度角和135度角的线，目的是看在这四个方向是否最后落子的一方构成连续五个的棋子，如果是的话，就表示该盘棋局已经分出胜负。具体见下面的图示：
四、搜索算法实现描述
注意下面的核心的算法中的变量currentBoardSituation，表示当前机器最新的盘面情况, CountList表示第一层子节点可以选择的较好的盘面的集合。核心的算法如下：
void MainDealFunction()
{
value=－MAXINT//对初始根节点的value赋值
CalSeveralGoodPlace(currentBoardSituation,CountList)
//该函数是根据当前的盘面情况来比较得到比较好的可以考虑的几个盘面的情况，可以根据实际的得分情况选取分数比较高的几个盘面，也就是说在第一层节点选择的时候采用贪婪算法，直接找出相对分数比较高的几个形成第一层节点，目的是为了提高搜索速度和防止堆栈溢出。
pos=CountList.GetHeadPosition()
CBoardSituation＊ pBoard
for(i=0ivalue=Search(pBoard,min,value,0)
Value=Select(value,pBoard－>value,max)
//取value和pBoard－>value中大的赋给根节点
}
for(i=0ivalue)
//找出那一个得到最高分的盘面
{
currentBoardSituation=pBoard
PlayerMode=min//当前下子方改为人
Break
}
}
其中对于Search函数的表示如下：实际上核心的算法是一个剪枝过程，其中在这个搜索过程中相关的四个参数为：（1）当前棋局情况；（2）当前的下子方，可以是机器(max)或者是人(min)；（3）父节点的值oldValue；（4）当前的搜索深度depth。
double Search(CBoardSituation＆
board,int mode,double oldvalue,int depth)
{
CList m_DeepList
if(deptholdvalue))== TRUE)
{
if(mode==max)
value=select(value,search(successor
Board,min,value,depth＋1),max)
else
value=select(value,search(successor
Board,max,value,depth＋1),min)
}
return value
}
else
{
if ( goal(board)<>0)
//这里goal(board)<>0表示已经可以分出胜负
return goal(board)
else
return evlation(board)
}
}
注意这里的goal(board)函数是用来判断当前盘面是否可以分出胜负，而evlation(board)是对当前的盘面从机器的角度进行打分。
下面是Select函数的介绍，这个函数的主要目的是根据 PlayerMode情况，即是机器还是用户来返回节点的应有的值。
double Select(double a,double b,int mode)
{
if(a>b ＆＆ mode==max)¦¦ (a<b ＆＆ mode==min)
return a
else
return b
}
五、小结
在Windows *** 作系统下，用VC＋＋实现了这个人机对战的五子棋程序。和国内许多只是采用规则或者只是采用简单递归而没有剪枝的那些程序相比，在智力上和时间有效性上都要好于这些程序。同时所讨论的方法和设计过程为用户设计其他的游戏（如象棋和围棋等）提供了一个参考。
参考资料：http://www.3800hk.com/Article/cxsj/vc/jdsfvc/2005-08-06/Article_33695.html
我给你一个c++五子棋的程序mian.cpp#include <cstdio>#include <string>
#include <cstdlib>
#include <ctime>
#include <Windows.h>
#include "pl.h"
using namespace stdpl game
pl game2void srandput(int &x,int &y) {
srand(time(NULL))
do {
x = rand() % 20
y = rand() % 20
} while (!game.isok(x,y))
}void scanfput(int &x,int &y) {
do {
scanf("%d %d",&x,&y)
} while (!game.isok(x,y))
}int main() {
int x,y
char who = com
x = y = -1
do {
if (who == com) who = me
else who = com
if (who == me) {
game.getxy(x,y)
printf("Com put chess in (%d,%d)\n",x,y)
game.printmap()
if (game.isend(x,y,com)) {
who = com
break
} game.sendxy(x,y)
printf("I put chess in (%d,%d)\n",x,y)
game.printmap()
if (game.isend(x,y,me)) break
//system("pause")
}
else {
//srandput(x,y)
scanfput(x,y)
//game2.getxy(x,y)
//game2.sendxy(x,y)
}
} while (true)
if (who == me) {
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),dwMe)
puts("You Win, Computer Lose.")
}
else {
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),dwCom)
puts("Computer Win, You Lose.")
}
printf("Use %d Steps\n",game.getstep())
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),dwWhite)
} pi.hconst DWORD dwWhite = FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_GREEN
const DWORD dwMe = FOREGROUND_GREEN
const DWORD dwCom = FOREGROUND_RED
//■□○●
char rec1[] = {-95,-10,0}
char rec2[] = {-95,-11,0}
char cir1[] = {-95,-16,0}
char cir2[] = {-95,-15,0}
//////////////////////////////////////////////////////////////////////////
//class pl
//////////////////////////////////////////////////////////////////////////
const int NMAX = 20
const int MAX = 1200
const char blank = '0'
const char me = '1'
const char com = '2'class pl {
public:
void sendxy(int &,int &)
void getxy(int,int)
void initscore()
void refreshscore(char,int,int)
void calscore(char)
void solve(int &,int &)
void printmap()
bool isok(int,int)
bool isend(int,int,char)
int getstep()
pl()
private:
int usestep
int wincount
char chess[NMAX][NMAX]
int win[2][MAX]
//ps,pt ->me
//cs,ct ->com
int ps[NMAX][NMAX],
cs[NMAX][NMAX]
bool pt[NMAX][NMAX][MAX],
ct[NMAX][NMAX][MAX]
}pl::pl() {
memset(chess,blank,sizeof(chess))
memset(pt,false,sizeof(pt))
memset(ct,false,sizeof(ct))
memset(win,0,sizeof(win))
wincount = 0
usestep = 0
initscore()
}void pl::printmap() {
int i,jfor (i=0i<NMAXi++) {
printf("\t\t\t%d\t",i)
for (j=0j<NMAXj++) {
if (chess[i][j] == me) {
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),dwMe)
printf("%s",cir2)
}
else if (chess[i][j] == com) {
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),dwCom)
printf("%s",cir2)
}
else printf("%s",rec2)
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),dwWhite)
}
putchar('\n')
}
printf("\n\t\t\t\t")
for (i=0i<NMAXi++) printf("%2d",i)
putchar('\n')
}void pl::getxy(int x,int y) {
if (x==-1 &&y==-1) return
refreshscore(com,x,y)
}bool pl::isok(int x,int y) {
return (chess[x][y] == blank)
}bool pl::isend(int x,int y,char who) {
int i,j
int l,r,u,d,c1,c2,c3,c4
if (x==-1 &&y==-1) return false
l = r = u = d = 0
c1 = c2 = c3 = c4 = 0
for (i=1i<5 &&x+i <NMAXi++) {
if (who == chess[x+i][y]) u ++
else break
}
for (i=1i<5 &&x-i >= 0i++) {
if (who == chess[x-i][y]) d ++
else break
}
for (i=1i<5 &&y+i <NMAXi++) {
if (who == chess[x][y+i]) r ++
else break
}
for (i=1i<5 &&y-i >= 0i++) {
if (who == chess[x][y-i]) l ++
else break
}
for (i=1i<5 &&x+i <NMAX &&y+i <NMAXi++) {
if (who == chess[x+i][y+i]) c1 ++
else break
}
for (i=1i<5 &&x+i <NMAX &&y-i >= 0i++) {
if (who == chess[x+i][y-i]) c2 ++
else break
}
for (i=1i<5 &&x-i >= 0 &&y-i >= 0i++) {
if (who == chess[x-i][y-i]) c3 ++
else break
}
for (i=1i<5 &&x-i >= 0 &&y+i <NMAXi++) {
if (who == chess[x-i][y+i]) c4 ++
else break
}
return ( (u+1+d)>=5 || (l+1+r)>=5 || (c1+1+c3)>=5 || (c2+1+c4)>=5 )
}void pl::sendxy(int &x, int &y) {
solve(x,y)
usestep ++
}//枚举赢的局面
void pl::initscore() {
int i,j,k
//竖
for (i=0i<NMAXi++) {
for (j=0j<NMAX-4j++) {
for (k=0k<5k++) pt[j+k][i][wincount] = ct[j+k][i][wincount] = true
wincount ++
}
}
//横
for (i=0i<NMAXi++) {
for (j=0j<NMAX-4j++) {
for (k=0k<5k++) pt[i][j+k][wincount] = ct[i][j+k][wincount] = true
wincount ++
}
}
//斜1
for (i=0i<NMAX-4i++) {
for (j=0j<NMAX-4j++) {
for (k=0k<5k++) pt[j+k][i+k][wincount] = ct[j+k][i+k][wincount] = true
wincount ++
}
}
//斜2
for (i=0i<NMAX-4i++) {
for (j=NMAX-1j>=4j--) {
for (k=0k<5k++) pt[j-k][i+k][wincount] = ct[j-k][i+k][wincount] = true
wincount ++
}
}
}//计算全局位置的分值
void pl::calscore(char who) {
bool (*table)[NMAX][MAX]
int (*score)[NMAX]
int iwho
if (who == me) {
table = pt
score = ps
iwho = 1
}
else {
table = ct
score = cs
iwho = 0
}
srand(time(NULL))
int i,j,k
for (i=0i<NMAXi++) {
for (j=0j<NMAXj++) {
score[i][j] = 0
if (chess[i][j] == blank) {
for (k=0k<wincountk++) {
if (!table[i][j][k]) continue
//分值的大小影响棋子位置的选择
srand(rand())
switch (win[iwho][k]) {
case 1:
score[i][j] += 1
break
case 2:
score[i][j] += 10
break
case 3:
score[i][j] += 100
break
case 4:
score[i][j] += 1000
}
}
}
}
}
}void pl::solve(int &x, int &y) {
calscore(me)
calscore(com)
int i,j
int me_score,com_score
int me_x,me_y,com_x,com_y
me_score = com_score = -1
//选取我方或对方得分最大值
for (i=0i<NMAXi++) {
for (j=0j<NMAXj++) {
if (chess[i][j] == blank) {
if (me_score <ps[i][j]) {
me_score = ps[i][j]
me_x = i
me_y = j
}
if (com_score <cs[i][j]) {
com_score = cs[i][j]
com_x = i
com_y = j
}
}
}
}
if (me_score >com_score) {
x = me_x
y = me_y
}
else {
x = com_x
y = com_y
}
refreshscore(me,x,y)
}//更新分数
void pl::refreshscore(char who,int x,int y) {
bool (*table)[NMAX][MAX]
bool (*antitable)[NMAX][MAX]
int iwho
if (who == me) {
table = pt
antitable = ct
iwho = 1
}
else {
table = ct
antitable = pt
iwho = 0
}
chess[x][y] = who
for (int i=0i<wincounti++) {
//一方位置能胜利次数
if (table[x][y][i] &&win[iwho][i] <INT_MAX) win[iwho][i] ++
if (antitable[x][y][i]) {
//另一方无法放置
antitable[x][y][i] = false
win[1-iwho][i] = INT_MAX
}
}
}int pl::getstep() {
return usestep
}
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）