五子棋报告 java

时间：2024.4.2

XXXX大学

XX学院

课程设计报告

课程名称： 面向对象程序设计

题目名称： 五子棋游戏设计

学生姓名：

专业班级：

指导教师： 任晓强

一、课程设计目的与任务（四号、宋体、加黑、顶格）

（1）掌握Java编程、面向对象的基础知识。

（2）较熟练地编写Java应用程序Application。

（3）了解Java的常用标准类库、编程技巧、异常处理。

（4）联系已学过的内容，巩固所学的理论，增强独立工作能力。

（5）通过设计主要使学生有一个独立编写程序的过程，对理论学习及动手能力都有一个很大的提高。

（6）通过本次设计，进一步培养学生热爱专业的思想，同时对本专业综合素质的提高起一个积极的推动作用。

课程设计过程中，要严格遵守实践环节的时间安排，听从指导教师的指导。正确地完成上述内容，记录实习日记，规范完整地撰写出课程设计报告。

二、 课程设计内容

1 本设计题目的主要内容

设计一个15╳15围棋棋盘，由两玩家交替进行对战，并可以实现以下功能：

1.选择落子的先后顺序

2.重置棋盘

3.刷新重新开始

4.退出提示

并且规定退出者判为负，但退出过程中要有提示。以防不小心点错了。

最后判断某一方是否为五子连珠。

实现一个简单的多用户五子棋的游戏程序，包括如下两个界面

（1）选择对弈桌（执黑、执白）。

（2）在游戏界面，有开始，退出（游戏未结束、点退出自动判负）；

2 设计思想与程序构架

2.1 程序流程图

2.2 程序的功能分配

a. 棋盘的绘制

public void draw_qipan(Graphics G) //画棋盘 15*15{

G.setColor(Color.lightGray);

G.fill3DRect(10,10,300,300,true);

G.setColor(Color.black);

for(int i=1;i<16;i++){

G.drawLine(20,20*i,300,20*i);

G.drawLine(20*i,20,20*i,300);

}

b. 添加按钮

Button b1=new Button("开始");

Button b2=new Button("重置游戏");

Label lblWin=new Label(" ");

Checkbox ckbHB[]=new Checkbox[3];

Button exist = new Button("退出");

public void init(){

ckbHB[0]=new Checkbox("执白",ckgHB,false);

ckbHB[1]=new Checkbox("执黑",ckgHB,false);

ckbHB[2]=new Checkbox("观看",ckgHB, false);

}

c. 鼠标棋子的触发事件

public void mouseClicked(MouseEvent e) {

Graphics g=getGraphics();

int x1,y1;

x1=e.getX();

y1=e.getY();

if (e.getX()<20 || e.getX()>300 || e.getY()<20 || e.getY()>300) {

return;

}

if (x1%20>10) {

x1+=10;

}

if(y1%20>10) {

y1+=10;

}

x1=x1/20*20;

y1=y1/20*20;

set_Qizi(x1,y1);

m*=(-1);

}

d. 按钮的触发事件

public void actionPerformed(ActionEvent e) {

Graphics g=getGraphics();

if (e.getSource()==b1) {

Game_start();

}

else{

Game_re();

}

if(e.getSource()==exist){

Game_re();

lblWin.setText(Get_qizi_color(color_Qizi)+"输了!");

intGame_Start=0;

}

e. 判断落子的位置及画出相应的黑白棋子

public void set_Qizi(int x,int y) //落子{

if (intGame_Start==0) //判断游戏未开始{

return;

}

if (intGame_Body[x/20][y/20]!=0) {

return;

}

Graphics g=getGraphics();

if (color_Qizi==1)//判断黑子还是白子{

g.setColor(Color.black);

color_Qizi=0;

}

else{

g.setColor(Color.white);

color_Qizi=1;

}

g.fillOval(x-10,y-10,20,20);

intGame_Body[x/20][y/20]=color_Qizi+1;

｝

f. 判断胜负

if (Game_win_1(x/20,y/20)) //判断输赢1{

lblWin.setText(Get_qizi_color(color_Qizi)+"赢了!");

intGame_Start=0;

}

if (Game_win_2(x/20,y/20)) //判断输赢2{

lblWin.setText(Get_qizi_color(color_Qizi)+"赢了!");

intGame_Start=0;

}

if (Game_win_3(x/20,y/20)) //判断输赢3{

lblWin.setText(Get_qizi_color(color_Qizi)+"赢了!");

intGame_Start=0;

}

if (Game_win_4(x/20,y/20)) //判断输赢4{

lblWin.setText(Get_qizi_color(color_Qizi)+"赢了!");

intGame_Start=0;

}

3 软件使用说明书

按提示操作

4 序测试及分析

a. 进入游戏界面

游戏开始的界面有三个选择项，用户可以选择相应的角色，选择完毕后点击开始进入游戏。

b. 选择角色，开始下棋

首先达到五个棋子连在一块的赢了，并在红色区域显示谁赢了！

c. 下完后，重新开始

下完一盘后游戏停止，点击重新开始，界面回到初始界面，选择角色继续游戏.

d.游戏中点退出，自动判输

