Windows应用程序 C# 五子棋设计

我有VB的源文件，给你点思路。

用二维数组确定位置。

用drawline函数可以画棋盘，drawellipse画棋子就行。。想弄得好看点直接调用

连续五个位置判断就行了。

之前有人问过同样的问题，我回答的，你们是不是同一个系的，要做课程设计？我直接粘贴过来：

我自己写了一个简单的程序，可选择落子的先后顺序，重新开始，最后判断某一方是否为五子连珠。选择落子的先后顺序，只需定义一个boolean变量，每次切换取其反值；重制棋盘或重新开始就把棋盘重新绘制一遍；判断某一方是否为五子连珠，就判断某方的每个棋子，以它为中心与之紧邻的水平，垂直，左斜，右斜四个方向是否有五子连珠。用一个二维数组position存储棋盘上的棋子情况，position[x][y]=1,0,-1分别表示棋盘的第x行第y列下有黑子，无子，白子。源代码如下：

package comtest;

import javaawt;

import javautil;

import javaawtgeom;

import javaawtevent;

import javaxswing;

public class MyFiveChess {

public static void main(String[] args) {

JFrame f = new JFrame();

fsetDefaultCloseOperation(JFrameEXIT_ON_CLOSE);

Dimension screenSize = ToolkitgetDefaultToolkit()getScreenSize();

int screenWidth = screenSizewidth;

int screenHeight = screenSizeheight;

fsetSize(screenWidth / 2, screenHeight / 2);

fsetLocation(screenWidth / 4, screenHeight / 4);

fsetTitle("FiveChess");

MyPanel panel = new MyPanel();

fadd(panel);

fsetVisible(true);

}

}

