16 Java 开发实例——网络五子棋游戏
16 章Java 开发实例——网络五子棋游戏
使用Eclipse 集成开发工具可以方便地开发Java 应用程序，本节就以一个综合实例对前面章节学过的内容进行总结与提升。读完本章后，读者能够清楚地知道使用Eclipse 开发Java应用程序的完整流程。
16.1 Java Socket 编程基础
由于本章采用的实例需要用到Java的Socket 类实现网络通信，首先来介绍一下JavaSocket 编程的基础知识，以便读者能够相对轻松地阅读后面的章节。
16.1.1 Socket 简介
Socket 通常称为“套接字”，它是一个封装了IP 地址和端口通信链的句柄，应用程序通常通过“套接字”向网络发出请求或者应答网络请求。Socket 可以视为两个程序进行的通信连接的端点，一个程序将信息写入Socket 中，该Socket 将信息发送到对方Socket 中，通信另一方的应用程序通过读取Socket 来获取相应得信息。Socket 的通信过程如图16-1 所示。
由图16-1 可以看到，Socket 通信的过程如下。
（1）主机A 上的程序A 将一段信息写入Socket 中，Socket 的内容被主机A 的网络管理软件访问后通过主机A 的网络接口卡发送到主机B 。
（2 ）主机B 的网络接口卡将接收到的信息传送给主机B 的网络管理软件，网络管理软件将这段信息保存在主机B 的Socket 中，然后程序B 在自己的Socket 中阅读这段信息。
16.1.2 Java Socket 的基本类
网络编程的基本模型是客户机/服务器模型，即通常所说的C/S 结构。Java SDK 提供一些API 类来完成客户机Socket 和服务器Socket 的构建与通信，这些类存在于https://www.360docs.net/doc/e518490889.html, 包中。常用的类有Socket 和ServerSocket 类。
（1）Socket 类。当客户程序需要与服务器程序通信的时候，客户程序要在客户机创建一个Socket 对象。Socket 类常用的构造函数是Socket(String host, int port) ，它创建一个基于Socket 的连接服务器流套接字的客户流套接字。如果创建了一个Socket 对象，它可以通过调用Socket 的getInputStream()方法从服务程序获得输入流传送来的信息，也可以通过调用Socket 的getOutputStream()方法获得输出流，来发送消息。在读写活动完成之后，客户程序必须调用close()方法关闭流和流套接字。
（2 ）ServerSocket 类。服务器端有一个专门的ServerSocket 对象，ServerSocket 有几个构造函数，最简单的是ServerSocket(int port) 。服务首先构造一个ServerSocket 对象（port 参数传递的端口号就是服务器监听连接请求的口），创建完成后就开始准备接收连接请求。接下来服务程序进入循环，循环从调用ServerSocket 的accept()方法开始（accept()方法将导致调用线程阻塞直到连接建立），建立连接后accept()返回一个绑定了客户程序的IP 地址或端口号的Socket 对象。由
于存在单个服务程序与多个客户程序通信的可能，解决方法是服务器主机运行一个处理服务程序和客户程序的通信后台线程。
16.2 网络五子棋程序的代码结构详解
本实例是一个简单的网络五子棋程序。程序由两个部分组成：一部分为服务器，另一部分为五子棋客户。其中服务器以消息方式完成客户的管理，客户支持对弈和聊天。实例源代码由com.fivechess.chessface、com.fivechess.client 和com.fivechess.server 3 个包组成。
注意详细注释都写在代码中。
16.2.1 com.fivechess.chessface
此包主要包含与游戏客户界面有关的一些类文件，如chessPad、chatPad、controlPad和inputPad 等。下面分别介绍这几个文件。
1．chatPad
chatPad 类是一个用户界面组件，其本身是一个具有带有滚动条的文本域的Panel，用户的聊天信息和命令的执行结果都将在此文本域上显示。chatPad 的实现代码如实例16-1 所示。
【实例16-1 】chatPad （chatPad.java ）
package com.fivechess.chessface;
import java.awt.BorderLayout;
import java.awt.Panel;
import java.awt.TextArea;
/**
* @author wufenghanren
* 聊天信息Panel。Panel 上的文本域可以显示用户聊天信息
*/
public class chatPad extends Panel {
public TextArea chatLineArea = new TextArea ("", 18, 30,
TextArea.SCROLLBARS_VERTICAL_ONLY);
public chatPad () {
setLayout (new BorderLayout ());
add (chatLineArea, BorderLayout.CENTER);
}
}
2．userPad
chatPad 类也是一个用户界面组件，它是一个带有列表框的Panel，所有的用户名都将显示在列表中。userPad 的实现代码如实例16-2 所示。
【实例16-2 】userPad （userPad.java ）
package com.fivechess.chessface;
import java.awt.*;
/**
* @author wufenghanren
* 用户列表Panel。此Panel 维护一个服务器的当前用户列表
* 所有的用户名都将显示在列表中
*/
public class userPad extends Panel {
public List userList = new List (10);
public userPad () {
setLayout (new BorderLayout ());
for (int i = 0; i < 30; i++) {
userList.add (i + "." + "当前暂无用户");
}
add (userList, BorderLayout.CENTER);
}
}
3．inputPad
inputPad 类的Panel 左边的下拉列表中可以列出所有用户的名字，右边的文本框中可以输入想要发送的消息，点击回车，信息被发送。此外，在文本框中还可以使用简单的命令，如changename （用于改变用户名）、list （用于更新用户列表）。inputPad 的实现代码如实例16-3 所示。
【实例16-3 】inputPad （inputPad.java ）
package com.fivechess.chessface;
import java.awt.Choice;
import java.awt.Color;
import java.awt.FlowLayout;
import https://www.360docs.net/doc/e518490889.html,bel;
import java.awt.Panel;
import java.awt.TextField;
/**
* @author wufenghanren
* 输入信息Panel。Panel 左边的下拉列表中列出了所有用户的名字
* 右边的文本框可以输入聊天信息，点击回车信息被发送
* 此外还可以在文本框中输入命令如changename、list等
*/
public class inputPad extends Panel {
public TextField inputWords = new TextField("点击回车发送信息", 20);
public Choice userChoice = new Choice ();
public Label chatLabel = new Label("输入发送信息:");
public inputPad () {
setLayout (new FlowLayout (FlowLayout.LEFT));
setBackground (new Color (204, 204, 204));
for (int i = 0; i < 30; i++) {
userChoice.addItem (i + "." + "当前暂无用户");
}
userChoice.setSize (60, 24);
add (userChoice);
add (chatLabel);
add (inputWords);
}
}
4．controlPad
controlPad 类的Panel 上包含整个客户的控制按钮，如“连接主机”、“建立游戏”、“加入游戏”和“选择界面颜色”等。点击这些按钮会完成相应的能。controlPad的实现代码如实例16-4 所示。
【实例16-4 】controlPad （controlPad.java ）
package com.fivechess.chessface;
import java.awt.Button;
import java.awt.Color;
import java.awt.FlowLayout;
import https://www.360docs.net/doc/e518490889.html,bel;
import java.awt.Panel;
import java.awt.TextField;
/**
* @author wufenghanren
* 控制Panel。此Panel 上的按钮如其名，完成相应的能
*/
public class controlPad extends Panel {
public Label IPlabel = new Label("服务器IP:", Label.LEFT);
public TextField inputIP = new TextField ("localhost", 10);
public Button connectButton = new Button ("连接主机");
public Button creatGameButton = new Button ("建立游戏");
public Button joinGameButton = new Button ("加入游戏");
public Button cancelGameButton = new Button("放弃游戏");
public Button colorChangeButton = new Button ("选择界面颜色");
public Button exitGameButton = new Button ("关闭程序");
//构造函数，负责Panel 的初始布局
public controlPad () {
setLayout (new FlowLayout (FlowLayout.LEFT));
setBackground (new Color (204,204,204));
add (IPlabel);
add (inputIP);
add (connectButton);
add (creatGameButton);
add (joinGameButton);
add (cancelGameButton);
add (colorChangeButton);
add (exitGameButton);
}
}
5．chessPad
几个界面组件中最复杂的是chessPad，它不仅仅是一个包含棋盘和棋子的Panel，除此之外还
要完成绘制棋子、保存处理落子后棋子的位置信息、判断棋局胜负和对棋局终了时进行棋盘的重新清理和初始化等操作。chessPad 包含了3 个类：一个是绘制棋盘的Panel、一个表示黑子的类，一个表示白子的类。chessPad 的实现代码如实例16-5 所示。
【实例16-5 】chessPad （chessPad.java ）
package com.fivechess.chessface;
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import https://www.360docs.net/doc/e518490889.html,.*;
/**
* @author wufenghanren
* 显示棋盘的Panel。此Panel 实现了鼠标监听器
*/
public class chessPad extends Panel implements MouseListener {
public int chessPoint_x = -1, chessPoint_y = -1, chessColor = 1;
int chessBlack_x [] = new int[200];//黑子的x 坐标
int chessBlack_y[] = new int[200];//黑子的y 坐标
int chessWhite_x [] = new int[200];//白子的x 坐标
int chessWhite_y[] = new int[200];//白子的y 坐标
int chessBlackCount = 0, chessWhiteCount = 0;
int chessBlackWin = 0, chessWhiteWin = 0;
public boolean isMouseEnabled = false, isWin = false, isInGame = false;
public Label statusLabel = new Label("客户状态");
public TextField statusText = new TextField("请先连接服务器");
//显示客户状态的文本框
public Socket chessSocket;
DataInputStream inData;
DataOutputStream outData;
public String chessSelfName = null;//己方的名字
public String chessPeerName = null;//对方的名字
public String host = null;
public int port = 4331;
public chessThread chessthread = new chessThread (this);
/**
* 棋盘Panel 的构造函数
*/
public chessPad () {
setSize (440, 440);
setLayout (null);
setBackground (new Color (204, 204, 204));
addMouseListener(this);
add (statusLabel);
statusLabel.setBounds(30, 5, 70, 24);
add (statusText);
statusText.setBounds(100, 5, 300, 24);
statusText.setEditable (false);
}
/**
* 和服务器通信的函数
*/
public boolean connectServer(String ServerIP, int ServerPort)
throws Exception {
try {
//利用参数创建一个Socket 的实例来完成和服务器之间的信息交换
chessSocket = new Socket (ServerIP, ServerPort);
inData = new DataInputStream (chessSocket.getInputStream ());
outData = new DataOutputStream (chessSocket.getOutputStream ());
chessthread.start ();
return true;
} catch (IOException ex) {
statusText.setText ("chessPad:connectServer:无法连接\n");
}
return false;
}
/**
* 一方获胜时对棋局的处理
*/
public void chessVictory (int chessColorWin) {
//清除所有的棋子
this.removeAll();
//将保存所有黑棋和白棋的位置坐标的数组清空，为下一盘棋做准备
for (int i = 0; i <= chessBlackCount; i++) {
chessBlack_x [i] = 0;
chessBlack_y[i] = 0;
}
for (int i = 0; i <= chessWhiteCount; i++) {
chessWhite_x [i] = 0;
chessWhite_y[i] = 0;
}
chessBlackCount = 0;
chessWhiteCount = 0;
add (statusText);
statusText.setBounds(40, 5, 360, 24);
//如果黑棋获胜，计算双方获胜盘数，将双方的战绩在状态文本框中显示出来if (chessColorWin == 1) {
chessBlackWin++;
statusText.setText ("黑棋胜,黑:白为" + chessBlackWin + ":" + chessWhiteWin + ",重新开局,等待白棋下子...");
}
//白棋获胜，同上
else if (chessColorWin == -1) {
chessWhiteWin++;
statusText.setText ("白棋胜,黑:白为" + chessBlackWin + ":" + chessWhiteWin + ",重新开局,等待黑棋下子...");
}
}
/**
* 将各个棋子的坐标保存在数组里
*/
public void getLocation (int a, int b, int color) {
if (color == 1) {
chessBlack_x [chessBlackCount] = a * 20;
chessBlack_y[chessBlackCount] = b * 20;
chessBlackCount++;
} else if (color == -1) {
chessWhite_x [chessWhiteCount] = a * 20;
chessWhite_y[chessWhiteCount] = b * 20;
chessWhiteCount++;
}
}
/**
* 依据五子棋的行棋规则判断某方获胜
*/
public boolean checkWin (int a, int b, int checkColor) {
int step = 1, chessLink = 1, chessLinkTest = 1, chessCompare = 0;
if (checkColor == 1) {
chessLink = 1;
for (step = 1; step <= 4; step++) {
for (chessCompare = 0; chessCompare <= chessBlackCount; chessCompare++) {
if (((a + step) * 20 == chessBlack_x [chessCompare])
&& ((b * 20) == chessBlack_y [chessCompare])) {
chessLink = chessLink + 1;
if (chessLink == 5) {
return (true);
}
}
}
if (chessLink == (chessLinkTest + 1))
chessLinkTest++;
else
break;
}
for (step = 1; step <= 4; step++) {
for (chessCompare = 0; chessCompare <= chessBlackCount; chessCompare++) {
if (((a - step) * 20 == chessBlack_x [chessCompare])
&& (b * 20 == chessBlack_y [chessCompare])) {
chessLink++;
if (chessLink == 5) {
return (true);
}
}
}
if (chessLink == (chessLinkTest + 1))
chessLinkTest++;
else
break;
}
chessLink = 1;
chessLinkTest = 1;
for (step = 1; step <= 4; step++) {
for (chessCompare = 0; chessCompare <= chessBlackCount; chessCompare++) {
if ((a * 20 == chessBlack_x [chessCompare])
&& ((b + step) * 20 == chessBlack_y [chessCompare]))
chessLink++;
if (chessLink == 5) {
return (true);
}
}
}
if (chessLink == (chessLinkTest + 1))
chessLinkTest++;
else
break;
}
for (step = 1; step <= 4; step++) {
for (chessCompare = 0; chessCompare <= chessBlackCount; chessCompare++) {
if ((a * 20 == chessBlack_x [chessCompare])
&& ((b - step) * 20 == chessBlack_y [chessCompare])) {
chessLink++;
if (chessLink == 5) {
return (true);
}
}
}
if (chessLink == (chessLinkTest + 1))
chessLinkTest++;
else
break;
}
chessLink = 1;
chessLinkTest = 1;
for (step = 1; step <= 4; step++) {
for (chessCompare = 0; chessCompare <= chessBlackCount; chessCompare++) {
if (((a - step) * 20 == chessBlack_x [chessCompare])
&& ((b + step) * 20 == chessBlack_y[chessCompare])) {
chessLink++;
if (chessLink == 5) {
return (true);
}
}
}
if (chessLink == (chessLinkTest + 1))
chessLinkTest++;
else
break;
}
for (step = 1; step <= 4; step++) {
for (chessCompare = 0; chessCompare <= chessBlackCount; chessCompare++) {
if (((a + step) * 20 == chessBlack_x [chessCompare])
&& ((b - step) * 20 == chessBlack_y [chessCompare])) {
chessLink++;
if (chessLink == 5) {
return (true);
}
}
}
if (chessLink == (chessLinkTest + 1))
chessLinkTest++;
else
break;
}
chessLink = 1;
chessLinkTest = 1;
for (step = 1; step <= 4; step++) {
for (chessCompare = 0; chessCompare <= chessBlackCount; chessCompare++) {
if (((a + step) * 20 == chessBlack_x [chessCompare])
&& ((b + step) * 20 == chessBlack_y [chessCompare])) {
chessLink++;
if (chessLink == 5) {
return (true);
}
}
}
if (chessLink == (chessLinkTest + 1))
chessLinkTest++;
else
break;
}
for (step = 1; step <= 4; step++) {
for (chessCompare = 0; chessCompare <= chessBlackCount; chessCompare++) {
if (((a - step) * 20 == chessBlack_x [chessCompare])
&& ((b - step) * 20 == chessBlack_y [chessCompare])) {
chessLink++;
if (chessLink == 5) {
return (true);
}
}
}
if (chessLink == (chessLinkTest + 1))
chessLinkTest++;
else
break;
}
} else if (checkColor == -1) {
chessLink = 1;
for (step = 1; step <= 4; step++) {
for (chessCompare = 0; chessCompare <= chessWhiteCount; chessCompare++) {
if (((a + step) * 20 == chessWhite_x [chessCompare])
&& (b * 20 == chessWhite_y [chessCompare])) {
chessLink++;
if (chessLink == 5) {
return (true);
}
}
}
if (chessLink == (chessLinkTest + 1))
chessLinkTest++;
else
break;
}
for (step = 1; step <= 4; step++) {
for (chessCompare = 0; chessCompare <= chessWhiteCount; chessCompare++) {
if (((a - step) * 20 == chessWhite_x [chessCompare])
&& (b * 20 == chessWhite_y[chessCompare])) {
chessLink++;
if (chessLink == 5) {
return (true);
}
}
}
if (chessLink == (chessLinkTest + 1))
chessLinkTest++;
else
break;
}
chessLink = 1;
chessLinkTest = 1;
for (step = 1; step <= 4; step++) {
for (chessCompare = 0; chessCompare <= chessWhiteCount; chessCompare++) {
if ((a * 20 == chessWhite_x [chessCompare])
&& ((b + step) * 20 == chessWhite_y[chessCompare])) {
chessLink++;
if (chessLink == 5) {
return (true);
}
}
}
if (chessLink == (chessLinkTest + 1))
chessLinkTest++;
else
break;
}
for (step = 1; step <= 4; step++) {
for (chessCompare = 0; chessCompare <= chessWhiteCount; chessCompare++) {
if ((a * 20 == chessWhite_x [chessCompare])
&& ((b - step) * 20 == chessWhite_y[chessCompare])) {
chessLink++;
if (chessLink == 5) {
return (true);
}
}
}
if (chessLink == (chessLinkTest + 1))
chessLinkTest++;
else
break;
}
chessLink = 1;
chessLinkTest = 1;
for (step = 1; step <= 4; step++) {
for (chessCompare = 0; chessCompare <= chessWhiteCount; chessCompare++) {
if (((a - step) * 20 == chessWhite_x [chessCompare])
&& ((b + step) * 20 == chessWhite_y[chessCompare])) {
chessLink++;
if (chessLink == 5) {
return (true);
}
}
}
if (chessLink == (chessLinkTest + 1))
chessLinkTest++;
else
break;
}
for (step = 1; step <= 4; step++) {
for (chessCompare = 0; chessCompare <= chessWhiteCount; chessCompare++) {
if (((a + step) * 20 == chessWhite_x [chessCompare])
&& ((b - step) * 20 == chessWhite_y[chessCompare])) {
chessLink++;
if (chessLink == 5) {
return (true);
}
}
}
if (chessLink == (chessLinkTest + 1))
chessLinkTest++;
else
break;
}
chessLink = 1;
chessLinkTest = 1;
for (step = 1; step <= 4; step++) {
for (chessCompare = 0; chessCompare <= chessWhiteCount; chessCompare++) {
if (((a + step) * 20 == chessWhite_x [chessCompare])
&& ((b + step) * 20 == chessWhite_y[chessCompare])) {
chessLink++;
if (chessLink == 5) {
return (true);
}
}
}
if (chessLink == (chessLinkTest + 1))
chessLinkTest++;
else
break;
}
for (step = 1; step <= 4; step++) {
for (chessCompare = 0; chessCompare <= chessWhiteCount; chessCompare++) {
if (((a - step) * 20 == chessWhite_x [chessCompare])
&& ((b - step) * 20 == chessWhite_y[chessCompare])) {
chessLink++;
if (chessLink == 5) {
return (true);
}
}
}
if (chessLink == (chessLinkTest + 1))
chessLinkTest++;
else
break;
}
}
return (false);
}
/**
* 绘制棋盘，将棋盘绘制成19*19 的格子，并将棋盘上应有的5个点绘制上去*/
public void paint (Graphics g) {
for (int i = 40; i <= 380; i = i + 20) {
g.drawLine (40, i, 400, i);
}
g.drawLine (40, 400, 400, 400);
for (int j = 40; j <= 380; j = j + 20) {
g.drawLine (j, 40, j, 400);
}
g.drawLine (400, 40, 400, 400);
g.fillOval(97, 97, 6, 6);
g.fillOval(337, 97, 6, 6);
g.fillOval(97, 337, 6, 6);
g.fillOval(337, 337, 6, 6);
g.fillOval(217, 217, 6, 6);
}
/**
* 落子的时候绘制棋子
*/
public void chessPaint (int chessPoint_a, int chessPoint_b, int color) { chessPoint_black chesspoint_black = new chessPoint_black (this); chessPoint_white chesspoint_white = new chessPoint_white (this);
if (color == 1 && isMouseEnabled) {
//当黑子落子时，记下此子的位置
getLocation (chessPoint_a, chessPoint_b, color);
//判断是否获胜
isWin = checkWin (chessPoint_a, chessPoint_b, color);
if (isWin == false) {
//如果没有获胜，向对方发送落子信息，并绘制棋子
chessthread.sendMessage ("/" + chessPeerName + " /chess "
+ chessPoint_a + " " + chessPoint_b + " " + color);
this.add (chesspoint_black);
chesspoint_black.setBounds(chessPoint_a * 20 - 7,
chessPoint_b * 20 - 7, 16, 16);
//在状态文本框显示行棋信息
statusText.setText ("黑(第" + chessBlackCount + "步)"
+ chessPoint_a + " " + chessPoint_b + ",请白棋下子");
isMouseEnabled = false;
} else {
//如果获胜，直接调用chessVictory 完成后续工作
chessthread.sendMessage ("/" + chessPeerName + " /chess "
+ chessPoint_a + " " + chessPoint_b + " " + color);
this.add (chesspoint_black);
chesspoint_black.setBounds(chessPoint_a * 20 - 7,
chessPoint_b * 20 - 7, 16, 16);
chessVictory (1);
isMouseEnabled = false;
}
}
//白棋落子，同黑棋类似处理
else if (color == -1 && isMouseEnabled) {
getLocation (chessPoint_a, chessPoint_b, color);
isWin = checkWin (chessPoint_a, chessPoint_b, color);
if (isWin == false) {
chessthread.sendMessage ("/" + chessPeerName + " /chess "
+ chessPoint_a + " " + chessPoint_b + " " + color);
this.add (chesspoint_white);
chesspoint_white.setBounds(chessPoint_a * 20 - 7,
chessPoint_b * 20 - 7, 16, 16);
statusText.setText ("白(第" + chessWhiteCount + "步)"
+ chessPoint_a + " " + chessPoint_b + ",请黑棋下子");
isMouseEnabled = false;
} else {
chessthread.sendMessage ("/" + chessPeerName + " /chess "
+ chessPoint_a + " " + chessPoint_b + " " + color);
this.add (chesspoint_white);
chesspoint_white.setBounds(chessPoint_a * 20 - 7,
chessPoint_b * 20 - 7, 16, 16);
chessVictory (-1);
isMouseEnabled = false;
}
}
}
/**
* 落子时在对方客户绘制棋子。对方接收到发送来的落子信息，调用此函数绘制棋子，显示落
子状态等
*/
public void netChessPaint (int chessPoint_a, int chessPoint_b, int color) {
chessPoint_black chesspoint_black = new chessPoint_black (this);
chessPoint_white chesspoint_white = new chessPoint_white (this);
getLocation (chessPoint_a, chessPoint_b, color);
if (color == 1) {
isWin = checkWin (chessPoint_a, chessPoint_b, color);
if (isWin == false) {
this.add (chesspoint_black);
chesspoint_black.setBounds(chessPoint_a * 20 - 7,
chessPoint_b * 20 - 7, 16, 16);
statusText.setText ("黑(第" + chessBlackCount + "步)"
+ chessPoint_a + " " + chessPoint_b + ",请白棋下子");
isMouseEnabled = true;
} else {
this.add (chesspoint_black);
chesspoint_black.setBounds(chessPoint_a * 20 - 7,
chessPoint_b * 20 - 7, 16, 16);
chessVictory (1);
isMouseEnabled = true;
}
} else if (color == -1) {
isWin = checkWin (chessPoint_a, chessPoint_b, color);
if (isWin == false) {
this.add (chesspoint_white);
chesspoint_white.setBounds(chessPoint_a * 20 - 7,
chessPoint_b * 20 - 7, 16, 16);
statusText.setText ("白(第" + chessWhiteCount + "步)"
+ chessPoint_a + " " + chessPoint_b + ",请黑棋下子");
isMouseEnabled = true;
} else {
chessthread.sendMessage ("/" + chessPeerName + " /victory "
+ color);
this.add (chesspoint_white);
chesspoint_white.setBounds(chessPoint_a * 20 - 7,
chessPoint_b * 20 - 7, 16, 16);
chessVictory (-1);
isMouseEnabled = true;
}
}
}
/**
* 当鼠标按下时响应的动作。记下当前鼠标点击的位置，即当前落子的位置*/
public void mousePressed (MouseEvent e) {
if (e.getModifiers() == InputEvent.BUTTON1_MASK) {
chessPoint_x = (int) e.getX ();
chessPoint_y = (int) e.getY ();
int a = (chessPoint_x + 10) / 20, b = (chessPoint_y + 10) / 20;
if (chessPoint_x / 20 < 2 || chessPoint_y / 20 < 2
|| chessPoint_x / 20 > 19 || chessPoint_y / 20 > 19) {
} else {
chessPaint (a, b, chessColor);
}
}
}
public void mouseReleased (MouseEvent e) {
}
public void mouseEntered (MouseEvent e) {
}
public void mouseExited (MouseEvent e) {
}
public void mouseClicked (MouseEvent e) {
}
}
/**
* 表示黑子的类
*/
class chessPoint_black extends Canvas {
chessPad chesspad = null;
chessPoint_black(chessPad p) {
setSize (20, 20);
chesspad = p;
}
public void paint (Graphics g) {
g.setColor(Color.black);
g.fillOval(0, 0, 14, 14);
}
}
/**
* 表示白子的类
*/
class chessPoint_white extends Canvas {
chessPad chesspad = null;
chessPoint_white (chessPad p) {
setSize (20, 20);
chesspad = p;
}
public void paint (Graphics g) {
g.setColor(Color.white);
g.fillOval(0, 0, 14, 14);
}
}
6．chessThread
除了上述几个用户界面类以外，com.fivechess.chessface 包还包含了一个用于和对弈方通信的线程类chessTread，此线程将自己的落子信息发送给对弈方，对方棋盘上也能看到同样的落子。线程只包含发送消息和接收消息的方法。ChessTread 的实现代码如实例16-6 所示。
【实例16-6 】chessTread （chessTread.java ）
package com.fivechess.chessface;
import java.io.IOException;
import java.util.StringTokenizer;
/**
* @author wufenghanren
*/
public class chessThread extends Thread {
chessPad chesspad;
public chessThread (chessPad chesspad) {
this.chesspad = chesspad;
}
/**
* 发送消息
*/
public void sendMessage (String sndMessage) {
try {
chesspad.outData.writeUTF (sndMessage);
} catch (Exception ea) {
System.out.println ("chessThread.sendMessage:" + ea);
}
}
/**
* 接收消息
*/
public void acceptMessage (String recMessage) {
//如果收到的消息以“/chess”开头，将其中的坐标信息和颜色信息提取出来
if (recMessage.startsWith ("/chess ")) {
StringTokenizer userToken = new StringTokenizer (recMessage, " ");
String chessToken;
String[] chessOpt = { "-1", "-1", "0" };
int chessOptNum = 0;
//使用Tokenizer将空格分隔的字符串分成3段
while (userToken.hasMoreTokens()) {
chessToken = (String) userToken.nextToken (" ");
if (chessOptNum >= 1 && chessOptNum <= 3) {
chessOpt [chessOptNum - 1] = chessToken;
}
chessOptNum++;
}
//将己方的走棋信息如棋子摆放的位置、棋子的颜色作为参数使用netChessPaint 函数对方客户也看到己方的落子位置
https://www.360docs.net/doc/e518490889.html,ChessPaint (Integer.parseInt (chessOpt[0]), Integer
.parseInt (chessOpt[1]), Integer.parseInt (chessOpt [2]));
} else if (recMessage.startsWith ("/yourname ")) {
chesspad.chessSelfName = recMessage.substring (10);
} else if (recMessage.equals("/error")) {
chesspad.statusText.setText ("错误:没有这个用户，请退出程序，重新加入");
}
}
public void run () {
String message = "";
try {
while (true) {
message = chesspad.inData.readUTF ();
acceptMessage (message);
}
} catch (IOException es) {
}
}
}
16.2.2 com.fivechess. client
com.fivechess.client 包只包含一个.j ava 文件，即chessClient.j ava 。文件包含两个类，一个
为chessClient 类，另一个为clientThread 类。
1．chessClient
chessClient 类用来整合com.fivechess.chessface 的几个Panel，以组成一个完整的客户，
此客户能够响应controlPanel 上的按钮的动作。chessClient 类的实现代码如实例16-7 所示。
【实例16-7 】chessClient （chessClient.java ）
package com.fivechess.client;
import com .fivechess.chessface.chatPad;
import com .fivechess.chessface.inputPad;
import com https://www.360docs.net/doc/e518490889.html,erPad;
import com .fivechess.chessface.chessPad;
import com .fivechess.chessface.controlPad;
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import https://www.360docs.net/doc/e518490889.html,.*;
import java.util.*;
import javax.swing.JColorChooser;
/**
* @author wufenghanren
* 五子棋客户框架，实现了动作监听器和键盘监听器
*/
public class chessClient extends Frame implements ActionListener, KeyListener { userPad userpad = new userPad ();//用户列表Panel
chatPad chatpad = new chatPad ();//聊天信息Panel
controlPad controlpad = new controlPad ();//控制Panel
chessPad chesspad = new chessPad ();//棋盘Panel
inputPad inputpad = new inputPad ();//信息输入Panel
Socket chatSocket;
DataInputStream in;
DataOutputStream out;
String chessClientName = null;
String host = null;
int port = 4331;
boolean isOnChat = false; //是否在聊天
boolean isOnChess = false; //是否在下棋
boolean isGameConnected = false; //是否连接下棋的客户
boolean isServer = false; //是否建立游戏的主机
boolean isClient = false; //是否加入游戏的客户
Panel southPanel = new Panel ();
Panel centerPanel = new Panel();
Panel westPanel = new Panel();
/*
* 五子棋客户框架的构造函数。用来初始化一些对象、布局和为按钮添加监听器
*/
public chessClient () {
super("五子棋客户");
setLayout (new BorderLayout ());
host = controlpad.inputIP.getText ();
westPanel.setLayout (new BorderLayout ());
westPanel.add (userpad, BorderLayout.NORTH);
westPanel.add (chatpad, BorderLayout.CENTER);
westPanel.setBackground (new Color(204, 204, 204));
inputpad.inputWords.addKeyListener (this);
chesspad.host = controlpad.inputIP.getText ();
centerPanel.add (chesspad, BorderLayout.CENTER);
centerPanel.add (inputpad, BorderLayout.SOUTH);
centerPanel.setBackground (new Color(204, 204, 204));
controlpad.connectButton.addActionListener (this);
controlpad.creatGameButton.addActionListener (this);
controlpad.joinGameButton.addActionListener(this);
controlpad.cancelGameButton.addActionListener(this);
controlpad.colorChangeButton.addActionListener (this);
controlpad.exitGameButton.addActionListener(this);
controlpad.creatGameButton.setEnabled(false);
controlpad.joinGameButton.setEnabled (false);
controlpad.cancelGameButton.setEnabled (false);
southPanel.add (controlpad, BorderLayout.CENTER);
southPanel.setBackground (new Color (204, 204, 204));
//添加窗口监听器，当窗口关闭时，关闭用于通信的Socket addWindowListener(new WindowAdapter() {
public void windowClosing (WindowEvent e) {
if (isOnChat) {
try {
chatSocket.close ();
} catch (Exception ed) {
}
}
if (isOnChess || isGameConnected) {
try {
chesspad.chessSocket.close ();
} catch (Exception ee) {
}
}
System .exit (0);
}
});
add (westPanel, BorderLayout.WEST);
add (centerPanel, BorderLayout.CENTER);
add (southPanel, BorderLayout.SOUTH);
setSize (670, 548);
目录 一、摘要： (1) 二、关键字： (1) 三、程序主流程图 (2) 四、需求分析： (3) 五、关键部分设计算法及实现： (4) 六、文件清单： (9) 七、使用说明： (9) 八、参考书目： (10) 九、附录：（源代码清单） (11) 五子棋程序 一、摘要：
五子棋游戏是一历史悠久，对抗性强，技巧性高的棋类游戏。本文用VC 设计了五子棋游戏。并就以下问题进行了探讨： （1）棋子棋盘在程序中的表示； （2）如何通过鼠标点击落子； （3）如何判断输赢，在棋盘的—，|，/，\，四个方向进行搜索，超过5子以上连成一线则认为赢了。 （4）如何实现梅棋功能。 （5）如何保存并读入棋谱； （6）如何让电脑拥有人类的智慧； （7）编写软件代码应遵守的编写规范，成对编码原则和代码的注释; （8）其它未详尽处，请参看源代码。 二、关键字： 棋盘数组 搜索算法 人工智能 活 半活 双活三
三、程序主要类结构图
CfiveStoneApp
四、需求分析： 五子棋历史源远流长，发展形势喜人，以下在网络上一篇有关五子棋历史发展的报道： 五子棋是起源于中国古代的传统黑白棋种之一。现代五子棋日文称之为“連珠”，英译为“Renju”，英文称之为“Gobang”或“FIR”(Five in a Row的缩写)，亦有“连五子”、“五子连”、“串珠”、“五目”、“五目碰”、“五格”等多种称谓。?五子棋不仅能增强思维能力，提高智力，而且富含哲理，有助于修身养性。五子棋既有现代休闲的明显特征“短、平、快”，又有古典哲学的高深学问“阴阳易理”；它既有简单易学的特性，为人民群众所喜闻乐见，又有深奥的技巧和高水平的国际性比赛；它的棋文化源渊流长，具有东方的神秘和西方的直观；既有“场”的概念，亦有“点”的连接。它是中西文化的交流点，是古今哲理的结晶。? 五子棋起源于古代中国，发展于日本，风靡于欧洲。对于它与围棋的关系有两种说法，一说早于围棋，早在“尧造围棋”之前，民间就已有五子棋游戏；一说源于围棋，是围棋发展的一个分支。在中国的文化里，倍受人们的青睐。古代的五子棋的棋具与围棋相同，纵横各十七道。五子棋大约随围棋一起在我国南北朝时先后传入朝鲜、日本等地。据日本史料文献介绍，中国古代的五子棋是经由高丽(朝鲜)，于1688年至1704年的日本元禄时代传到日本的。到日本明治32年(公元1899年)，经过公开征名，“连珠”这一名称才被正式确定下来，取意于“日月如合壁，五星如连珠”。从此，连珠活动经过了不断的改良，主要是规则的变化(即对执黑棋一方的限制)，例如，1899年规定，禁止黑白双方走“双三”；1903年规定，只禁止黑方走“双三”；1912年规定，黑方被迫走“双三”亦算输；1916年规定，黑方不许走“长连”；1918年规定，黑方不许走“四、三、三”；1931年规定，黑方不许走“双四”，并规定将19×19的围棋盘改为15×15的连珠专用棋盘。本世纪初五子棋传入欧洲并迅速风靡全欧。通过一系列的变化，使五子棋这一简单的游戏复杂化、规范化，而最终成为今天的职业连珠五子棋，同时也成为一种国际比赛棋。? 目前，职业连珠已迅速在国际上发展起来。1988年8月8日，国际连珠联盟(RIF)由日本、俄罗斯、瑞典、亚美尼亚、阿塞拜疆、爱沙尼亚、法国、拉脱维亚、白俄罗斯等9个成员国在瑞典宣告创立，我国于1996年正式加入国际连珠联盟，现在全世界已有47个国家和地区成为国际连珠联盟的正式会员。职业连珠的世界锦标赛从1989年起每两年举办一次，现已举办了六届，第三、五、六届的冠军是爱沙尼亚人，其余三届的冠军都是日本人。我国最好成绩是团体第七，个人张进宇第9名。就水平而言，目前以俄罗斯、日本、瑞典最强，其中日本研究也最深，我国只处于中等水平。日本拥有自己的五子棋职业棋手，并且对连珠技术的研究也相当普遍和全面。日本每年举行连珠名人战。? 五子棋的根在中国，有着广泛的群众基础。但与世界先进的五子棋技术相比，我们的棋艺水平还很低，所以我们要推广五子棋，宣传五子棋，争取在较短的时间内赶上和超过世界五子棋坛的先进水平。1990年，由那威和十几名五子棋爱好者，共同发起并成立了中国第一个现代职业五子棋的民间组织----京都五子棋队，现已发展成为拥有百余名选手的北京京都五子棋队。日本连珠联盟曾多次派代表团访问中国，与中国广大爱好者进行交流和友谊比赛，瑞典连珠联盟也于1995年派代表团访问了中国，京都五子棋队曾两次选派选手代表中国参加世界杯比赛，取得此成绩反映了我国五子棋水平在世界上所处的位置，同时也显示了我国在此项运动中的发展潜力。1997年5月北京成功地举办了第一届“康柏杯”
//Java编程：五子棋游戏源代码 import java.awt.*; import java.awt.event.*; import java.applet.*; import javax.swing.*; import java.io.PrintStream; import javax.swing.JComponent; import javax.swing.JPanel; /* *main方法创建了ChessFrame类的一个实例对象（cf）， *并启动屏幕显示显示该实例对象。 **/ public class FiveChessAppletDemo { public static void main(String args[]){ ChessFrame cf = new ChessFrame(); cf.show(); } } /* *类ChessFrame主要功能是创建五子棋游戏主窗体和菜单**/ class ChessFrame extends JFrame implements ActionListener { private String[] strsize={"20x15","30x20","40x30"}; private String[] strmode={"人机对弈","人人对弈"}; public static boolean iscomputer=true,checkcomputer=true; private int width,height; private ChessModel cm; private MainPanel mp; //构造五子棋游戏的主窗体 public ChessFrame() { this.setTitle("五子棋游戏"); cm=new ChessModel(1); mp=new MainPanel(cm); Container con=this.getContentPane(); con.add(mp,"Center"); this.setResizable(false); this.addWindowListener(new ChessWindowEvent()); MapSize(20,15); JMenuBar mbar = new JMenuBar(); this.setJMenuBar(mbar); JMenu gameMenu = new JMenu("游戏");
分类号： U D C：D10621-408-(2007)5738-0 密级：公开编号：21 成都信息工程学院 学位论文 基于Java的五子棋游戏的设计 论文作者姓名：赵小龙 申请学位类别：计算机科学与技术 申请学位类别：工学学士 指导教师姓名（职称）：吴春旺 论文提交日期：2007年06月10日
基于Java的五子棋游戏的设计 摘要 五子棋作为一个棋类竞技运动，在民间十分流行，为了熟悉五子棋规则及技巧，以及研究简单的人工智能，决定用Java开发五子棋游戏。主要完成了人机对战和玩家之间联网对战2个功能。网络连接部分为Socket编程应用，客户端和服务器端的交互用Class Message定义，有很好的可扩展性，客户端负责界面维护和收集用户输入的信息，及错误处理。服务器维护在线用户的基本信息和任意两个对战用户的棋盘信息，动态维护用户列表。在人机对弈中通过深度搜索和估值模块，来提高电脑棋手的智能。分析估值模块中的影响精准性的几个要素，以及提出若干提高精准性的办法，以及对它们搜索的节点数进行比较，在这些算法的基础上分析一些提高电脑AI方案，如递归算法、电脑学习等。算法的研究有助于理解程序结构，增强逻辑思维能力，在其他人工智能方面也有很大的参考作用。 关键词：深度搜索；估值；电脑AI；五子棋；算法
Gobang Java-based games design Abstract As a sport, gobang is very popular in civil, in order to become familiar with gobang rules and techniques, and the study of simple artificial intelligence, I decide to use the Java to develope gobang games and complete the two functions including man-machine war and man-man war. Network Connection is Socket Programming for some applications, client and server interaction is definited by Class Message, which is a very good scalability, Client interface is responsible for the collection and maintenance of user input information, and error handling. Server users maintain online basic information and arbitrary two-time users of the chessboard of information, dynamic maintenance user list. During the man-machine players, it improves intelligence of the computer players through depth search and valuation module. Analyzes Module valuation of the precise elements, as well as a number of increased precision, and compares their search for nodes, which raises some computer AI programs on the basis of analysis, such as recursive algorithm, computer learning. Algorithm of procedures contribute to the understanding of the structure, logical thinking ability, In other areas of artificial intelligence has great references. . Key words:Search depth; Valuation; Computer AI; Gobang ; Algorithm
基于JAVA的五子棋游戏系统设计与实 现
基于JAVA的五子棋游戏系统设计与实现专业电子信息工程 学生董永杰 指导教师曾玉
摘要 当前，随着计算机网络的的发展，以计算机技术和网络技术为核心的现代网络技术已经在现实生活和生产中得到了广泛的使用，已经成为多数人群的休闲方式，也为多数人所喜好。当然，为了满足没有网络同样能娱乐的要求，许多小游戏做成了单机和网络的双功能。 本软件使用JAVA语户端之间的连接，利用多线程技术言实现，经过对图形界面，绘图，布局管理器等去构造出游戏的单机功能，在此基础上，利用SCOKET的知识，建立起服务器与客来处理服务器端与客户端之间的数据传输，通信问题，使得客户端和服务器端之间能够同步的进行处理。 经过对软件的编写，更深入的理解了面向对象的概念，也体会到利用面向对象语言处理一些问题的优势。同时也加深了对多线程，流套接字等高级技术的理解。 关键词：多线程；流套接字；数据传输；同步。
ABSTRACT At present, With the rapid development of computer network. Taking computer technology and the network technology as the core, modern network technology is already used in the real life and the production and already became the leisure mode of the most people. And most people like them. Of course, it’s a pity that there still have some clients lacking of network because of various causes. In order to satisfy the above clients’ requirements. A large number of games ,usually nam ed as “small games” by players, are designed for involving two kinds of different function. The former game is often played by these players whose computers never connect with the network. It’s called for stand-alone version games. Just as its name implies, the later is named as online version games This software implemented with JAVA language, and according to the understanding of SCOKET ,GUI and paint image ichnology. Established in these foundation , the server co ects with the multi- client, and transmission the information between many clients using the multi-thread proceeding technology. it is very convenient for both client and server to do the synchronous processing. Through to the software compilation, deepen understanding and grasp to the technology above understanding and holding.
计算机学院网络工程专业《程序设计综合课程设计》报告（2011/2012学年第一学期） 学生姓名： 学生班级：网络工程 学生学号： 指导教师： 2011年12月30日
双人五子
棋 目录 第一章课程设计目的和要求 (1) 1.1课程设计的目的 (1) 1.2课程设计的要求 (1) 第二章课程设计任务内容 (2) 2.1课程设计的主要内容 (2) 2.2系统设计原则 (2) 第三章设计说明 (3) 3.1游戏分析和介绍 (3) 3.1.1游戏分析 (3)
3.1.2游戏介绍 (3) 3.2重点模块说明 (3) 3.2.1棋盘界面Showboard() (3) 3.2.2下棋Play() (4) 3.2.3覆盖棋盘Recoverboard() (7) 3.2.4游戏结束后初始化棋盘Unitboard() (7) 3.2.5保存棋盘CopyB() (8) 3.3函数清单 (8) 3.4接口 (9) 第四章软件使用说明 (10) 4.1测试 (10) 4.2限制条件 (13) 第五章课程设计心得体会 (14) 附录一程序流程图 (15) 附录二程序代码 (16) 附录三参考文献 (26) 第一章课程设计目的和要求 1.1课程设计的目
1,学习综合运用C语言课程和其他相关课程的知识，提高分析解决实际问题的能力，进一步巩固、加深和拓宽所学的知识，进一步加强结构化程序设计的思想，加深对高级语言基本语言要素和控制结构的理解。 2,全面系统的学习面向对象程序设计的基本概念、基本语法和编程方法，与同学合作设计整套程序，并且独立完成一定工作量的程序设计. 3,掌握程序设计中的常用算法和C语言的程序技巧,培养良好的程序设计风格。 4,运用所学的知识了解五子棋游戏的制作结构，将所学的知识运用于实践中。 1.2课程设计的要求 1,与同学合作设计、编制、调试出一款双人五子棋游戏，并单独完成其中一定量的函数模块。 2,要求该游戏具有趣味性和可操作性，能够正常运行。其中用到C++语言中的各种语句、结构。（如其中需要注意全局变量和局部变量的申明，数组的使用等） 3,双人五子棋要求能够进入欢迎界面，二人对弈，当有五颗同色棋子相连时，判断出输赢等一系列游戏流程。
基于JA V A的五子棋游戏系统设计与实现专业电子信息工程 学生董永杰 指导教师曾玉
摘要 目前，随着计算机网络的的发展，以计算机技术和网络技术为核心的现代网络技术已经在现实生活和生产中得到了广泛的使用，已经成为多数人群的休闲方式，也为多数人所喜好。当然，为了满足没有网络同样能娱乐的要求，许多小游戏做成了单机和网络的双功能。 本软件使用JAVA语户端之间的连接，利用多线程技术言实现，通过对图形界面，绘图，布局管理器等去构造出游戏的单机功能，在此基础上，利用SCOKET 的知识，建立起服务器与客来处理服务器端与客户端之间的数据传输，通信问题，使得客户端和服务器端之间能够同步的进行处理。 通过对软件的编写，更深入的理解了面向对象的概念，也体会到利用面向对象语言处理一些问题的优势。同时也加深了对多线程，流套接字等高级技术的理解。 关键词：多线程；流套接字；数据传输；同步。
ABSTRACT ABSTRACT At present, With the rapid development of computer network. Taking computer technology and the network technology as the core, modern network technology is already used in the real life and the production and already became the leisure mode of the most peo ple. And most people like them. Of course, it’s a pity that there still have some clients lacking of network because of various causes. In order to satisfy the above clients’ requirements. A large number of games ,usually named as “small games” by players, are designed for involving two kinds of different function. The former game is often played by these players whose computers never connect with the network. It’s called for stand-alone version games. Just as its name implies, the later is named as online version games This software implemented with JAVA language, and according to the understanding of SCOKET ,GUI and paint image ichnology. Established in these foundation , the server co ects with the multi- client, and transmission the information between many clients using the multi-thread proceeding technology. it is very convenient for both client and server to do the synchronous processing. Through to the software compilation, deepen understanding and grasp to the technology above understanding and holding. Key Words: multiple thread, Socket, transmission-data, synchronism.
计算机工程系课程设计报告 课程名称：软件工程 课程设计题目：五子棋游戏 班级 2013级计科(4)班 姓名许婷娜 学号 20130905428 2015年12月27日
目录 1. 引言 (1) 1.1系统的开发背景（可行性分析） (1) 1.2 系统简介 (2) 1.2.1系统介绍 (2) 1.2.2开发本系统所做的工作 (2) 2. 需求分析 (3) 2.1 需求的描述与分析 (3) 2.2 需求定义 (3) 2.2.1 功能需求 (3) 2.2.2 性能需求 (4) 3. 系统设计 (4) 3.1总体设计 (4) 3.1.1设计思想 (4) 3.1.2五子棋游戏的功能的结构图 (5) 3.2程序设计分析 (5) 4. 五子棋游戏的详细设计 (6) 4.1五子棋游戏的主窗口界面 (6) 4.2五子棋游戏的核心模块的详细设计 (10) 4.2.1五子棋游戏程序核心代码 (10) 4.2.2五子棋游戏程序主面板与鼠标事件 (13) 4.2.3五子棋游戏程序流程图 (17) 4.3五子棋游戏的游戏功能模块的详细设计 (18) 4.3.1五子棋游戏的开局功能模块 (18) 4.3.2五子棋游戏的棋盘功能模块 (18) 4.3.3五子棋游戏的模式功能模块 (19) 4.3.4五子棋游戏的退出功能模块 (19) 4.4五子棋游戏的外观功能模块的详细设计 (19) 4.5五子棋游戏的版本功能模块的详细设计 (20)
5. 五子棋游戏的测试 (20) 5.1系统测试的类型 (20) 5.2测试举例 (21) 5.2.1测试用户的对弈结果 (21) 5.2.2测试用户切换棋盘类型功能 (22) 5.2.3测试用户切换模式类型功能 (23) 5.2.4测试用户切换外观类型功能 (24) 5.2.5测试版本功能 (26) 小结 (27) 致谢 (28) 参考文献 (29)
五子棋游戏总体设 计与实现
4.系统总体设计与实现 4.1 总体设计分析 总体设计是软件开发过程中的另一个重要阶段，在这一阶段中将根据需求分析中提出的逻辑模型，科学合理地进行物理模型的设计。这个阶段的主要目标是将反映用户信息需求的逻辑方案转换成物理方案，并为下一阶段提供必要的技术资料。 4.1.1 总体设计原则 (1)整体性：软件是作为统一整体而存在的。因此，在总体设计中要从整个软件的角度进行考虑。 (2)灵活性：为保持软件长久的生命力，要求该手机游戏软件具有很强的环境适应性。为此，游戏软件应具有较好的开放性和结构的可变性。 (3)可靠性：可靠性是指软件抵御外界干扰的能力及受外界干扰时的恢复能力。 (4)经济性：经济性是指在满足游戏软件需求的前提下，尽可能地减小游戏软件的开销。 4.1.2 软件模块总体设计 软件中各模块之间的关系一般利用层次图来表示。它是一种一系列多层次的用树形结构的矩形框描绘数据的层次结构框图。
一个单独的矩形框作为树形结构的顶层，各个数据的子集由下面的各层矩形框代表，最底层的各个矩形框代表组成这个数据的实际数据元素（不能再分割的元素），它代表完整的数据结构。这模式非常适合于需求分析阶段的需要，层次方框图对数据结构描绘随着结构精细化也越来越详细。重复细化沿着图中每条路径，从对顶层信息的分类开始，直到确定了数据结构的全部细节为止。 图4-1 游戏功能结构 本研究中将游戏软件分为三大模块，如图4-1所示，包括：游戏选项、游戏设置和帮助。按照在调研中搜集的资料对每个模块的功能进行编排制作。依据上述功能的分析，本研究中，将游
戏软件在三大模块的基础上又对每一大模块又分为几个子模块：游戏选项包括六个模块：开始游戏、重新游戏、悔棋、认输、背景音乐和退出游戏。 游戏设置包括三个模块：先后手设置、棋盘底纹颜色设置和棋盘大小设置。 帮助包括两个模块：游戏帮助和关于。 4.2 游戏设计 4.2.1 游戏前的准备 本游戏在开发之前需要做一些前期准备工作，特别是对于精通五子棋游戏的Java 游戏开发者来说。一般情况下，一款运用起来比较熟练地J2ME 开发工具是必不可少的。本游戏使用的是J2ME的简化开发工具Sun Java (TM) Wireless Toolkit 2.5.2 for CLDC，她需先将Java虚拟机安装调试好之后才能使用。WTK 2.5.2 不带有文本编辑功能，因此需要另寻搭配使用。本游戏采用Ultra Edit 进行编辑。本游戏需要几张后缀名为.png格式的卡通图，除了一张用作五子棋游戏的 Logo 外，其余的都将在游戏中使用。4.2.2 游戏界面和事件驱动设计 游戏的界面设计采取传统游戏界面风格，如图4-2所示。游戏设计中采用传统界面游戏风格，首先启动游戏，然后进入游戏开始界面，界面中放置“设置”、“开局”、“帮助”、“关
徐州师范大学物电学院课程设计报告 课程名称：计算机程序设计实训 题目：五子棋 专业班级： 09物41 学生姓名：高乐莲 学生学号： xxxx ___________ 日期： 2011.12.24 指导教师：赵纪平 物电学院教务部印制
说明： 1、报告中的第一、二、三项由学生在课程设计开始前填写，由指导教师指 导并确认签字。 2、学生成绩由指导教师根据学生的设计情况给出各项分值及总评成绩，并 填写成绩评定表。 3、所有学生必须参加课程设计的答辩环节，凡不参加答辩者，其成绩一律 按不及格处理。答辩小组成员应由2人及以上教师组成。答辩后学生根据答辩情况填写答辩记录表。 4、报告正文字数一般应不少于3000字，也可由指导教师根据本门课程设 计的情况另行规定。 5、平时表现成绩低于6分的学生，取消答辩资格，其该课程设计成绩按不 及格处理。 6、课程设计完成后，由指导教师根据完成情况写出总结。 7、此表格式为徐州师范大学物理与电子工程学院提供的基本格式，指导教 师可根据本门课程设计的特点及内容做适当的调整。
指导教师签字： 年月日
目录 摘要...................................................................................................II Abstract................................................................................................ II 1 绪论 (1) 1.1 课题背景 (1) 1.2 课程设计的目的 (1) 2 设计方案简述 (2) 2.1 可行性分析 (2) 2.2 需求分析 (2) 3 详细设计 (3) 3.1窗体设计 (3) 3.2游戏项目开发 (5) 3.2.1棋牌设置 (5) 3.2.2放置棋子功能的开发 (6) 3.3.3游戏获胜决断的开发 (12) 3.2.4游戏的调试与运行 (20) 4 设计结果及分析 (22) 4.1 程序的结果 (22) 4.2结果分析 (23) 5总结 (24) 参考文献 (25)
五子棋游戏 项目设计报告 报告人：_ 学号： z
日期：2016年5月25日 摘要 (3) 一、....................................................... 系统功能简述. (4) （一）.......................................... 系统功能4 （二）.......................................... 开发环境4 （三）............................................... 实用价值 4. 二、................................................ 界面设计 5. （一）............................................... 界面操作 5. （二）...................................... 界面设计方案6 三、.............................................. 收获与体会 13 四、................................................ 参考文献 14
摘要 随着经济的发展，社会竞争的激烈，现在社会进入了竞争的时代。上班族为了完成公司业务，每天超负荷的工作；学生为了不落后他人每天早起晚睡不断地学习,压力巨大。所以为了缓解大家的压力，使大家在工作、学习之余娱乐一下，活跃大脑，提高工作、学习效率，因此益智性游戏越来越受人们的关注，五子棋作为益智类游戏之一，倍受人们的喜爱，所以对于五子棋的开发也有了很多关注。 本文主要讲的是利用VC++6.0 软件开发一个界面简洁、直观、实用性比较高的AI 功能的五子棋游戏，游戏程序实现人机对弈，在对弈过程中当用户和电脑比赛时电脑利用搜索算法计算出落子的最佳位置，是先人机对弈，而且程序能够完成具有重新开始游戏、判断胜负、判断落子等功能。 关键词:人工智能，自动处理，人机博弈，五子棋
五子棋游戏实验报告 课程名称计算机程序设计(VB) 学号______________________ 姓名______________________ 班级______________________ 提交时间 五子棋软件设计 一、实验目的 1?通过五子棋软件设计或者自拟题目设计，巩固本课程所学的各个章节重点知识，自拟题目的同学需尽早向教师提岀自己的想法及设计方案。 2?通过开发一个较大的系统，增强软件开发能力。 3?通过调试系统，增强逻辑思维能力。 二、实验内容 1.基本要求： (1)输入两个对手名字，然后进入游戏界面。 (2)用鼠标点击的方式在棋盘上摆放棋子，黑白交替。(棋盘15*15 ) (3)可以悔棋。 (4)五子连在一起的时候能判断胜利，并且显示出胜利者的名字。 (5)能够将棋局的结果保存，保存该棋局
结束的状态、对手名字、棋局名字(棋局名字在保存时由用户在相应的界面下添入)(此功能要求用数据库和文件两种技术实现)。
因为棋盘上空点居多，大部分点的信息为0,因此只需保存有棋子的点的信息 用文件技术进行棋局保存，思路相同。 （7）五子棋恢复棋局 思路：首先从数据库文件中找到要恢复棋局的数据（即曾经保存的数据），然后把这些数据赋值给内存中相应的数组或者变量中，按照这些数据重新绘制棋盘和棋子，即完成了对棋局的恢复。 窗体启动事件应该完成的事情： 组合框中应该显示曾经保存的棋局名。因为每次保存棋局时，都是将棋局所有棋子的记录添加在表的最 后，因此表中关于棋局名的记录只能是类似于aaabbbbccccc的形式，而不可能是abbcacc的形式，根据 这个特点编程序取出表中不同的棋局名。 具体算法： 用一个字符串变量strfile初始值为空，从表的顶端向下依次移动记录指针，如果当前记录的棋局名字段和strfile不相等，说明进入另一个棋局的记录中，将该棋局记录的棋局名赋值给strfile，并加入到组合 框中，一直到表中最后一个记录 因为要从数据库中取岀相关数据到a数组中，因此要将a数组所有数据清零。 要建立一个data控件，与数据库连接起来，而后识别棋局（即表中的棋局名字段与在列表框中选择的棋 局名比较），将数据库该棋局中所有信息都赋值给a数组及相关变量。 刚才仅仅是数据的恢复，即将数据库中已经保存过的数据恢复到内存中，下一步应该根据内存中的数据重新绘制棋盘以及棋子。 重新绘制棋盘是独立的一块功能，因此考虑用全局子过程来实现，该子过程定义在模块中。思路如下： 清屏一绘制棋盘一根据a数组中的每一项的两个下标来决定绘制棋子的位置，根据每一项的值是1还是 2来决定在该位置绘制何颜色的棋子。 决定该黑白方走的blackwhite变量当时没有保存，可以采用在数据库中保存的方式来解决，本例中解决方法是通过数黑白棋子个数来决定恢复棋局后该谁走的。 因此设置了一个变量做计数器，每走一步棋计数器的值加一。 用文件技术实现棋局恢复，思路相同。 （8）悔棋 悔一步棋：用几个变量来表示关于一步棋的几个信息，每次下子都将该子的信息赋值给那几个变量，悔 一步棋即将那几个变量所表示的点的a数组信息清零。而后调用paint （）过程重画。 以上是教师带着学生完成的软件功能。 遗留问题：保存棋手姓名和棋局名并在恢复棋局的时候显示。（需要同学们自己完成）思路：在数据表中多建立两个字段，分别表示两个棋手姓名，同其它数据的保存类似。 三、设计日期 十二月 四、完成日期 十二月 五、实验体会 其实，一开始学习vb我就对它不抱有一定的热情，可能是因为要用到计算机以及编程问题，当时一想到有代码，就会无比的苦恼，但是为了让这门课顺利通过，我还是怀着一颗必须要学的心情。起初，我对待这门新课程和其他课
佛山科学技术学院 《可视化编程技术》课程设计报告 五子棋软件设计 学生姓名：凌健铭 学号：2011924133 年级专业：11级教育技术学2班 指导老师：容汝佳 学院：教育科学学院 广东★佛山 提交日期：2013年6月
目录 1. 前言 (2) 2．概要设计 (3) 2.1 开发环境 (3) 2.2 五子棋功能 (3) 2.3 界面设计 (3) 2.4 类的框架结构图 (4) 3. 详细设计 (5) 3.1 五子棋使用的JAVA类的说明 (5) 3.2 类的主要方法 (6) 3.2.1下放棋子 (6) 3.2.2 判断输赢 (7) 3.2.3 重新开始 (10) 3.2.4 悔棋 (10) 3.2.5 程序流程图 (11) 4. 运行结果 (12) 5. 测试分析 (15) 6. 源程序 (15) 参考文献 (26) 设计总结 (26)
摘要：该程序是一个图形界面的简单的java五子棋游戏，具有良好的界面，使用人员能快捷简单地进行操作。人们可以在空闲时使用该程序进行五子棋对战，达到娱乐休闲的目的。该五子棋程序设有悔棋、重新开始和退出功能。界面为黄色棋盘。 关键字：java五子棋游戏软件，娱乐类电子游戏设计 1 前言 五子棋作为一个棋类竞技活动，其满足了人民娱乐休闲的需要，在民间十分流行。 Java是由Sun公司开发的新一代纯面向对象的网络编程语言。其目标是建 立一种在任意种机器、任一种操作系统的网络环境中运行的软件，实行所谓的“程序写一次，到处运行”的目标。正因为如此，Java已成为当今Internet上最流行、最受欢迎的一种程序开发语言。 Java开发小组把Java按特性分为基本版、移动版、企业版，每个版本有一个软件开发包。Java基本版本叫Java 2标准版（Java 2 Standard Edition,J2SE）,它包含建立Java应用程序或者是Applet所需的应用程序编程接口（API）。Java 2移动版（The Java 2 Mobile Edition，J2ME）包含创建无线Java应用程序的API。还有Java 2企业版（The Java 2 Enterprise，J2EE）是J2SE的增强版本，包含建立多层架构应用程序API。 Java语言是由C++语言发展起而来的，是一种彻底的面向对象的程序设计语言。作为一种纯面向对象的程序设计语言，它非常适合大型软件的开发。Java 语言去掉了C++语言的一些容易引起错误的特性。Java语言的特点有：面向对象、跨平台、安全性、多线程和图形功能强。 2 概要设计 2.1开发环境 开发平台：Microsoft Windows XP Professional Service Pack 2
毕业论文（设计）题目五子棋游戏的设计与实现
毕业设计（论文）原创性声明和使用授权说明 原创性声明 本人郑重承诺：所呈交的毕业设计（论文），是我个人在指导教师的指导下进行的研究工作及取得的成果。尽我所知，除文中特别加以标注和致谢的地方外，不包含其他人或组织已经发表或公布过的研究成果，也不包含我为获得及其它教育机构的学位或学历而使用过的材料。对本研究提供过帮助和做出过贡献的个人或集体，均已在文中作了明确的说明并表示了谢意。 作者签名：日期： 指导教师签名：日期： 使用授权说明 本人完全了解大学关于收集、保存、使用毕业设计（论文）的规定，即：按照学校要求提交毕业设计（论文）的印刷本和电子版本；学校有权保存毕业设计（论文）的印刷本和电子版，并提供目录检索与阅览服务；学校可以采用影印、缩印、数字化或其它复制手段保存论文；在不以赢利为目的前提下，学校可以公布论文的部分或全部内容。 作者签名：日期：
学位论文原创性声明 本人郑重声明：所呈交的论文是本人在导师的指导下独立进行研究所取得的研究成果。除了文中特别加以标注引用的内容外，本论文不包含任何其他个人或集体已经发表或撰写的成果作品。对本文的研究做出重要贡献的个人和集体，均已在文中以明确方式标明。本人完全意识到本声明的法律后果由本人承担。 作者签名：日期：年月日 学位论文版权使用授权书 本学位论文作者完全了解学校有关保留、使用学位论文的规定，同意学校保留并向国家有关部门或机构送交论文的复印件和电子版，允许论文被查阅和借阅。本人授权大学可以将本学位论文的全部或部分内容编入有关数据库进行检索，可以采用影印、缩印或扫描等复制手段保存和汇编本学位论文。 涉密论文按学校规定处理。 作者签名：日期：年月日 导师签名：日期：年月日
基于JAVA的五子棋游戏系统设计与实现专业电子信息工程 学生董永杰 指导教师曾玉
目前，随着计算机网络的的发展，以计算机技术和网络技术为核心的现代网络技术已经在现实生活和生产中得到了广泛的使用，已经成为多数人群的休闲方式，也为多数人所喜好。当然，为了满足没有网络同样能娱乐的要求，许多小游戏做成了单机和网络的双功能。 本软件使用JAVA语户端之间的连接，利用多线程技术言实现，通过对图形界面，绘图，布局管理器等去构造出游戏的单机功能，在此基础上，利用SCOKET的知识，建立起服务器与客来处理服务器端与客户端之间的数据传输，通信问题，使得客户端和服务器端之间能够同步的进行处理。 通过对软件的编写，更深入的理解了面向对象的概念，也体会到利用面向对象语言处理一些问题的优势。同时也加深了对多线程，流套接字等高级技术的理解。 关键词：多线程；流套接字；数据传输；同步。
At present, With the rapid development of computer network. Taking computer technology and the network technology as the core, modern network technology is already used in the real life and the production and already became the leisure mode of the most people. And most people like them. Of course, it’s a pity that there still have some clients lacking of network because of various causes. In order to satisfy the above clients’ requirements. A large number of games ,usually named as “small games” by players, are designed for involving two kinds of different function. The former game is often played by these players whose computers never connect with the network. It’s called for stand-alone version games. Just as its name implies, the later is named as online version games This software implemented with JAVA language, and according to the understanding of SCOKET ,GUI and paint image ichnology. Established in these foundation , the server co ects with the multi- client, and transmission the information between many clients using the multi-thread proceeding technology. it is very convenient for both client and server to do the synchronous processing. Through to the software compilation, deepen understanding and grasp to the technology above understanding and holding.