在下棋的过程当中谁中途退出，即点击退出，系统自动判断谁输

5 设计总结

通过此次课程设计，将我本学期所学的JAVA知识得到巩固和应用，在设计的过程中我遇到了很到问题，不过在老师和同学们的帮助和自己的思考下还是很好的完成了。这此课程设计还让我懂得了写程序不能闭门造车，要努力拓宽知识面，开阔视野，拓展思维。它还让我学会了在网上查阅那些无限的资料。由于自己的分析设计和程序经验不足，该系统设计和实现过程中，还有许多没有完善的地方，比如用户界面设计不够美观，异常出错处理比较差等多方面问题，这些都有待进一步完善和提高。对于文中出现的不足和系统中出现的问题敬请老师指导。

三、附录

创建棋盘类

Public class WcyChess extends Applet implements ActionListener,MouseListener,MouseMotionListener,ItemListener{

int color_Qizi=0;//旗子的颜色标识 0:白子 1:黑子

int intGame_Start=0;//游戏开始标志 0未开始 1游戏中

int intGame_Body[][]=new int[16][16]; //设置棋盘棋子状态

int m=-1;

Button b1=new Button("开始");

Button b2=new Button("重置游戏");

Label lblWin=new Label(" ");

Checkbox ckbHB[]=new Checkbox[3];

Button exist = new Button("退出");

CheckboxGroup ckgHB=new CheckboxGroup();

NetchatClient chat=new NetchatClient();

public void init(){

setLayout(null);

addMouseListener(this);

add(b1);

b1.setBounds(330,50,80,30);

b1.addActionListener(this);

add(b2);

b2.setBounds(330,90,80,30);

b2.addActionListener(this);

ckbHB[0]=new Checkbox("执白",ckgHB,false);

ckbHB[0].setBounds(320,20,60,30);

ckbHB[1]=new Checkbox("执黑",ckgHB,false);

ckbHB[1].setBounds(380,20,60,30);

ckbHB[2]=new Checkbox("观看",ckgHB, false);

add(ckbHB[0]);

add(ckbHB[1]);

add(ckbHB[2]);

ckbHB[0].addItemListener(this);

ckbHB[1].addItemListener(this);

add(lblWin);

lblWin.setBounds(330,180,80,30);

lblWin.setBackground(Color.red);

lblWin.setText("胜利者！");//没有显示？

ckbHB[2].setBounds(440, 20,60, 30);

add(exist);

exist.setBounds(330,130,80,30);

exist.addActionListener(this);

// add(chat);chat.setBounds(20, 500, 300, 300);

chat.frame();

chat.setVisible(true);

Game_start_csh();

setSize(500,600);

setVisible(true);

}

public void itemStateChanged(ItemEvent e) {

if (ckbHB[0].getState()) //选择黑子还是白子{

color_Qizi=0;

}

else{

color_Qizi=1;

}

public void mousePressed(MouseEvent e){}

public void mouseClicked(MouseEvent e) {

Graphics g=getGraphics();

int x1,y1;

x1=e.getX();

y1=e.getY();

if (e.getX()<20 || e.getX()>300 || e.getY()<20 || e.getY()>300) {

return;

}

if (x1%20>10) {

x1+=10;

}

if(y1%20>10) {

y1+=10;

}

x1=x1/20*20;

y1=y1/20*20;

set_Qizi(x1,y1);

m*=(-1);

}

public void actionPerformed(ActionEvent e) {

Graphics g=getGraphics();

if (e.getSource()==b1) {

Game_start();

}

else {

Game_re();

}

if(e.getSource()==exist){

Game_re();

lblWin.setText(Get_qizi_color(color_Qizi)+"输了!");

intGame_Start=0;

}

public void mouseEntered(MouseEvent e){}

public void mouseExited(MouseEvent e){}

public void mouseReleased(MouseEvent e){}

public void mouseDragged(MouseEvent e){}

public void mouseMoved(MouseEvent e){}

public void paint(Graphics g) {

draw_qipan(g);

}

判断输赢功能实现

if (Game_win_1(x/20,y/20)){ //判断输赢1

lblWin.setText(Get_qizi_color(color_Qizi)+"赢了!");

intGame_Start=0;

}

if (Game_win_2(x/20,y/20))｛ //判断输赢2

lblWin.setText(Get_qizi_color(color_Qizi)+"赢了!");

intGame_Start=0;

}

if (Game_win_3(x/20,y/20)) //判断输赢3{

lblWin.setText(Get_qizi_color(color_Qizi)+"赢了!");

intGame_Start=0;

}

if (Game_win_4(x/20,y/20)) //判断输赢4{

lblWin.setText(Get_qizi_color(color_Qizi)+"赢了!");

intGame_Start=0;

}

四、 主要参考资料

1. 吴其庆编著.Java程序设计实例教程.北京：冶金工业出版社

2. 柳西玲.许斌编著.Java语言应用开发基础.北京：清华大学出版社

3．丁振凡 Java 语言实用教程：北京邮电大学出版社

第二篇：java+五子棋报告(完整版)

下面的源代码分为4个文件；

(2)chessInterface.java:客户端的界面。