class MyPanel extends JPanel {

private static final int SIDELENGTH = 10;

private ArrayList<Ellipse2D> squares = new ArrayList<Ellipse2D>();;

private Ellipse2D current = null;

JButton jb = new JButton("重新开始");

JButton jb2 = new JButton("切换先手");

boolean isBlack;

boolean first = true;

boolean isOver;

int l = 16;

int n = 20;

int bx = 20;

int by = 20;

int[][] position = new int[n + 1][n + 1];

public MyPanel(){

jbaddActionListener(new MyActionHandler());

jb2addActionListener(new MyActionHandler());

addMouseListener(new MouseHandler());

addMouseMotionListener(new MouseMotionHandler());

add(jb);

add(jb2);

}

public void initMyPenal(){

squares = new ArrayList<Ellipse2D>();

current = null;

isBlack = first;

isOver = false;

position = new int[n + 1][n + 1];

for(int i = 0; i <= n; i++)

for(int j = 0; j <= n; j++)

position[i][j] = 0;

repaint();

}

public void paint(Graphics g) {

superpaint(g);

jbsetLocation(400,150);

jb2setLocation(400,200);

gsetColor(ColorRED);

gsetFont(new Font(null, FontBOLD, 20));

gdrawString((first "黑" : "白")+"方下子", 400, 100);

gsetColor(new Color(240, 210, 120));

gfillRect(bx - l, by - l, l (n + 2), l (n + 2));

gsetColor(ColorBLACK);

for (int i = 0; i <= n; i++){

gdrawLine(bx, by + i l, bx + l n, by + i l);

gdrawLine(bx + i l, by, bx + i l, by + l n);

}

Graphics2D g2 = (Graphics2D)g;

isBlack = first;

for(Ellipse2D r : squares){

g2setColor(isBlack ColorBLACK : ColorWHITE);

g2fill(r);

isBlack = !isBlack;

}

if(isOver) {

gsetColor(ColorRED);

gsetFont(new Font("TimesRoman", FontBOLD, 60));

gdrawString((isBlack "白" : "黑") + "方获胜", 120, 200);

}

}

public Ellipse2D find(Point2D p){

for(Ellipse2D r : squares)

if(rcontains(p))

return r;

return null;

}

public void add(Point2D p) {

if(pgetX() > bx - l / 2 && pgetX() < bx + l n + l / 2 &&

pgetY() > by - l / 2 && pgetY() < by + l n + l / 2){

for (int i = 0; i <= n; i++) {

for (int j = 0; j <= n; j++) {

if(position[i][j] == 1 || position[i][j] == -1) continue;

current = new Ellipse2DDouble(bx + j l - l / 2,

by + i l - l / 2, l, l);

if (currentcontains(p)) {

position[i][j] = isBlack 1 : -1;

isOver = isWin(position, isBlack, i , j) true : false;

currentsetFrame(bx + j l - l / 2 + 1,

by + i l - l / 2 + 1, l - 2, l - 2);

squaresadd(current);

repaint();

return;

}

}

}

}

}

private class MouseHandler extends MouseAdapter{

public void mousePressed(MouseEvent event){

if(isOver) return;

current = find(eventgetPoint());

if(current == null)

add(eventgetPoint());

}

}

private class MyActionHandler implements ActionListener{

public void actionPerformed(ActionEvent e) {

String cmd=egetActionCommand();

if("重新开始"equals(cmd)){

initMyPenal();

}else if("切换先手"equals(cmd)){

initMyPenal();

first=!first;

}

}

}

private class MouseMotionHandler implements MouseMotionListener{

public void mouseMoved(MouseEvent event){

Rectangle r = new Rectangle(bx - l, by - l, l (n + 2), l (n + 2));

if(rcontains(eventgetPoint())){

setCursor(CursorgetPredefinedCursor(CursorCROSSHAIR_CURSOR));

}else setCursor(CursorgetDefaultCursor());

}

public void mouseDragged(MouseEvent event){}

}

public boolean isWin(int[][] state, boolean isBlack, int x, int y) {//四个方向中是否有五子连珠

return isCzWin(state, isBlack, x, y)

|| isSpWin(state, isBlack, x, y)

|| isYxWin(state, isBlack, x, y)

|| isZxWin(state, isBlack, x, y);

}

public boolean isCzWin(int[][] state, boolean isBlack, int x, int y) {//判断垂直方向是否有五子连珠

int n = 0;

int a = (x >= 4 x - 4 : 0);

int b = (x <= statelength - 5 x + 4 : statelength - 1);

for (int i = a; i <= b; i++)

if (state[i][y] == (isBlack 1: -1)) {

if (++n == 5) return true;

} else n = 0;

return false;

}

public boolean isSpWin(int[][] state, boolean isBlack, int x, int y) {//判断水平方向是否有五子连珠

int n = 0;

int a = (y >= 4 y - 4 : 0);

int b = (y <= state[0]length - 5 y + 4 : state[0]length - 1);

for (int i = a; i <= b; i++)

if (state[x][i] == (isBlack 1: -1)) {

if (++n == 5) return true;

} else n = 0;

return false;

}

public boolean isZxWin(int[][] state, boolean isBlack, int x, int y) {//判断左斜方向是否有五子连珠

int n = 1, a = x, b = y;

for (int i = 1; i <= 4 && a > 0 && b > 0; i++)

if (state[a - 1][b - 1] == (isBlack 1: -1)) {

n++; a--; b--;

} else break;

for (int i = 1; i <= 4 && x < statelength - 1 && y < state[0]length - 1; i++)

if (state[x + 1][y + 1] == (isBlack 1: -1)) {

n++; x++; y++;

} else break;

if (n >= 5) return true;

return false;

}

public boolean isYxWin(int[][] state, boolean isBlack, int x, int y) {//判断右斜方向是否有五子连珠

int n = 1, a = x, b = y;

for (int i = 1; i <= 4 && a > 0 && b < state[0]length - 1; i++)

if (state[a - 1][b + 1] == (isBlack 1: -1)) {

n++; a--; b++;

} else break;

for (int i = 1; i <= 4 && x < statelength - 1 && y > 0; i++)

if (state[x + 1][y - 1] == (isBlack 1: -1)) {

n++; x++; y--;

} else break;

if (n >= 5) return true;

return false;

}

}

比较简略，自己可以根据情况修改，改进改进！

一、实验题目

五子棋游戏。

