围棋作为一个棋类竞技运动，在民间十分流行，为了熟悉围棋规则及技巧，以及研究简单的人工智能，决定用Java开发围棋游戏。主要完成了人机对战和玩家之间联网对战2个功能。网络连接部分为Socket编程应用，客户端和服务器端的交互用Class Message定义，有很好的可扩展性，客户端负责界面维护和收集用户输入的信息，及错误处理。服务器维护在线用户的基本信息和任意两个对战用户的棋盘信息，动态维护用户列表。在人机对弈中通过深度搜索和估值模块，来提高电脑棋手的智能。分析估值模块中的影响精准性的几个要素，以及提出若干提高精准性的办法，以及对它们搜索的节点数进行比较，在这些算法的基础上分析一些提高电脑AI方案，如递归算法、电脑学习等。算法的研究有助于理解程序结构，增强逻辑思维能力，在其他人工智能方面也有很大的参考作用。
直接上代码啦，let’s go
/*************************MainWindow**********************/
import java.awt.BorderLayout;
import java.awt.Button;
import java.awt.Checkbox;
import java.awt.CheckboxGroup;
import java.awt.Choice;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.Frame;
import java.awt.Graphics;
//抽象类，不能用于构造方法创建对象
import java.awt.GridLayout;
import java.awt.Image;
import java.awt.Label;
import java.awt.Panel;
import java.awt.Point;
import java.awt.TextField;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.awt.event.WindowEvent;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.RandomAccessFile;
import java.net.ServerSocket;
import java.net.Socket;
import javax.swing.Box;
import javax.swing.JButton;
import javax.swing.JDialog;
import javax.swing.JLabel;
//负责创建标签对象，标签用来显示信息，但没有编辑功能
import javax.swing.JOptionPane;
import javax.swing.JPasswordField;
import javax.swing.JTextField; //利用import引用各类包
public class MainWindow extends Frame implements Runnable
{
Go panelGo=new Go(); //用Go类声明并创建一个panelGo对象
Image myImage;
int PORT;
Socket sendSocket; //主动连接Socket
PrintWriter writer; //用来发送message
boolean stopFlag;
boolean isInitiative;
Point messagePoint;
Point goStartPoint=null; //初始化
Point yellowPoint=null;
boolean stepColor=true;
Point LastPoint=null; //移除黄点时，判断位置变动
BorderLayout borderLayout1 = new BorderLayout(); //用BorderLayout布局
Panel panel1 = new Panel(); //创建面板
Panel panel2 = new Panel();
BorderLayout borderLayout2 = new BorderLayout();
Panel panel3 = new Panel();
CheckboxGroup checkboxGroup1 = new CheckboxGroup(); //选项框
Checkbox checkbox1 = new Checkbox(); //声明创建Checkbox类的对象
Checkbox checkbox2 = new Checkbox();
Label label1 = new Label();
TextField textField1 = new TextField();
Button button1 = new Button();
Label label2 = new Label();
Choice choice1 = new Choice();
Button button2 = new Button();
GridLayout gridLayout1 = new GridLayout(); //利用GridLayout布局
BorderLayout borderLayout3 = new BorderLayout();
public MainWindow() //构造MainWindow方法
{
try
{
jbInit(); //可能发生异常的语句
}
catch(Exception e)
{
e.printStackTrace();
} //异常处理
}
private void jbInit() throws Exception //用关键字throws声明抛出异常
{
choice1.setBackground(new Color(236, 190, 120)); //设置棋盘底色
button1.setBackground(new Color(236, 190, 120));
this.setResizable(false);
new Thread(this).start(); //启动监听线程
this.PORT=1976;
this.isInitiative=false; //是否主动连接
this.stopFlag=false; //是否继续监听的标志
this.choice1.addItem("黑");
this.choice1.addItem("白");
LastPoint=new Point();
messagePoint=new Point();
this.setSize(470,450);
this.setTitle("围棋程序 作者:围棋对弈小组"); //设置标题
this.panelGo.setEnabled(false); //开始之前屏蔽掉盘面
checkbox1.addMouseListener(new java.awt.event.MouseAdapter()
{
public void mouseClicked(MouseEvent e)
{
checkbox1_mouseClicked(e);
}
}); //获取监听器
this.goStartPoint=this.panelGo.getLocation(); //
this.setLayout(borderLayout1); //设置背景布局
panel1.setLayout(borderLayout2);
checkbox1.setCheckboxGroup(checkboxGroup1);
checkbox1.setLabel("单机");
checkbox2.setCheckboxGroup(checkboxGroup1);
checkbox2.setLabel("联机"); //设置名为联机的复选框
checkbox2.addMouseListener(new java.awt.event.MouseAdapter()
{
public void mouseClicked(MouseEvent e)
{
checkbox2_mouseClicked(e);
}
}); //获取监听器
label1.setText("对方地址");//
button1.setLabel("连接"); //设置名为连接的按钮
button1.addActionListener(new java.awt.event.ActionListener()
{
public void actionPerformed(ActionEvent e)
{
button1_actionPerformed(e);
}
}); //告诉监听器所发生的事件，并执行方法
label2.setText(" ");
button2.setBackground(new Color(236, 190, 120));
button2.setLabel("开始"); //设置名为开始的按钮
button2.addActionListener(new java.awt.event.ActionListener()
{
public void actionPerformed(ActionEvent e)
{
button2_actionPerformed(e);
}
}); //
panel3.setLayout(gridLayout1); //设置布局
gridLayout1.setRows(8);
gridLayout1.setColumns(1);
gridLayout1.setHgap(100);
gridLayout1.setVgap(10); //
panel2.setLayout(borderLayout3); //
this.panel2.setSize(500,70); //
panelGo.addMouseMotionListener(new java.awt.event.MouseMotionAdapter()
{
public void mouseMoved(MouseEvent e)
{
panelGo_mouseMoved(e);
}
}); //获取监听器
panelGo.addMouseListener(new java.awt.event.MouseAdapter()
{
public void mouseClicked(MouseEvent e)
{
panelGo_mouseClicked(e);
}
}); //获取监听器
this.addWindowListener(new java.awt.event.WindowAdapter()
{
public void windowClosing(WindowEvent e)
{
this_windowClosing(e);
}
}); //获取监听器
panel3.setBackground(new Color(236, 190, 120)); //设置背景颜色
//初始化创建的对象
panel3.add(checkbox1, null);
panel3.add(checkbox2, null);
panel3.add(label1, null);
panel3.add(textField1, null);
panel3.add(button1, null);
panel3.add(choice1, null);
panel3.add(button2, null);
panel3.add(label2, null);
this.panel1.add(this.panelGo,BorderLayout.CENTER); //将panelGo添加到BorderLayout布局的中间
this.panel1.add(panel3, BorderLayout.EAST); //将pane13添加到BorderLayout布局的东区域
this.add(panel2, BorderLayout.SOUTH); //将pane12添加到BorderLayout布局的南区域
this.add(panel1, BorderLayout.CENTER); //将pane13添加到BorderLayout布局的中间
this.disableLink(); //废掉控件
this.checkboxGroup1.setSelectedCheckbox(this.checkbox1); //如果复选框处于选中状态该方法返回true，否则返回false
this.yellowPoint=new Point(1000,1000); //初始化一个世纪外的黄点
this.centerWindow();
loginDialog(this); //调用loginDialog方法传进参数this
}
/************用户登录界面************/
private JDialog login; //声明一个私有类变量
private void loginDialog(final Frame frame) {
login = new JDialog();
login.setTitle("登录"); //设置标题
login.setLayout(new FlowLayout()); //利用流布局来设置窗口的布局
login.add(new JLabel("用户名:")); //添加标签为用户名的对象
final JTextField name = new JTextField(10); //设置文本框中字符不得超过10个
login.add(name);
login.add(new JLabel("密 码:"));
final JPasswordField password = new JPasswordField(10); //设置密码框中字符不得多于10个
password.setEchoChar(‘*‘); //设置显示密码对应的字符为*
login.add(password);
JButton confirm = new JButton("登录"); //定义一个登录按钮
confirm.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
if (compareUserData(name.getText().trim(), new String(password.getPassword()))) {
login.setVisible(false);
frame.show();
myImage=frame.createImage(16,16);//用来纪录有黄点之前的图像
} else {
JOptionPane.showMessageDialog(login, "用户名或密码错误！", "错误提示", JOptionPane.ERROR_MESSAGE);
}
}
}); //获取监听器，并执行事件
login.add(confirm);
final JDialog regDialog = new JDialog(login, "注册", true); //定义一个对象，该对象无法被继承
registerDialog(regDialog);
JButton register = new JButton("注册"); //设置注册的按钮
register.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
regDialog.setVisible(true);
}
}); //获取监听器，执行regDialog为可见
login.add(register);
login.setSize(200, 130);
login.setResizable(false);
login.setLocationRelativeTo(null);
login.setVisible(true); //确保窗体里面的组件可见
}
private boolean compareUserData(String name, String password) {
try {
RandomAccessFile out = new RandomAccessFile("user.dat", "rw");
String fname, fpassword = null;
while (out.getFilePointer() < out.length()) {
fname = out.readUTF();
out.readUTF();
fpassword = out.readUTF();
if (fname.equals(name) && fpassword.equals(password)) return true;
}
out.close(); //可能发生异常的语句
} catch (IOException e) {
e.printStackTrace();
} //异常语句的处理
return false;
}
private void registerDialog(final JDialog regDialog) {
Box box1 = Box.createVerticalBox();
box1.add(new JLabel("用户名:", JLabel.RIGHT)); //添加用户名标签，用户名在标签中靠右对齐
box1.add(Box.createVerticalStrut(10));
box1.add(new JLabel("性别:", JLabel.RIGHT)); //添加性别标签，性别在标签中靠右对齐
box1.add(Box.createVerticalStrut(10));
box1.add(new JLabel("密码:", JLabel.RIGHT), -1); //添加密码标签，密码在标签中靠右对齐
box1.add(Box.createVerticalStrut(10));
box1.add(new JLabel("确认密码:", JLabel.RIGHT)); //添加确认密码标签，确认密码在标签中靠右对齐
Box box2 = Box.createVerticalBox();
final JTextField nameTextField = new JTextField(10); //设置用户名文本框字符不得超过10个，且文本框不能被继承
box2.add(nameTextField);
box2.add(Box.createVerticalStrut(8));
final CheckboxGroup cbg = new CheckboxGroup();
Box box21 = Box.createHorizontalBox();
final Checkbox cb1 = new Checkbox("男", cbg, true); //复选框默认状态选定为男性
box21.add(cb1);
box21.add(new Checkbox("女", cbg, false)); //当鼠标点击女性复选框时，flase自动变为true
box2.add(box21);
box2.add(Box.createVerticalStrut(8));
//定义密码框中的字符长度小于10个
final JPasswordField pass1 = new JPasswordField(10);
box2.add(pass1);
box2.add(Box.createVerticalStrut(8));
final JPasswordField pass2 = new JPasswordField(10);
box2.add(pass2);
Box baseBox = Box.createHorizontalBox();
baseBox.add(box1);
baseBox.add(box2);
regDialog.setLayout(new FlowLayout());
regDialog.add(baseBox);
JButton confirm = new JButton("确定"); //创建并声明确定按钮
JButton cancel = new JButton("取消"); //创建并声明取消按钮
regDialog.add(confirm);
regDialog.add(cancel);
regDialog.setSize(200, 200); //设置大小
regDialog.setResizable(false);
regDialog.setLocationRelativeTo(null);
confirm.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
String sex = null;
if (cbg.getSelectedCheckbox() == cb1)
sex = "男";
else
sex = "女";
if (saveUserData(nameTextField.getText().trim(), sex,
new String(pass1.getPassword()), new String(pass2.getPassword())))
regDialog.setVisible(false);
else
JOptionPane.showMessageDialog(regDialog, "输入有误，请检查", "错误提示",
JOptionPane.ERROR_MESSAGE);
}
}); //获取监听器
cancel.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
regDialog.setVisible(false);
}
}); //获取监听器
}
private boolean saveUserData(String name, String sex, String password1, String password2) {
if (!password1.equals(password2)) return false;
try {
RandomAccessFile out = new RandomAccessFile("user.dat", "rw");
out.seek(out.length());
out.writeUTF(name);
out.writeUTF(sex);
out.writeUTF(password1);
out.close(); //可能发生异常的语句
} catch (IOException e) {
e.printStackTrace();
return false;
} //异常的处理
return true;
}
void centerWindow()
{
//返回一个Dimension对象的引用，该对象实体中含有名字是width和height的成员变量。
Dimension d=Toolkit.getDefaultToolkit().getScreenSize();
int pX=(d.width-this.getWidth())/2;
int pY=(d.height-this.getHeight())/2;
this.setLocation(pX,pY);
}
/**********主方法*************/
public static void main(String args[])
{
MainWindow main=new MainWindow();
}
//监听线程
public void run()
{
try
{
ServerSocket serverSocket=new ServerSocket(PORT);
Socket receiveSocket=null;
receiveSocket=serverSocket.accept();
if(this.isInitiative) //如果已在进行，则不接受连接
this.stopFlag=true;
this.checkboxGroup1.setSelectedCheckbox(this.checkbox2); //自动选择联机
this.button1.setEnabled(false);
this.choice1.setEnabled(true);
this.textField1.setEnabled(false);
this.checkbox1.setEnabled(false);
this.checkbox2.setEnabled(false);
this.writer=new PrintWriter(receiveSocket.getOutputStream(),true);
BufferedReader reader=new BufferedReader(new InputStreamReader(receiveSocket.getInputStream()));
String message;
while(!this.stopFlag)
{
this.panelGo.showError("接收连接成功");
message=reader.readLine(); //按行读取文件中的内容
this.doMessage(message);
}
reader.close();
receiveSocket.close();
serverSocket.close();
}catch(IOException ioe){this.panelGo.showError("意外中断");}
}
//处理接收到的信息
void doMessage(String message)
{
if(message.startsWith("start"))//判断开始
{
this.panelGo.showError("对方已开始");
if(message.equals("start_black"))
this.choice1.select("白");
else
this.choice1.select("黑");
if(this.choice1.getSelectedItem().equals("黑"))//只要你是黑的，就先走
this.panelGo.setEnabled(true);
this.paintMyColor();//表明颜色
this.disableLink();
}
else//下子的信息
{
int color=Integer.parseInt(message.substring(0,1));
this.messagePoint.x=Integer.parseInt(message.substring(1,3));
this.messagePoint.y=Integer.parseInt(message.substring(3,5));
this.panelGo.setEnabled(true);//解禁
this.panelGo.doStep(this.messagePoint,color);
}
}
//为鼠标定位
void panelGo_mouseMoved(MouseEvent e)
{
Point realPoint=e.getPoint();
Point mousePoint=this.panelGo.getMousePoint(realPoint,this.goStartPoint);
this.removeLastMousePoint(this.LastPoint,mousePoint);
this.LastPoint.x=mousePoint.x;
this.LastPoint.y=mousePoint.y;
if(this.isPlace(mousePoint))
this.showMousePoint(mousePoint);
}
//加黄点的范围
boolean isPlace(Point p)
{
if(p.x>19||p.x<1||p.y<1||p.y>19)
return false;
int color;
One one;
one=(One)(this.panelGo.myHash.get(p));
color=one.color;
if(color!=0)
return false;
return true;
}
void panelGo_mouseClicked(MouseEvent e)
{
if(this.isSingle())
{
this.doSingle();
}
else
{
this.doMultiple();
}
}
//开始
void button2_actionPerformed(ActionEvent e)
{
if(e.getActionCommand().equals("开始"))
{
this.disableLink();
this.checkbox1.setEnabled(false);
this.checkbox2.setEnabled(false);
this.button2.setLabel("退出");
if(this.isSingle())
this.panelGo.setEnabled(true);
else//联机版时
{
if(this.choice1.getSelectedItem().equals("黑"))
{
this.writer.println("start_black");
}
else
this.writer.println("start_white");
}
this.paintMyColor();//表明颜色
}
else if(e.getActionCommand().equals("退出"))
{
this.dispose();
System.exit(0);
}
}
//disable联机时用的控件
void disableLink()
{
this.textField1.setBackground(new Color(236, 190, 120));
this.textField1.setEnabled(false);
this.choice1.setEnabled(false);
this.button1.setEnabled(false);
}
//enable联机时的控件
void enableLink()
{
this.textField1.setBackground(Color.white);
this.textField1.setEnabled(true);
this.choice1.setEnabled(true);
this.button1.setEnabled(true);
}
//判断类型
boolean isSingle()
{
return this.checkbox1.getState();
}
void single()
{
}
void multiple()
{
}
//加小黄点
void showMousePoint(Point mousePoint)
{
Graphics g=this.panelGo.getGraphics();
g.setColor(Color.yellow);
g.fillOval(mousePoint.x*20-6,mousePoint.y*20-6,this.panelGo.INTERVAL-8,this.panelGo.INTERVAL-8);
this.yellowPoint.x=mousePoint.x;//定位黄点
this.yellowPoint.y=mousePoint.y;
Graphics myG=this.myImage.getGraphics();
this.createMyImage(myG,this.yellowPoint,0);
}
//消除前一个黄点
void removeLastMousePoint(Point thatPoint,Point thisPoint)
{
if(thatPoint.x!=thisPoint.x||thatPoint.y!=thisPoint.y)
{
Graphics g=this.panelGo.getGraphics();
if(this.yellowPoint!=null&&this.myImage!=null)
g.drawImage(this.myImage,this.yellowPoint.x*20-8,this.yellowPoint.y*20-8,16,16,null);
this.yellowPoint.x=1000;//不在范围内，就一边去
this.yellowPoint.y=1000;
}
}
//构成所需要的Image
void createMyImage(Graphics g,Point thisPoint,int color)
{
int px=thisPoint.x;
int py=thisPoint.y;
Color myColor=this.panelGo.getBackground(); //设置背景色
//设置棋盘线
if(px==1&&py==1&&color==0)//四个角
{
g.setColor(myColor);
g.fillRect(0,0,16,16);
g.setColor(Color.black);
g.drawLine(8,8,8,16);
g.drawLine(5,5,5,16);
g.drawLine(8,8,16,8);
g.drawLine(5,5,16,5);
}
else if(px==1&&py==19&&color==0)
{
g.setColor(myColor);
g.fillRect(0,0,16,16);
g.setColor(Color.black);
g.drawLine(8,8,8,0);
g.drawLine(8,8,16,8);
g.drawLine(5,11,16,11);
g.drawLine(5,11,5,0);
}
else if(px==19&&py==1&&color==0)
{
g.setColor(myColor);
g.fillRect(0,0,16,16);
g.setColor(Color.black);
g.drawLine(8,8,8,16);
g.drawLine(8,8,0,8);
g.drawLine(11,5,11,16);
g.drawLine(11,5,0,5);
}
else if(px==19&&py==19&&color==0)
{
g.setColor(myColor);
g.fillRect(0,0,16,16);
g.setColor(Color.black);
g.drawLine(8,8,8,0);
g.drawLine(8,8,0,8);
g.drawLine(11,11,11,0);
g.drawLine(11,11,0,11);
}
else if(px==1&&color==0)//四个边
{
g.setColor(myColor);
g.fillRect(0,0,16,16);
g.setColor(Color.black);
g.drawLine(8,8,16,8);
g.drawLine(8,0,8,16);
g.drawLine(5,0,5,16);
}
else if(px==19&&color==0)
{
g.setColor(myColor);
g.fillRect(0,0,16,16);
g.setColor(Color.black);
g.drawLine(8,8,0,8);
g.drawLine(8,0,8,16);
g.drawLine(11,0,11,16);
}
else if(py==1&&color==0)
{
g.setColor(myColor);
g.fillRect(0,0,16,16);
g.setColor(Color.black);
g.drawLine(8,8,8,16);
g.drawLine(0,8,16,8);
g.drawLine(0,5,16,5);
}
else if(py==19&&color==0)
{
g.setColor(myColor);
g.fillRect(0,0,16,16);
g.setColor(Color.black);
g.drawLine(8,8,8,0);
g.drawLine(0,8,16,8);
g.drawLine(0,11,16,11);
}
//八个小黑点
else
if(color==0&&((px==4&&py==4)||(px==4&&py==10)||(px==4&&py==16)||(px==10&&py==4)||(px==10&&py==10)||(px==10&&py==16)||(px==16&&py==4)||(px==16&&py==10)||(px==16&&py==16)))
{
g.setColor(myColor);
g.fillRect(0,0,16,16);
g.setColor(Color.black);
g.drawLine(0,8,16,8);
g.drawLine(8,0,8,16);
g.fillOval(5,5,6,6);
}
else if(color==0)
{
g.setColor(myColor);//
g.fillRect(0,0,16,16);
g.setColor(Color.black);
g.drawLine(0,8,16,8);
g.drawLine(8,0,8,16);
}
}
//单机版走步
void doSingle()
{
if(this.stepColor)
this.panelGo.doStep(this.yellowPoint,1);
else
this.panelGo.doStep(this.yellowPoint,2);
if(!this.panelGo.errorFlag)//如果不违例，则换颜色
{
this.stepColor=!this.stepColor;
this.paintThisColor(this.stepColor);
}
else
this.panelGo.errorFlag=false;
this.yellowPoint.x=1000;//刚走的子不至于删掉
this.yellowPoint.y=1000;
}
//联机版走步
void doMultiple()
{
int color;
if(this.choice1.getSelectedItem().equals("黑"))
color=1;
else
color=2;
this.panelGo.doStep(this.yellowPoint,color);
//如果走法不对，返回
if(this.panelGo.errorFlag)
{
this.panelGo.errorFlag=false;
return;
}
this.panelGo.setEnabled(false);
String message=this.getMessage(color,this.yellowPoint.x,this.yellowPoint.y);
this.writer.println(message);
this.yellowPoint.x=99;//刚走的子不至于删掉，还要可以解析
this.yellowPoint.y=99;
}
//处理发送字符串
String getMessage(int color,int x,int y)
{
String strColor=String.valueOf(color);
String strX;
String strY;
//如果单数的话，就加一位
if(x<10)
strX="0"+String.valueOf(x);
else
strX=String.valueOf(x);
if(y<10)
strY="0"+String.valueOf(y);
else
strY=String.valueOf(y);
return strColor+strX+strY;
}
void this_windowClosing(WindowEvent e)
{
this.dispose();
System.exit(0);
}
void checkbox2_mouseClicked(MouseEvent e)
{
this.enableLink();
}
void checkbox1_mouseClicked(MouseEvent e)
{
this.disableLink();
}
void button1_actionPerformed(ActionEvent e)
{
this.goToLink(this.textField1.getText().trim(),this.PORT);
}
//主动连接serverSocket
void goToLink(String hostName,int port)
{
try
{
this.stopFlag=true;
this.sendSocket=new Socket(hostName,port);
this.panelGo.showError("连接成功！！");
this.choice1.setEnabled(true);
this.button1.setEnabled(false);
this.checkbox1.setEnabled(false);
this.checkbox2.setEnabled(false);
this.textField1.setEnabled(false);
this.writer=new PrintWriter(this.sendSocket.getOutputStream(),true);
new Listen(sendSocket,this).start();
}
catch(IOException ioe){
this.panelGo.showError("意外中断");
}
}
//开始时根据颜色画己方颜色
void paintMyColor()
{
Graphics g=this.label2.getGraphics();
if(this.choice1.getSelectedItem().equals("黑"))
g.fillOval(20,10,30,30);
else
{
g.setColor(Color.white);
g.fillOval(20,10,30,30);
g.setColor(Color.black);
g.drawOval(20,10,30,30);
}
}
//单机版画每步颜色
void paintThisColor(boolean whatColor)
{
Graphics g=this.label2.getGraphics();
if(whatColor)
g.fillOval(20,10,30,30);
else
{
g.setColor(Color.white);
g.fillOval(20,10,30,30);
g.setColor(Color.black);
g.drawOval(20,10,30,30);
}
}
}/***********************Go*************************************/
import java.awt.*;
import java.util.*;//引入包
public class Go extends Panel
{
int whichStep;
Hashtable myHash;
Point pointNow; //当前的点
Point STARTPOINT; //起始点
int INTERVAL; //等高距
Vector vec; //定义矢量
Point robPoint; //打劫点
Point mousePoint; //鼠标点
boolean errorFlag; //行棋错误标志
//构建器
public Go()
{
super(); //super函数，方便子类调用父类里面的成员变量与构造方法
pointNow=new Point(1000,1000); //把初始红点画在外面
errorFlag=false; //行棋错误标志
whichStep=0;
STARTPOINT=new Point(20,20); //新的点所在的位置
INTERVAL=20; //棋盘的间隔
myHash=new Hashtable(); //创建对象
robPoint=null; //打劫点
mousePoint=new Point(); //开辟鼠标点内存
vec=new Vector(); //存放校验的子
this.initMyHash(STARTPOINT,INTERVAL);
try
{
jbInit();
}
catch(Exception e)
{
e.printStackTrace();
} //异常处理
}
//初始化hashtable
void initMyHash(Point startPoint,int interval)
{
One one;
Point key; //逻辑点标志
int i,j; //定义i,j
for(i=1;i<=19;i++)
for(j=1;j<=19;j++) //循环
{
key=new Point(i,j);
one=new One(); //创建对象
one.posX=startPoint.x+(i-1)*interval;//相邻点处理，获取
one.posY=startPoint.y+(j-1)*interval;//相邻点处理。获取//获取相邻点
one.pointAround[0]=new Point(i,j-1); //上
one.pointAround[1]=new Point(i,j+1); //下
one.pointAround[2]=new Point(i-1,j); //左
one.pointAround[3]=new Point(i+1,j); //右
if(i==1)one.pointAround[2]=one.OUT; //左的周围
if(i==19)one.pointAround[3]=one.OUT; //右的周围
if(j==1)one.pointAround[0]=one.OUT; //上的周围
if(j==19)one.pointAround[1]=one.OUT; //下的周围
myHash.put(key,one); //我的我的哈希表并且在里键入关键字
}
}
//更新盘面
public void paint(Graphics g)
{
Point startPoint=STARTPOINT; //创建对象，开始点
int interval=INTERVAL; //定义成员变量
this.paintChessboard(g,startPoint,interval); //棋盘的操作
this.paintChessman(g,startPoint,interval); //棋子的操作
}
//画棋盘
void paintChessboard(Graphics g,Point startPoint,int interval)
{
int pX=startPoint.x; //定义相邻点X
int pY=startPoint.y; //相邻点Y
int LINELENGTH=interval*18; //定义路线长度
int i;
for(i=0;i<19;i++)
{
g.drawLine(pX+i*interval,pY,pX+i*interval,pY+LINELENGTH);
g.drawLine(pX,pY+i*interval,pX+LINELENGTH,pY+i*interval);
}//for循环，以便构造19*19的棋盘
g.fillOval(pX+interval*3-3,pY+interval*3-3,(int)(interval-14),(int)(interval-14));
g.fillOval(pX+interval*9-3,pY+interval*3-3,(int)(interval-14),(int)(interval-14));
g.fillOval(pX+interval*15-3,pY+interval*3-3,(int)(interval-14),(int)(interval-14));
g.fillOval(pX+interval*3-3,pY+interval*9-3,(int)(interval-14),(int)(interval-14));
g.fillOval(pX+interval*9-3,pY+interval*9-3,(int)(interval-14),(int)(interval-14));
g.fillOval(pX+interval*15-3,pY+interval*9-3,(int)(interval-14),(int)(interval-14));
g.fillOval(pX+interval*3-3,pY+interval*15-3,(int)(interval-14),(int)(interval-14));
g.fillOval(pX+interval*9-3,pY+interval*15-3,(int)(interval-14),(int)(interval-14));
g.fillOval(pX+interval*15-3,pY+interval*15-3,(int)(interval-14),(int)(interval-14));
//路线长度和间隔的确定
g.drawRect(pX-3,pY-3,366,366);//棋盘大小
}
//加棋子
void paintChessman(Graphics g,Point startPoint,int interval)
{//加入棋子，并且是按照一黑一白
int pX=startPoint.x; //相邻点X
int pY=startPoint.y; //相邻点Y
Enumeration enun=myHash.elements(); //创建对象
while(enun.hasMoreElements())
{
One one=(One)enun.nextElement();
if(one.color!=one.BLANK)
{
if(one.color==one.BLACK)
g.setColor(Color.black);
else if(one.color==one.WHITE)
g.setColor(Color.white);
else
break; //如果盘里加满了棋子，则跳出循环
g.fillOval(one.posX-8,one.posY-8,interval-4,interval-4);
//路线长度
g.setColor(Color.black); //获取颜色
g.drawOval(one.posX-8,one.posY-8,interval-4,interval-4);
//画椭圆
}
}
g.setColor(Color.red); //画红点
g.fillOval(this.pointNow.x*20-5,this.pointNow.y*20-5,10,10);
//路线间隔
}
//处理每一步
void doStep(Point whatPoint,int whatColor)
{
//如果点在盘外，返回
if(whatPoint.x<1||whatPoint.x>19||whatPoint.y<1||whatPoint.y>19)
{
this.showError("不能下在此处");
this.errorFlag=true; //在棋盘外，出错
return;
}
//如果点上有子，则返回
if(((One)myHash.get(whatPoint)).color!=0)
{
this.showError("此处已有子");
this.errorFlag=true; //此点已经有棋子了，不能下
return;
}
//如果已经开劫了，则应先应劫，否则返回
if(this.isRob(whatPoint))
{
this.showError("已经开劫，请先应劫");
this.errorFlag=true;
return;
}
this.updateHash(whatPoint,whatColor); //我的棋子所在的地方
this.getRival(whatPoint,whatColor); //对手的棋子所在的地方
//如果没有气也没有己类
if(!this.isLink(whatPoint,whatColor)&&!this.isLink(whatPoint,0))
//0相当于ｏｎｅ．ＢＬＡＮＫ
{
this.showError("此处不可放子");
this.errorFlag=true;
this.singleRemove(whatPoint); //棋子所在的地方
return;//返回
}
this.pointNow.x=whatPoint.x;
this.pointNow.y=whatPoint.y; //得到当前红点
this.repaint(); //返回到当前的点
}
//取异类并判断执行吃子
void getRival(Point whatPoint,int whatColor)
{
boolean removeFlag=false; //判断这一步到底吃没吃子
One one;
one=(One)(this.myHash.get(whatPoint)); //确定该步的位置
Point otherPoint[]=one.pointAround; //该步周围的棋子
int i;
for(i=0;i<4;i++)
{
One otherOne=(One)(this.myHash.get(otherPoint[i]));//举出异类实例
if(!otherPoint[i].equals(one.OUT))
if(otherOne.color!=one.BLANK&&otherOne.color!=whatColor)
{
if(this.isRemove(otherPoint[i])) //如果有气
this.vec.clear(); //不吃子
else
{
this.makeRobber(otherPoint[i]);
this.doRemove(); //进行吃子行为
this.vec.clear(); //改点被清空
removeFlag=true; //返回
}
}
}
if(!removeFlag)
this.robPoint=null; //如果没吃子的话消掉打劫点
}
//判断是否因打劫不能下
boolean isRob(Point p)
{
if(this.robPoint==null) //打劫点不存在
return false; //返回错误
if(this.robPoint.x==p.x&&this.robPoint.y==p.y) //打劫点存在进行判断
return true; //返回正确
return false; //返回错误
}
//建立打劫点
void makeRobber(Point point)
{
if(this.vec.size()==1)
this.robPoint=point; //建立新打劫点
else
this.robPoint=null; //吃多个的话消掉打劫点
}
//判断吃子
boolean isRemove(Point point)
{
if(this.vec.contains(point))
return false;
if(this.isLink(point,0)) //有气的话
return true;
this.vec.add(point); //没有气就加入这个点
One one;
one=(One)(this.myHash.get(point)); //创建新的点
Point otherPoint[]=one.pointAround; //新的点周围的棋子
int i;
for(i=0;i<4;i++)
{
One otherOne=(One)(this.myHash.get(otherPoint[i]));//举出同类实例
if(!otherPoint[i].equals(one.OUT)) //如果周围的点不等同于输入点的颜色
if(otherOne.color==one.color) //如果周围的点是颜色相同
if(this.isRemove(otherPoint[i])) //这里递归，移除
return true;
}
return false;
}
//执行消子
void doRemove() //执行消棋子的步骤
{
Enumeration enun=this.vec.elements(); //列出各种情况
while(enun.hasMoreElements())
{
Point point=(Point)enun.nextElement(); //指向下一个元素
this.singleRemove(point); //单独移除的点
}
}
//消单个子
void singleRemove(Point point)
{
One one=(One)(this.myHash.get(point));
one.isthere=false;
one.color=one.BLANK;
Graphics g=this.getGraphics();
g.clearRect(point.x*20-8,point.y*20-8,20,20); //删除画面上的子
}
//判断有气
boolean isLink(Point point,int color) //进行判断是否有气
{
One one;
one=(One)(this.myHash.get(point)); //新输入的点
Point otherPoint[]=one.pointAround; //周围的点
int i;
for(i=0;i<4;i++)
{
One otherOne=(One)(this.myHash.get(otherPoint[i]));//举出同类实例
if(!otherPoint[i].equals(one.OUT)) //如果周围的点不等同于输入的点的颜色
if(otherOne.color==color) //如果周围的点颜色相同
{
return true; //返回TRUE
}
}
return false; //如果不满足，返回错误
}
//每一步更新myHash
void updateHash(Point whatPoint,int whatColor) //更新操作
{
One one=(One)(this.myHash.get(whatPoint)); //创建myHash
one.isthere=true; //所下的点符合
one.color=whatColor; //确定颜色
this.whichStep=this.whichStep+1; //走步增加1
one.whichStep=this.whichStep; //确定走步
}
Point getMousePoint(Point p1,Point p2) //p1为真实点，p2为相对原点
{
this.mousePoint.x=Math.round((float)(p1.x-p2.x)/this.INTERVAL);
//用四舍五入计算逻辑点位置
this.mousePoint.y=Math.round((float)(p1.y-p2.y)/this.INTERVAL);
//用四舍五入计算逻辑点位置
return this.mousePoint; //返回该位置
}
//显示错误信息
void showError(String errorMessage)
{
Graphics g=this.getGraphics(); //创建图g
g.setColor(new Color(236,190,98)); //定义错误信息的颜色
g.fillRect(20,400,30,200); //路线长度
g.setColor(Color.red); //画红点
g.drawString(errorMessage,60,415); //错误信息
g.fillOval(20,400,20,20); //路线间隔
}
private void jbInit() throws Exception //扔出错误
{
this.setBackground(new Color(236, 190, 120)); //背景色
}
}/*************************One************************/
import java.awt.*;
public class One
{
int BLACK=1;//定义黑子等于1
int WHITE=2;//定义白子为2
int BLANK=0;
Point OUT=new Point(-1,-1);
int whichStep;
int color=BLANK; //定义颜色
boolean isthere=false;//此处为错误的
Point pointAround[]={OUT,OUT,OUT,OUT};
int posX; //定义相邻点X
int posY; //定义相邻点Y
}/*******************GoApplet**************************/
import java.applet.*;
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;//引用相应的包
public class GoApplet extends Applet
{
public void init()//创建对象
{
new MainWindow().show();//主窗口
}
}/***********************Listen******************************/
import java.io.*;
import java.net.*;
public class Listen extends Thread //继承
{
Socket socket;
MainWindow mainWindow; //主窗口
public Listen(Socket socket,MainWindow mainWindow) //监听
{
this.socket=socket; //使用this区分成员变量和局部变量
this.mainWindow=mainWindow; //使用this区分成员变量和局部变量
}
public void run() //运行
{
try
{
this.activeListen(this.socket);
}
catch(IOException ioe){ //异常处理
this.mainWindow.panelGo.showError("意外中断");
}
}
void activeListen(Socket socket) throws IOException //活动监听者
{
BufferedReader reader=new BufferedReader(new InputStreamReader(socket.getInputStream()));
//缓冲流
String message; //键入通知
while(true)
{
message=reader.readLine(); //读入信息
this.mainWindow.doMessage(message); //在主窗口中执行读取的信息
}
}
}运行登录后的主界面如下：
时间： 2024-10-06 22:43:57