(3)chessPad.java:棋盘的绘制。

(4)chessServer.java:服务器端。

可同时容纳50个人同时在线下棋，聊天。

public void acceptMessage(String recMessage)

{

if(recMessage.startsWith("/userlist "))

{

StringTokenizer userToken=new StringTokenizer(recMessage," ");

int userNumber=0;

chessclient.userpad.userList.removeAll();

chessclient.inputpad.userChoice.removeAll();

chessclient.inputpad.userChoice.addItem("所有人");

while(userToken.hasMoreTokens())

{

String user=(String)userToken.nextToken(" ");

if(userNumber>0 && !user.startsWith("[inchess]"))

{

chessclient.userpad.userList.add(user);

chessclient.inputpad.userChoice.addItem(user);

}

userNumber++;

}

chessclient.inputpad.userChoice.select("所有人");

}

else if(recMessage.startsWith("/yourname "))

{

chessclient.chessClientName=recMessage.substring(10);

chessclient.setTitle("Java五子棋客户端 "+"用户名:"+chessclient.chessClientName); }

else if(recMessage.equals("/reject"))

{

try

{

chessclient.chesspad.statusText.setText("不能加入");

chessclient.controlpad.cancelGameButton.setEnabled(false);

chessclient.controlpad.joinGameButton.setEnabled(true);

chessclient.controlpad.creatGameButton.setEnabled(true);

}

catch(Exception ef)

{

chessclient.chatpad.chatLineArea.setText("chessclient.chesspad.chessSocket.close无法关闭");

}

chessclient.controlpad.joinGameButton.setEnabled(true);

}

else if(recMessage.startsWith("/peer "))

{

chessclient.chesspad.chessPeerName=recMessage.substring(6);

if(chessclient.isServer)

{

chessclient.chesspad.chessColor=1;

chessclient.chesspad.isMouseEnabled=true;

chessclient.chesspad.statusText.setText("请黑棋下子");

}

else if(chessclient.isClient)

{

chessclient.chesspad.chessColor=-1;

chessclient.chesspad.statusText.setText("已加入游戏，等待对方下子...");

}

else if(recMessage.equals("/youwin"))

{

chessclient.isOnChess=false;

chessclient.chesspad.chessVictory(chessclient.chesspad.chessColor);

chessclient.chesspad.statusText.setText("对方退出，请点放弃游戏退出连接");

chessclient.chesspad.isMouseEnabled=false;

}

else if(recMessage.equals("/OK"))

{

chessclient.chesspad.statusText.setText("创建游戏成功，等待别人加入...");

}

else if(recMessage.equals("/error"))

{

chessclient.chatpad.chatLineArea.append("传输错误：请退出程序，重新加入 \n"); }

else

{

chessclient.chatpad.chatLineArea.append(recMessage+"\n");

chessclient.chatpad.chatLineArea.setCaretPosition(

chessclient.chatpad.chatLineArea.getText().length());

}

public void run()

{

String message="";

try

{

while(true)

{

message=chessclient.in.readUTF();

acceptMessage(message);

}

catch(IOException es)

{

}

public class chessClient extends Frame implements ActionListener,KeyListener {

userPad userpad=new userPad();

chatPad chatpad=new chatPad();

controlPad controlpad=new controlPad();

chessPad chesspad=new chessPad();

inputPad inputpad=new inputPad();

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 northPanel=new Panel();

Panel centerPanel=new Panel();

Panel westPanel=new Panel();

Panel eastPanel=new Panel();

chessClient()

{

super("Java五子棋客户端");

setLayout(new BorderLayout());

host=controlpad.inputIP.getText();

westPanel.setLayout(new BorderLayout());

westPanel.add(userpad,BorderLayout.NORTH); westPanel.add(chatpad,BorderLayout.CENTER); westPanel.setBackground(Color.pink);

inputpad.inputs.addKeyListener(this);

chesspad.host=controlpad.inputIP.getText();

centerPanel.add(chesspad,BorderLayout.CENTER); centerPanel.add(inputpad,BorderLayout.SOUTH); centerPanel.setBackground(Color.pink);

controlpad.connectButton.addActionListener(this); controlpad.creatGameButton.addActionListener(this); controlpad.joinGameButton.addActionListener(this); controlpad.cancelGameButton.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(Color.pink);

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);

}

public void windowActivated(WindowEvent ea) {

}

});

add(westPanel,BorderLayout.WEST);

add(centerPanel,BorderLayout.CENTER); add(southPanel,BorderLayout.SOUTH);

pack();

setSize(670,548);

setVisible(true);

setResizable(false);

validate();

}

public boolean connectServer(String serverIP,int serverPort) throws Exception

{

try

{

chatSocket=new Socket(serverIP,serverPort);

in=new DataInputStream(chatSocket.getInputStream());

out=new DataOutputStream(chatSocket.getOutputStream());

clientThread clientthread=new clientThread(this);

clientthread.start();

isOnChat=true;

return true;

}

catch(IOException ex)

{

chatpad.chatLineArea.setText("chessClient:connectServer:无法连接,建议重新启动程序 \n");

}

return false;

}

public void actionPerformed(ActionEvent e)

{

if(e.getSource()==controlpad.connectButton)

{

host=chesspad.host=controlpad.inputIP.getText();

try

{

if(connectServer(host,port))

{

chatpad.chatLineArea.setText("");

controlpad.connectButton.setEnabled(false);

controlpad.creatGameButton.setEnabled(true);

controlpad.joinGameButton.setEnabled(true);

chesspad.statusText.setText("连接成功，请创建游戏或加入游戏");

}

catch(Exception ei)

{

chatpad.chatLineArea.setText("controlpad.connectButton:无法连接,建议重新启动程序 \n");

}

if(e.getSource()==controlpad.exitGameButton)

{

if(isOnChat)

{

try

{

chatSocket.close();

}

catch(Exception ed)

{

}

if(isOnChess || isGameConnected)

{

try

{

chesspad.chessSocket.close();

}

catch(Exception ee)

{

}

System.exit(0);

}

if(e.getSource()==controlpad.joinGameButton)

{

String selectedUser=userpad.userList.getSelectedItem();

if(selectedUser==null || selectedUser.startsWith("[inchess]") || selectedUser.equals(chessClientName))

{

chesspad.statusText.setText("必须先选定一个有效用户"); }

else

{

try

{

if(!isGameConnected)

{

if(chesspad.connectServer(chesspad.host,chesspad.port)) {

isGameConnected=true;

isOnChess=true;

isClient=true;

controlpad.creatGameButton.setEnabled(false);

controlpad.joinGameButton.setEnabled(false);

controlpad.cancelGameButton.setEnabled(true);

chesspad.chessthread.sendMessage("/joingame "+userpad.userList.getSelectedItem()+" "+chessClientName);

}

else

{

isOnChess=true;

isClient=true;

controlpad.creatGameButton.setEnabled(false);

controlpad.joinGameButton.setEnabled(false);

controlpad.cancelGameButton.setEnabled(true);

chesspad.chessthread.sendMessage("/joingame "+userpad.userList.getSelectedItem()+" "+chessClientName);

}

catch(Exception ee)

{

isGameConnected=false;

isOnChess=false;

isClient=false;

controlpad.creatGameButton.setEnabled(true);

controlpad.joinGameButton.setEnabled(true);

controlpad.cancelGameButton.setEnabled(false);

chatpad.chatLineArea.setText("chesspad.connectServer无法连接 \n"+ee);

}

if(e.getSource()==controlpad.creatGameButton)

{

try

{

if(!isGameConnected)

{

if(chesspad.connectServer(chesspad.host,chesspad.port))

{

isGameConnected=true;

isOnChess=true;

isServer=true;

controlpad.creatGameButton.setEnabled(false);

controlpad.joinGameButton.setEnabled(false);

controlpad.cancelGameButton.setEnabled(true);

chesspad.chessthread.sendMessage("/creatgame "+"[inchess]"+chessClientName); }

}

else

{

isOnChess=true;

isServer=true;

controlpad.creatGameButton.setEnabled(false);

controlpad.joinGameButton.setEnabled(false);

controlpad.cancelGameButton.setEnabled(true);

chesspad.chessthread.sendMessage("/creatgame "+"[inchess]"+chessClientName); }

}

catch(Exception ec)

{

isGameConnected=false;

isOnChess=false;

isServer=false;

controlpad.creatGameButton.setEnabled(true);

controlpad.joinGameButton.setEnabled(true);

controlpad.cancelGameButton.setEnabled(false);

ec.printStackTrace();

chatpad.chatLineArea.setText("chesspad.connectServer无法连接 \n"+ec); }

}

if(e.getSource()==controlpad.cancelGameButton)

{

if(isOnChess)

{

chesspad.chessthread.sendMessage("/giveup "+chessClientName);

chesspad.chessVictory(-1*chesspad.chessColor);

controlpad.creatGameButton.setEnabled(true);

controlpad.joinGameButton.setEnabled(true);

controlpad.cancelGameButton.setEnabled(false);

chesspad.statusText.setText("请建立游戏或者加入游戏");

}

if(!isOnChess)

{

controlpad.creatGameButton.setEnabled(true);

controlpad.joinGameButton.setEnabled(true);

controlpad.cancelGameButton.setEnabled(false);

chesspad.statusText.setText("请建立游戏或者加入游戏");

}

isClient=isServer=false;

}

public void keyPressed(KeyEvent e)

{

TextField inputWords=(TextField)e.getSource();

if(e.getKeyCode()==KeyEvent.VK_ENTER)

{

if(inputpad.userChoice.getSelectedItem().equals("所有人"))

{

try

{

out.writeUTF(inputWords.getText());

inputWords.setText("");

}

catch(Exception ea)

{

chatpad.chatLineArea.setText("chessClient:KeyPressed无法连接,建议重新连接 \n"); userpad.userList.removeAll();

inputpad.userChoice.removeAll();

inputWords.setText("");

controlpad.connectButton.setEnabled(true);

}

else

{

try

{

out.writeUTF("/"+inputpad.userChoice.getSelectedItem()+" "+inputWords.getText()); inputWords.setText("");

}

catch(Exception ea)

{

chatpad.chatLineArea.setText("chessClient:KeyPressed无法连接,建议重新连接 \n"); userpad.userList.removeAll();

inputpad.userChoice.removeAll();

inputWords.setText("");

controlpad.connectButton.setEnabled(true);

}

public void keyTyped(KeyEvent e)

{

}

public void keyReleased(KeyEvent e)

{

}

public static void main(String args[])

{

chessClient chessClient=new chessClient();

}

/****************************************************************************************** 下面是：chessInteface.java

******************************************************************************************/

import java.awt.*;

import java.awt.event.*;

import java.io.*;

import java.net.*;

class userPad extends Panel

{

List userList=new List(10);

userPad()

{

setLayout(new BorderLayout());

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

{

userList.add(i+"."+"没有用户");

}

add(userList,BorderLayout.CENTER);

}

class chatPad extends Panel

{

TextArea

TextArea("",18,30,TextArea.SCROLLBARS_VERTICAL_ONLY);

chatPad()

{

setLayout(new BorderLayout());

add(chatLineArea,BorderLayout.CENTER);

}

class controlPad extends Panel

{

Label IPlabel=new Label("IP",Label.LEFT);

TextField inputIP=new TextField("localhost",10);

Button connectButton=new Button("连接主机");

Button creatGameButton=new Button("建立游戏");

Button joinGameButton=new Button("加入游戏");

Button cancelGameButton=new Button("放弃游戏");

Button exitGameButton=new Button("关闭程序");

controlPad()

{

setLayout(new FlowLayout(FlowLayout.LEFT));

setBackground(Color.pink);

chatLineArea=new

add(IPlabel);

add(inputIP);

add(connectButton);

add(creatGameButton);

add(joinGameButton);

add(cancelGameButton);

add(exitGameButton);

}

class inputPad extends Panel

{

TextField inputWords=new TextField("",40);

Choice userChoice=new Choice();

inputPad()

{

setLayout(new FlowLayout(FlowLayout.LEFT));

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

{

userChoice.addItem(i+"."+"没有用户");

}

userChoice.setSize(60,24);

add(userChoice);

add(inputWords);

}

/********************************************************************************************** 下面是：chessPad.java

**********************************************************************************************/ import java.awt.*;

import java.awt.event.*;

import java.io.*;

import java.net.*;

import java.util.*;

class chessThread extends Thread

{

chessPad chesspad;

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)

{

if(recMessage.startsWith("/chess "))

{

StringTokenizer userToken=new StringTokenizer(recMessage," ");

String chessToken;

String[] chessOpt={"-1","-1","0"};

int chessOptNum=0;

while(userToken.hasMoreTokens())

{

chessToken=(String)userToken.nextToken(" ");

if(chessOptNum>=1 && chessOptNum<=3)

{

chessOpt[chessOptNum-1]=chessToken;

}

chessOptNum++;

}

chesspad.netChessPaint(Integer.parseInt(chessOpt[0]),Integer.parseInt(chessOpt[1]),Integer.parseInt(chessOpt[2]));

}

else if(recMessage.startsWith("/yourname "))

{

TextField statusText=new TextField("请先连接服务器");

Socket chessSocket;

DataInputStream inData;

DataOutputStream outData;

String chessSelfName=null;

String chessPeerName=null;

String host=null;

int port=4331;

chessThread chessthread=new chessThread(this);

chessPad()

{

setSize(440,440);

setLayout(null);

setBackground(Color.pink);

addMouseListener(this);

add(statusText);

statusText.setBounds(40,5,360,24);

statusText.setEditable(false);

}

public boolean connectServer(String ServerIP,int ServerPort) throws Exception {

try

{

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);

}

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+"

"+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

{

chessthread.sendMessage("/"+chessPeerName+"

"+chessPoint_b+" "+color); /chess "+chessPoint_a+" /chess "+chessPoint_a+"

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+"

"+chessPoint_b+" "+color);

/chess "+chessPoint_a+"

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) {}

public void actionPerformed(ActionEvent e)

{

}

class chessPoint_black extends Canvas implements MouseListener {

chessPad chesspad=null;

chessPoint_black(chessPad p)

{

setSize(20,20);

chesspad=p;

addMouseListener(this);

}

public void paint(Graphics g)

{

g.setColor(Color.black);

g.fillOval(0,0,14,14);

}

public void mousePressed(MouseEvent e)

{

// if(e.getModifiers()==InputEvent.BUTTON3_MASK)

// {

// chesspad.remove(this);

// chesspad.chessColor=1;

// chesspad.text_2.setText("");

// chesspad.text_1.setText("请黑棋下子");

// }

}

public void mouseReleased(MouseEvent e){}

public void mouseEntered(MouseEvent e) {}

public void mouseExited(MouseEvent e) {}

public void mouseClicked(MouseEvent e) {}

}

class chessPoint_white extends Canvas implements MouseListener {

chessPad chesspad=null;

chessPoint_white(chessPad p)

TextArea

TextArea("",22,50,TextArea.SCROLLBARS_VERTICAL_ONLY);

Label statusLabel=new Label("当前连接数:",Label.LEFT);

Panel boardPanel=new Panel();

Panel statusPanel=new Panel();

MessageServer()

{

setSize(350,300);

setBackground(Color.pink);

setLayout(new BorderLayout());

boardPanel.setLayout(new FlowLayout());

boardPanel.setSize(210,210);

statusPanel.setLayout(new BorderLayout());

statusPanel.setSize(210,50);

boardPanel.add(messageBoard);

statusPanel.add(statusLabel,BorderLayout.WEST);

add(boardPanel,BorderLayout.CENTER);

add(statusPanel,BorderLayout.NORTH);

}

class ServerThread extends Thread

{

Socket clientSocket;

Hashtable clientDataHash;

Hashtable clientNameHash;

Hashtable chessPeerHash;

MessageServer server;

boolean isClientClosed=false;

ServerThread(Socket clientSocket,Hashtable messageBoard=new clientDataHash,Hashtable clientNameHash,Hashtable chessPeerHash,MessageServer server)

{

this.clientSocket=clientSocket;

this.clientDataHash=clientDataHash;

this.clientNameHash=clientNameHash;

this.chessPeerHash=chessPeerHash;

this.server=server;

}

public void messageTransfer(String message)

{

String clientName,peerName;

if(message.startsWith("/"))

{

if(message.startsWith("/changename "))

{

clientName=message.substring(12);

if( clientName.length()<=0 || clientName.length()>20 ||

clientName.startsWith("/") || clientNameHash.containsValue(clientName) ||

clientName.startsWith("changename")|| clientName.startsWith("list") ||

clientName.startsWith("[inchess]") || clientName.startsWith("creatgame") ||

clientName.startsWith("joingame") || clientName.startsWith("yourname") ||

clientName.startsWith("userlist") || clientName.startsWith("chess") ||

clientName.startsWith("OK") || clientName.startsWith("reject") ||

clientName.startsWith("peer") || clientName.startsWith("peername") ||

clientName.startsWith("giveup") || clientName.startsWith("youwin") ||

clientName.startsWith("所有人"))

{

message="无效命令";

Feedback(message);

}

else

{

if(clientNameHash.containsValue(("[inchess]"+(String)clientNameHash.get(clientSocket)))) {

synchronized(clientNameHash)

{

clientNameHash.put((Socket)getHashKey(clientNameHash,("[inchess]"+clientNameHash.get(clientSocket))),

("[inchess]"+clientName));

chessPeerTalk(("[inchess]"+clientName),("/yourname "+("[inchess]"+clientName))); }

}

else if(chessPeerHash.containsKey(clientNameHash.get(clientSocket)))

{

//游戏客户端改名字

synchronized(clientNameHash)

{

clientNameHash.put((Socket)getHashKey(clientNameHash,("[inchess]"+clientNameHash.get(clientSocket))),

("[inchess]"+clientName));

}

synchronized(chessPeerHash)

{

//chessPeerHash添加新名字映射

chessPeerHash.put(clientName,chessPeerHash.get(clientNameHash.get(clientSocket))); //chessPeerHash删除旧映射

chessPeerHash.remove(clientNameHash.get(clientSocket));

}

//向游戏客户端发送新名字

chessPeerTalk(("[inchess]"+clientName),("/yourname "+("[inchess]"+clientName))); //向peer游戏客户端发送

chessPeerTalk((String)chessPeerHash.get(clientName),("/peer

"+"[inchess]"+clientName));

}

else if(chessPeerHash.containsValue(clientNameHash.get(clientSocket)))

{

synchronized(clientNameHash)

{

//游戏客户端改名字

clientNameHash.put((Socket)getHashKey(clientNameHash,("[inchess]"+clientNameHash.get(clientSocket))),

("[inchess]"+clientName));

}

synchronized(chessPeerHash)

{

//chessPeerHash重新映射

chessPeerHash.put((String)getHashKey(chessPeerHash,clientNameHash.get(clientSocket)),clientName);

//向游戏客户端发送新名字

chessPeerTalk(("[inchess]"+clientName),("/yourname "+("[inchess]"+clientName))); }

//向peer游戏客户端发送

chessPeerTalk((String)getHashKey(chessPeerHash,clientName),("/peer

"+"[inchess]"+clientName));

}

message=clientNameHash.get(clientSocket)+"改名为:"+clientName;

synchronized(clientNameHash)

{

clientNameHash.put(clientSocket,clientName);

}

publicTalk(message);

Feedback("/yourname "+(String)clientNameHash.get(clientSocket)); publicTalk(getUserList());

}

else if(message.equals("/list"))

{

Feedback(getUserList());

}

else if(message.startsWith("/creatgame [inchess]"))

{

String chessServerName=message.substring(20);

synchronized(clientNameHash)

{

clientNameHash.put(clientSocket,message.substring(11)); }

synchronized(chessPeerHash)

{

chessPeerHash.put(chessServerName,"wait");

}

Feedback("/yourname "+clientNameHash.get(clientSocket)); chessNameOpt[getOptNum-1]=getUserToken;

}

getOptNum++;

chessPeerHash.put(serverName,selfName);

}

publicTalk(getUserList());

chessPeerTalk(selfName,("/peer "+"[inchess]"+serverName)); chessPeerTalk(serverName,("/peer "+"[inchess]"+selfName)); }

else

{

chessPeerTalk(selfName,"/reject");

try

{

clientClose();

}

catch(Exception ez)

{

}

else if(message.startsWith("/[inchess]"))

{

int firstLocation=0,lastLocation;

lastLocation=message.indexOf(" ",0);

peerName=message.substring((firstLocation+1),lastLocation);

message=message.substring((lastLocation+1));

if(chessPeerTalk(peerName,message))

{

Feedback("/error");

}

else if(message.startsWith("/giveup "))

{

String chessClientName=message.substring(8);

if(chessPeerHash.containsKey(chessClientName)

&& !((String)chessPeerHash.get(chessClientName)).equals("wait"))

{

chessPeerTalk((String)chessPeerHash.get(chessClientName),"/youwin"); synchronized(chessPeerHash)

{

chessPeerHash.remove(chessClientName);

}

if(chessPeerHash.containsValue(chessClientName))

{

chessPeerTalk((String)getHashKey(chessPeerHash,chessClientName),"/youwin"); synchronized(chessPeerHash)

{

chessPeerHash.remove((String)getHashKey(chessPeerHash,chessClientName)); }

}

else

{

int firstLocation=0,lastLocation;

lastLocation=message.indexOf(" ",0);

if(lastLocation==-1)

{

Feedback("无效命令");

return;

}

else

{

peerName=message.substring((firstLocation+1),lastLocation);

message=message.substring((lastLocation+1));

message=(String)clientNameHash.get(clientSocket)+">"+message;

if(peerTalk(peerName,message))

{

Feedback("没有这个用户:"+peerName+"\n");

}

else

{

message=clientNameHash.get(clientSocket)+">"+message;

server.messageBoard.append(message+"\n");

publicTalk(message);

server.messageBoard.setCaretPosition(server.messageBoard.getText().length()); }

}

public void publicTalk(String publicTalkMessage)

{

synchronized(clientDataHash)

{

for(Enumeration enu=clientDataHash.elements();enu.hasMoreElements();) {

DataOutputStream outData=(DataOutputStream)enu.nextElement();

try

{

outData.writeUTF(publicTalkMessage);

}

catch(IOException es)

eb.printStackTrace();

}

public String getUserList()

{

String userList="/userlist";

for(Enumeration enu=clientNameHash.elements();enu.hasMoreElements();) {

userList=userList+" "+(String)enu.nextElement();

}

return(userList);

}

public Object getHashKey(Hashtable targetHash,Object hashValue) {

Object hashKey;

for(Enumeration enu=targetHash.keys();enu.hasMoreElements();)

{

hashKey=(Object)enu.nextElement();

if(hashValue.equals((Object)targetHash.get(hashKey)))

return(hashKey);

}

return(null);

}

public void firstCome()

{

publicTalk(getUserList());

Feedback("/yourname "+(String)clientNameHash.get(clientSocket)); Feedback("Java五子棋聊天客户端");

Feedback("/changename <你的名字> --更改名字");

Feedback("/list --更新用户列表");

Feedback("/<用户名> <要说的话> --私聊");

Feedback("注意：用命令的时候，先把谈话的对象定为所有人");

}

public void clientClose()

{

server.messageBoard.append("用户断开:"+clientSocket+"\n");

//如果是游戏客户端主机

synchronized(chessPeerHash)

{

if(chessPeerHash.containsKey(clientNameHash.get(clientSocket)))

{

chessPeerHash.remove((String)clientNameHash.get(clientSocket));

}

if(chessPeerHash.containsValue(clientNameHash.get(clientSocket)))

{

chessPeerHash.put((String)getHashKey(chessPeerHash,(String)clientNameHash.get(clientSocket)),"tobeclosed");

}

synchronized(clientDataHash)

{

clientDataHash.remove(clientSocket);

}

synchronized(clientNameHash)

{

clientNameHash.remove(clientSocket);

}

publicTalk(getUserList());

server.statusLabel.setText("当前连接数:"+clientDataHash.size());

try

{

clientSocket.close();

}

catch(IOException exx)

{

}

isClientClosed=true;

}

public void run()

{

DataInputStream inData;

synchronized(clientDataHash)

{

server.statusLabel.setText("当前连接数:"+clientDataHash.size()); }

try

{

inData=new DataInputStream(clientSocket.getInputStream()); firstCome();

while(true)

{

String message=inData.readUTF();

messageTransfer(message);

}

catch(IOException esx)

{

}

finally

{

if(!isClientClosed)

{

clientClose();

}

public class chessServer extends Frame implements ActionListener {

Button messageClearButton=new Button("清除显示");

Button serverStatusButton=new Button("服务器状态");

Button serverOffButton=new Button("关闭服务器");

Panel buttonPanel=new Panel();

MessageServer server=new MessageServer();

ServerSocket serverSocket;

Hashtable clientDataHash=new Hashtable(50);

public void makeMessageServer(int port,MessageServer server) throws IOException {

Socket clientSocket;

long clientNumber=1;

this.server=server;

try

{

serverSocket=new ServerSocket(port);

server.messageBoard.setText("

while(true)

{

clientSocket=serverSocket.accept();

server.messageBoard.append("用户连接:"+clientSocket+"\n");

DataOutputStream outData=new DataOutputStream(clientSocket.getOutputStream());

clientDataHash.put(clientSocket,outData);

clientNameHash.put(clientSocket,("新来客"+clientAccessNumber++));

ServerThread thread=new ServerThread(clientSocket,clientDataHash,clientNameHash,chessPeerHash,server);

thread.start();

}

catch(IOException ex)

{

System.out.println("已经有服务器在运行. \n");

}

public void actionPerformed(ActionEvent e)

{

if(e.getSource()==messageClearButton)

{

server.messageBoard.setText("");

}

if(e.getSource()==serverStatusButton)

服务器开始于:"+serverSocket.getInetAddress().getLocalHost()+":"+serverSocket.getLocalPort()+"\n");

{

try

{

server.messageBoard.append("服务器信息:"+serverSocket.getInetAddress().getLocalHost()+":"+serverSocket.getLocalPort()+"\n"); }

catch(Exception ee)

{

System.out.println("serverSocket.getInetAddress().getLocalHost() error \n");

}

if(e.getSource()==serverOffButton)

{

System.exit(0);

}

public static void main(String args[])

{

chessServer chessServer=new chessServer();

}

更多相关推荐：

五子棋Java实验报告: 五子棋JAVA实验报告一实验目的和要求1能够用编程语言实现一个简单的五子棋程序2在实际系统中使用实现人工智能的相关算法3进一步加深对人工智能算法的理解二五子棋的基本常识与原理1五子棋的起源五子棋是一种两人对弈的...
java五子棋小游戏实验报告(附源代码): 手机五子棋游戏的设计与实现专业姓名班级学号指导教师基于J2ME的手机五子棋游戏摘要J2MEJava2MicroEdition是近年来随着各种不同设备尤其是移动通信设备的飞速发展而诞生的一项开发技术它因其writ...
Java五子棋实现报告: 一实验目的1使用Java编写五子棋程序2掌握编写过程的一些类和类成员的使用并且了解五子棋制作过程的一些步骤和了解一些算法二实验环境在电子楼2楼装有MyEclipse的计算机上进行三实验内容编写一个五子棋程序程序...
java 五子棋课程设计报告: 课程设计论文任务书班一课程设计论文题目多用户五子棋游戏二课程设计论文工作自20xx年6月15日起至20xx年6月19日止三课程设计论文地点创新大楼310四课程设计论文内容要求1本课程设计的目的数据类型对面向对象...
java五子棋项目报告: 河南经贸职业学院信息管理系Java程序设计课程设计报告Java语言程序设计课程设计报告题目设计者班级学号指导教师系部专业信息管理系计算机应用技术20xx年6月25日1河南经贸职业学院信息管理系Java程序设计课...
java课程设计报告-五子棋: 目录第一章软件开发平台游戏设计思路第二章小游戏五子棋的开发过程第一节JAVA基础知识第二节启动程序的分析第三节游戏设计过程第三章总结第四章参考文献第五章附录第一章游戏设计思路第二章第一节java程序基础知识本系...
五子棋Java实验报告 (1): JAVA实验报告课程名称JAVA程序设计教程实验题目五子棋院系公共管理学院信息管理系班级信息管理与信息系统一班学号20xx19xx25姓名谢巧婷五子棋JAVA实验报告一实验目的和要求1能够用编程语言实现一个简单...

Java五子棋设计报告: 南京晓庄学院JAVA程序设计课程设计报告题目五子棋游戏的设计与实现姓名陶野学号班级指导教师1213081812软件工程转本2班王峥完成时间7月1日成绩信息工程学院20xx年6月1目录1111112221引言1系...
java五子棋报告: 五子棋一程序功能介绍设计一个2020的五子棋盘由两个玩家交替下子并且可以实现以下功能1鼠标点击横竖线交汇处落子2通过落子使得五个黑子或者五个白子在一条横线竖线或斜线上2重新开始按钮刷新重新开始3检查是否实现了五...
java实现五子棋加服务器: 下面的源代码分为4个文件chessClientJava客户端主程序chessInterfaceJava客户端的界面chessPadJava棋盘的绘制chessServerJava服务器端可同时容纳50个人同时在...
java课程设计报告五子棋: 计算机网络技术专业专业代码590102动态网站基础程序设计课程设计班级网站1101班学号20xx274920xx317020xx039420xx483920xx264620xx264720xx361920xx2...

五子棋-Java课程设计: 课程设计报告简单的游戏五子棋小组成员姓名学号组长一实验分工二开发环境实验编译以及测试环境硬件环境CPUIntel奔腾双核E5200主频25GHz内存2G软件环境操作系统Windows7编程环境JDK70开发工具...

热门关注

五子棋游戏课程设计报告(含源代码可以运行)

Java课程设计-五子棋

五子棋游戏实验报告