二、问题分析

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

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

三、功能设计

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

1等级设置

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

2悔棋功能

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

3棋面绘制

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

4引入

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

5背景设置

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

6音乐播放

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

7时间显示

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

8其他小功能

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

四、数据结构与算法设计

数据结构部分

1当前棋局的存储结构

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

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

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

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

2实现悔棋 *** 作的数据结构

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

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

算法设计部分

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

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

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

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

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

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

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

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

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

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

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

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

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

详细设计

1mainFrame类

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

2chessMusic类

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

3chessImage类

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

public static Date begin;//每局开始时间

public static Date cur;//每局结束时间

public static chessOneStep LineLeft;//结束端点1

public static chessOneStep LineRight;//结束端点2

public static boolean IsGameOver;//是否只有一方获胜

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

public static int ColorOfWindows[][]= {{ 60,179,113},{245,245,245},{122,122,122}};//背景颜色

public static int WitchMatch;//背景搭配

public static String MusicOfBackGround;//背景音乐

public static int CurrentStep;//记录当前步数

public static int Rank;//设置难度等级

public static boolean IsSurrender;//判断是否认输

public static boolean IsTie;//判断是否认输

public static String Message;//输出提示信息

public static Image IconImage;// 图标

public static Image blackBoard;//白棋盘

public static Image whiteBoard;//黑棋盘

public static Image blackChess;// 白棋棋子

public static Image whiteChess;// 白棋棋子

public static Image RightPlayer;//白棋棋罐

public static Image LeftPlayer;//白棋玩家头像

public static String path = "src/";// 的保存路径

4chessButton类

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

(1)、按钮组件

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

(2)、单选按钮组件

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

(3)、文本框

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

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

5chessPiece类

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

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

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

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

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

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

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

6chessBoard类

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

方法一：

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

方法二：

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

7chessOneStep类

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

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

主要方法如下：

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

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

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

8chessList类

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

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

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

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

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

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

9myCompare类

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

10chessPanel类

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

private chessboard MyChessBoard;//当前显示棋盘

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

主要方法如下：

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

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

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

11chessPositon类

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

private static chessboard MyChessBoard;//当前显示棋盘

public static chesspiece MyChessPiece;//当前显示整个棋面的状态

private static chesspanel Mychesspanel;////当前显示面板

public static chesslist MyChessList=new chesslist();//当前下棋集合，用于悔棋

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

public static boolean CanGo;//控制当前下棋一方

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

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

（2）、chessposition()

不带参数的构造函数

（3）、mouseClicked(MouseEvent event)

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

（4）、IsOver(int[][] Array,int x,int y)

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

（5）display()

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

（6）、GetValue(int flag, int num)

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

（7）、GetPredictValue(int flag, int num)

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

（8）、Evaluate(int[][] Array, int x, int y)

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

（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(int LookLength)

derectSearch(int [][]Array,boolean who,int deepth)

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

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

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

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

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

直接搜索算法伪代码为

GetSearch(boolean flag，int deep)

{

如果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(int LookLength)

MinMaxsearch(int [][]Array,boolean who, int deepth)

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

#define MAX_LINE 15

#define MAX_ROW 15

int Map[MAX_LINE][MAX_ROW];

int CheckWin() //返回0表示都没赢，返回1表示白棋赢，返回2表示黑棋赢

{

int i,j,k;

int tmp;

/ 判断所有横行 /

for(i=0;i<MAX_LINE;i++)

{

for(j=0;j<MAX_ROW-5;j++)

{

tmp=Map[i][j];

if( tmp != 0)

{

for(k=1;k<5;k++)

if(Map[i][j+k] != tmp) / 判断Map[i][j+0]到Map[i][j+4]是否都相等（且不等于0） /

break;

if(k==6)

return tmp;

}

}

}

/ 判断所有纵行 /

for(i=0;i<MAX_LINE-5;i++)

{

for(j=0;j<MAX_ROW;j++)

{

tmp=Map[i][j];

if( tmp != 0)

{

for(k=1;k<5;k++) / 判断Map[i+0][j]到Map[i+4][j]是否都相等（且不等于0） /

if(Map[i+k][j] != tmp)

break;

if(k==6)

return tmp;

}

}

}

/ 判断所有斜行（撇） /

for(i=5;i<MAX_LINE;i++)

{

for(j=0;j<MAX_ROW-5;j++)

{

tmp=Map[i][j];

if( tmp != 0)

{

for(k=1;k<5;k++) / 判断Map[i-0][j+0]到Map[i-4][j+4]是否都相等（且不等于0） /

if(Map[i-k][j+k] != tmp)

break;

if(k==6)

return tmp;

}

}

}

/ 判断所有斜行（捺） /

for(i=0;i<MAX_LINE-5;i++)

{

for(j=0;j<MAX_ROW-5;j++)

{

tmp=Map[i][j];

if( tmp != 0)

{

for(k=1;k<5;k++)

if(Map[i+k][j+k] != tmp) / 判断Map[i+0][j+0]到Map[i+4][j+4]是否都相等（且不等于0） /

break;

if(k==6)

return tmp;

}

}

}

return 0;

}

通过C++语言来实现一个以windows控制台为展示平台的简单版五子棋程序，其中通过键盘输入来控制游戏中的行为(光标移动、落子、确认)。

规则要求某一方在横竖斜方向连续存在五个或五个以上本人所执棋子获得为获胜。当我们要扒一个已存在的程序时(有的是五子棋的程序，可以在互联网里找到很多)。

我们可以从他的UI入手,通过我们所观察到的，所感受到，所使用到的服务，来对软件进行分析，从而获得以上流程，但我们一旦需要将需求变为代码时，我们的设计就要考虑的更多了。

我们可以使用两个int类型的值来表示：白子- 1，黑子- 2，那么我们只要在棋盘中更改光标所在位置元素的值为1或2就可以了。

我们回顾一下光标移动的代码，我们会发现，中进行落子后，我们光标再次移动有可能会改变已记录的落子信息,为了使光标与棋子不冲突，我们使用两个图层，表示两个相同的棋盘。

五子棋C语言代码如下：

#include <stdioh>

#include <biosh>

#include <ctypeh>

#include <conioh>

#include <dosh>

#define CROSSRU 0xbf /右上角点/

#define CROSSLU 0xda /左上角点/

#define CROSSLD 0xc0 /左下角点/

#define CROSSRD 0xd9 /右下角点/

#define CROSSL 0xc3 /左边/

#define CROSSR 0xb4 /右边/

#define CROSSU 0xc2 /上边/

#define CROSSD 0xc1 /下边/

#define CROSS 0xc5 /十字交叉点/

/定义棋盘左上角点在屏幕上的位置/

#define MAPXOFT 5

#define MAPYOFT 2

/定义1号玩家的 *** 作键键码/

#define PLAY1UP 0x1157/上移--'W'/

#define PLAY1DOWN 0x1f53/下移--'S'/

#define PLAY1LEFT 0x1e41/左移--'A'/

#define PLAY1RIGHT 0x2044/右移--'D'/

#define PLAY1DO 0x3920/落子--空格键/

/定义2号玩家的 *** 作键键码/

#define PLAY2UP 0x4800/上移--方向键up/

#define PLAY2DOWN 0x5000/下移--方向键down/

#define PLAY2LEFT 0x4b00/左移--方向键left/

#define PLAY2RIGHT 0x4d00/右移--方向键right/

#define PLAY2DO 0x1c0d/落子--回车键Enter/

/若想在游戏中途退出, 可按 Esc 键/

#define ESCAPE 0x011b

/定义棋盘上交叉点的状态, 即该点有无棋子 /

/若有棋子, 还应能指出是哪个玩家的棋子 /

#define CHESSNULL 0 /没有棋子/

#define CHESS1 'O'/一号玩家的棋子/

#define CHESS2 'X'/二号玩家的棋子/

/定义按键类别/

#define KEYEX99v 0/退出键/

#define KEYFALLCHESS 1/落子键/

#define KEYMOVECURSOR 2/光标移动键/

#define KEYINVALID 3/无效键/

/定义符号常量: 真, 假 --- 真为1, 假为0 /

#define TRUE 1

#define FALSE 0

//

/ 定义数据结构 /

/棋盘交叉点坐标的数据结构/

struct point

{

int x,y;

};

或者下面这个：

#include <graphicsh>

#include <stdlibh>

#include <stdioh>

#include <conioh>

#define N 15

#define B 7

#define STOP -10000

#define OK 1

#define NO 0

#define UP 328

#define DOWN 336

#define LEFT 331

#define RIGHT 333

int a[N+1][N+1];

int zx,zy;

int write=1,biaoji=0;

struct zn{

long sum;

int y;

int x;

}w[N+1][N+1],max,max1;

void cbar(int i,int x,int y,int r);

void map(int a[][]);

int getkey();

int key();

void zuobiao(int x,int y,int i);

int tu(int a[][],int write);

int wtu(int a[][],int write);

int zhineng(int a[][]);

int zh5(int y,int x,int a[][]);

long zzh5(int b[][],int i);

main()

{

int i,j;

int gdriver=DETECT;

int gmode;

initgraph(&gdriver,&gmode,"");

zx=(N+1)/2;

zy=(N+1)/2;

for(i=1;i<=N;i++)

for(j=1;j<=N;j++)

a[i][j]=0;

map(a);

i=1;

while(i)

{

int k,n;

k=wtu(a,write);

if(k==STOP) goto end;

map(a);

n=zhineng(a);

if(n==STOP) goto end;

map(a);

}

end:

;

}

int zhineng(int a[N+1][N+1])

{

int i,j;

int k;

maxsum=-1;

for(i=0;i<=N;i++)

for(j=0;j<+N;j++)

{

w[i][j]sum=0;

w[i][j]x=i;

w[i][j]y=j;

}

for(i=1;i<=N-4;i++)

for(j=1;j<=N-4;j++)

{

k=zh5(i,j,a);

if(k==STOP) return (STOP);

}

for(i=1;i<=N;i++)

for(j=1;j<=N;j++)

{

if(maxsum<w[i][j]sum)

{

maxsum=w[i][j]sum;

maxy=i;

maxx=j;

}

else if(maxsum==w[i][j]sum)

{

if(((maxy-zy)(maxy-zy)+(maxx-zx)(maxx-zx))>((i-zy)(i-zy)+(j-zx)(j-zx)))

maxsum=w[i][j]sum;

maxy=i;

maxx=j;

}

}

if(a[maxy][maxx]==0)

{

a[maxy][maxx]=-1;

zy=maxy;

zx=maxx;

}

}

int zh5(int y,int x,int a[N+1][N+1])

{

int i,j;

int b[6][6];

long c[13];

long d[6][6];

long temp;

for(i=y;i<=y+4;i++)

for(j=x;j<=x+4;j++)

b[i+1-y][j+1-x]=a[i][j];

c[1]=b[1][1]+b[1][2]+b[1][3]+b[1][4]+b[1][5];

c[2]=b[2][1]+b[2][2]+b[2][3]+b[2][4]+b[2][5];

c[3]=b[3][1]+b[3][2]+b[3][3]+b[3][4]+b[3][5];

c[4]=b[4][1]+b[4][2]+b[4][3]+b[4][4]+b[4][5];

c[5]=b[5][1]+b[5][2]+b[5][3]+b[5][4]+b[5][5];

c[6]=b[1][1]+b[2][1]+b[3][1]+b[4][1]+b[5][1];

c[7]=b[1][2]+b[2][2]+b[3][2]+b[4][2]+b[5][2];

c[8]=b[1][3]+b[2][3]+b[3][3]+b[4][3]+b[5][3];

c[9]=b[1][4]+b[2][4]+b[3][4]+b[4][4]+b[5][4];

c[10]=b[1][5]+b[2][5]+b[3][5]+b[4][5]+b[5][5];

c[11]=b[1][1]+b[2][2]+b[3][3]+b[4][4]+b[5][5];

c[12]=b[1][5]+b[2][4]+b[3][3]+b[4][2]+b[5][1];

for(i=1;i<=12;i++)

{

switch(c[i])

{

case 5:biaoji=1;return(STOP);

case -5:biaoji=-1;return(STOP);

case -4:c[i]=100000;break;

case 4:c[i]=100000;break;

case -3:c[i]=150;break;

case 3:c[i]=150;break;

case -2:c[i]=120;break;

case 2:c[i]=100;break;

case -1:c[i]=1;break;

case 1:c[i]=1;break;

default: c[i]=0;

}

}

for(i=1;i<=12;i++)

{

if(c[i]==150)

c[i]+=zzh5(b,i);

}

for(i=1;i<=5;i++)

for(j=1;j<=5;j++)

d[i][j]=0;

for(i=1;i<=5;i++)

for(j=1;j<=5;j++)

{

if(i==j) d[i][j]+=c[11];

if((i+j)==6) d[i][j]+=c[12];

d[i][j]+=c[i]+c[j+5];

}

for(i=1;i<=5;i++)

for(j=1;j<=5;j++)

{

if(b[i][j]!=0)

d[i][j]=-2;

}

max1sum=-1;

max1y=0;

max1x=0;

for(i=1;i<=5;i++)

for(j=1;j<=5;j++)

{

if(max1sum<d[i][j])

{

max1sum=d[i][j];

max1y=i;

max1x=j;

w[i+y-1][j+x-1]sum+=max1sum;

}

else if(max1sum==d[i][j])

{

if(((i+y-1-zy)(i+y-1-zy)+(j+x-1-zx)(j+x-1-zx))>((max1y+y-1-zy)(max1y+y-1-zy)+(max1x+x-1-zx)(max1x+x-1-zx)))

{

max1sum=d[i][j];

max1y=i;

max1x=j;

}

}

}

}

long zzh5(int b[6][6],int n)

{

int i,j,k,l,m;

switch(n)

{

case 1:i=b[1][1];j=b[1][2];k=b[1][3];l=b[1][4];m=b[1][5];break;

case 2:i=b[2][1];j=b[2][2];k=b[2][3];l=b[2][4];m=b[2][5];break;

case 3:i=b[3][1];j=b[3][2];k=b[3][3];l=b[3][4];m=b[3][5];break;

case 4:i=b[4][1];j=b[4][2];k=b[4][3];l=b[4][4];m=b[4][5];break;

case 5:i=b[5][1];j=b[5][2];k=b[5][3];l=b[5][4];m=b[5][5];break;

case 6:i=b[1][1];j=b[2][1];k=b[3][1];l=b[4][1];m=b[5][1];break;

case 7:i=b[1][2];j=b[2][2];k=b[3][2];l=b[4][2];m=b[5][2];break;

case 8:i=b[1][3];j=b[2][3];k=b[3][3];l=b[4][3];m=b[5][3];break;

case 9:i=b[1][4];j=b[2][4];k=b[3][4];l=b[4][4];m=b[5][4];break;

case 10:i=b[1][5];j=b[2][5];k=b[3][5];l=b[4][5];m=b[5][5];break;

case 11:i=b[1][1];j=b[2][2];k=b[3][3];l=b[4][4];m=b[5][5];break;

case 12:i=b[1][5];j=b[2][4];k=b[3][3];l=b[4][2];m=b[5][1];break;

}

if((i==0&&j==1&&k==1&&l==1&&m==0))

return (900);

if((i==0&&j==-1&&k==-1&&l==-1&&m==0))

return(1000);

if((i==0&&j==0&&k==1&&l==1&&m==1)||(i==1&&j==1&&k==1&&l==0&&m==0))

return(20);

if((i==0&&j==0&&k==-1&&l==-1&&m==-1)||(i==-1&&j==-1&&k==-1&&l==0&&m==0))

return(20);

if((i==-1&&j==1&&k==1&&l==1&&m==1)||(i==1&&j==-1&&k==1&&l==1&&m==1)||(i==1&&j==1&&k==-1&&l==1&&m==1)||(i==1&&j==1&&k==1&&l==-1&&m==1)||(i==1&&j==1&&k==1&&l==1&&m==-1))

return(-60);

if((i==1&&j==-1&&k==-1&&l==-1&&m==-1)||(i==-1&&j==1&&k==-1&&l==-1&&m==-1)||(i==-1&&j==1&&k==-1&&l==-1&&m==-1)||(i==-1&&j==-1&&k==-1&&l==1&&m==-1)||(i==-1&&j==-1&&k==-1&&l==-1&&m==1))

return(-60);

}

int wtu(int a[N+1][N+1],int write)

{

int i=1;

map(a);

zuobiao(zx,zy,1);

while(i)

{

int k;

k=tu(a,write);

if(k==OK) i=0;

if(k==STOP) return (STOP);

}

}

int getkey()

{

int key,lo,hi;

key=bioskey(0);

lo=key&0x00ff;

hi=(key&0xff00)>>8;

return((lo==0) hi+256:lo);

}

int key()

{

int k;

k=getkey();

switch(k)

{

case 27: return (STOP);

case 13:

case ' ': return (OK);

case 328: return (UP);

case 336: return (DOWN);

case 331: return (LEFT);

case 333: return (RIGHT);

default: return (NO);

}

}

void zuobiao(int x,int y,int i)

{

int r;

if(i!=0)

{

setcolor(GREEN);

for(r=1;r<=5;r++)

circle(75+25x,25+25y,r);

}

else

{

if(a[zy][zx]==1)

{

setcolor(8);

for(r=1;r<=5;r++)

circle(75+25x,25+25y,r);

}

else if(a[zy][zx]==-1)

{

setcolor(WHITE);

for(r=1;r<=5;r++)

circle(75+25x,25+25y,r);

}

else

{

setcolor(B);

for(r=1;r<=5;r++)

circle(75+25x,25+25y,r);

setcolor(RED); line(75+25zx-5,25+25zy,75+25x+5,25+25zy);

line(75+25zx,25+25zy-5,75+25zx,25+25zy+5);

}

}

}

int tu(int a[N+1][N+1],int write)

{

int k;

re:

k=key();

if(k==OK)

{

if(a[zy][zx]==0)

{

a[zy][zx]=write;

}

else

goto re;

}

if(k==STOP) return(STOP);

if(k==NO) goto re;

if(k==UP)

{

int i,j;

if(zy==1) j=zy;

else j=zy-1;

zuobiao(zx,zy,0);

zuobiao(zx,j,1);

zy=j;

goto re;

}

if(k==DOWN)

{

int i,j;

if(zy==N) j=zy;

else j=zy+1;

zuobiao(zx,zy,0);

zuobiao(zx,j,1);

zy=j;

goto re;

}

if(k==LEFT)

{

int i,j;

if(zx==1) i=zx;

else i=zx-1;

zuobiao(zx,zy,0);

zuobiao(i,zy,1);

zx=i;

goto re;

}

if(k==RIGHT)

{

int i,j;

if(zx==N) i=zx;

else i=zx+1;

zuobiao(zx,zy,0);

zuobiao(i,zy,1);

zx=i;

goto re;

}

}

void cbar(int i,int x,int y,int r)

{

if(i!=0)

{

if(i==1)

setcolor(8);

else if(i==-1)

setcolor(WHITE);

for(i=1;i<=r;i++)

{

circle(x,y,i);

}

}

}

void map(int a[N+1][N+1])

{

int i,j;

cleardevice();

setbkcolor(B);

setcolor(RED);

for(i=0;i<N;i++)

{

line(100,50+25i,75+N25,50+25i);

line(100+25i,50,100+25i,25+N25);

}

for(i=1;i<=N;i++)

for(j=1;j<=N;j++)

cbar(a[i][j],75+25j,25+25i,10);

}

以上就是关于Windows应用程序 C# 五子棋设计全部的内容，包括:Windows应用程序 C# 五子棋设计、java 程序设计、系统框图如下 java实现五子棋程序 可以实现人人对战 人机对战 简单功能 悔棋 认输等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！