java五子棋的源代码 java五子棋源代码及uml类图 _controlpad

急求Java五子棋代码。。。要绝对的原创（可以加分）java网络五子棋
下面的源代码分为4个文件；
chessClient.java:客户端主程序。
chessInterface.java:客户端的界面。
chessPad.java:棋盘的绘制。
chessServer.java:服务器端。
可同时容纳50个人同时在线下棋，聊天。
没有加上详细注释，不过绝对可以运行，j2sdk1.4下通过。
/*********************************************************************************************
1.chessClient.java
**********************************************************************************************/
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.net.*;
import java.util.*;
class clientThread extends Thread
{
chessClient chessclient;
clientThread(chessClient chessclient)
{
this.chessclient=chessclient;
}
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(userNumber0!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.inputWords.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;i50;i)
{
userList.add(i "." "没有用户");
}
add(userList,BorderLayout.CENTER);
}
}
class chatPad extends Panel
{
TextArea chatLineArea=new 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);
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;i50;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=1chessOptNum=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 "))
{
chesspad.chessSelfName=recMessage.substring(10);
}
else if(recMessage.equals("/error"))
{
chesspad.statusText.setText("错误:没有这个用户，请退出程序，重新加入");
}
else
{
//System.out.println(recMessage);
}
}
public void run()
{
String message="";
try
{
while(true)
{
message=chesspad.inData.readUTF();
acceptMessage(message);
}
}
catch(IOException es)
{
}
}
}
class chessPad extends Panel implements MouseListener,ActionListener
{
int chessPoint_x=-1,chessPoint_y=-1,chessColor=1;
int chessBlack_x[]=new int[200];
int chessBlack_y[]=new int[200];
int chessWhite_x[]=new int[200];
int chessWhite_y[]=new int[200];
int chessBlackCount=0,chessWhiteCount=0;
int chessBlackWin=0,chessWhiteWin=0;
boolean isMouseEnabled=false,isWin=false,isInGame=false;
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=https://www.04ip.com/post/new DataInputStream(chessSocket.getInputStream());
outData=https://www.04ip.com/post/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);
}
}
java 五子棋源代码在我的基础上加个悔棋判断胜负后把胜利的一方显示在屏幕上或别的标明胜利一方的谢我的设计是：
allChess[19][19] ;//19 * 19 的棋盘存放所有的棋子
0 -- 当前没有棋子
1 -- 黑子
2 -- 白子
比如： allChess[2][3]=2-- 第3行第4列为白子
如果想要悔棋的话，我的理解是这样的：
拿白子举例：
每下一个白子后，保存两个数组，连续下两次白子之后的数组，如果想悔棋，黑方确认之后，返回到上一次白子下后的数组。
楼主这样试试
JAVA设计的五子棋源程序import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.awt.geom.*;
import java.util.*;
class PaintPanel extends JPanel {
ArrayList Items = new ArrayList();
public PaintPanel() {
setLayout(new BorderLayout());
ButtonPanel buttonPanel = new ButtonPanel();
add(buttonPanel, BorderLayout.SOUTH);
addMouseListener(new MouseHandler());
}
public void paintComponent(Graphics g) {
int startX = 50;
int startY = 50;
boolean isMy = false;
super.paintComponent(g);
Graphics2D g2 = (Graphics2D)g;
for(int i=0; i16; i) {
g2.draw(new Line2D.Double(startX, startY 20*i, startX 300, startY 20*i));
g2.draw(new Line2D.Double(startX 20*i, startY, startX 20*i, startY 300));
}
for(int i=0; iItems.size(); i) {
isMy = !isMy;
if(isMy)
g2.setColor(Color.BLACK);
else
g2.setColor(Color.WHITE);
g2.fill((Ellipse2D)Items.get(i));
}
}
void myRepaint() {
repaint();
}
private class MouseHandler extends MouseAdapter {
public void mousePressed(MouseEvent event) {
int x = event.getX();
int y = event.getY();
paintItem(x, y);
repaint();
}
void paintItem(int x, int y) {
if(x50x350y 50y350) {
int X = x / 20;
int Y = y / 20;
int centerX = X*2010;
int centerY = Y*2010;
Ellipse2D ellipse = new Ellipse2D.Double();
ellipse.setFrameFromCenter(centerX, centerY, centerX 8, centerY 8);
Items.add(ellipse);
}
}
}
private class ButtonPanel extends JPanel {
public ButtonPanel() {
JButton reset = new JButton("Reset");
add(reset);
JButton quit = new JButton("Quit");
add(quit);
ResetEvent listenerR = new ResetEvent();
reset.addMouseListener(listenerR);
QuitEvent listenerQ = new QuitEvent();
quit.addMouseListener(listenerQ);
}
private class QuitEvent
extends MouseAdapter {
public void mouseClicked(MouseEvent event) {
System.exit(1);
}
}
private class ResetEvent
extends MouseAdapter {
public void mouseClicked(MouseEvent event) {
Items.clear();
myRepaint();
}
}
}
}
class GameFrame extends JFrame {
public GameFrame() {
setTitle("A Little Game");
setSize(400, 500);
setResizable(false);
PaintPanel panel = new PaintPanel();
getContentPane().add(panel);
}
} public class Game {
public static void main(String[] args) {
GameFrame frame = new GameFrame();
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.show();
}
}
//有缺陷java五子棋的源代码，需要更加完善
求一个简单的JAVA五子棋代码?。?网上复制的别来了！以下是现写的实现了两人对战自己复制后运行把没什么难度类名 Games
import java.util.Scanner;
public class Games {
private String board[][];
private static int SIZE = 17;
private static String roles = "A玩家";
//初始化数组
public void initBoard() {
board = new String[SIZE][SIZE];
for (int i = 0; iSIZE; i) {
for (int j = 0; jSIZE; j) {
//if(i==0){
//String str = "";
//str= j "";
//board[i][j]= str;
//}else if(i!=0j==0){
//String str = "";
//str= i "";
//board[i][j]= str;
//}else{
board[i][j] = "╋";
//}
}
}
}
//输出棋盘
public void printBoard() {
for (int i = 0; iSIZE; i) {
for (int j = 0; jSIZE; j) {
System.out.print(board[i][j]);
}
System.out.println();
}
}
//判断所下棋子位置是否合理
public boolean isOk(int x, int y) {
boolean isRight = true;
if (x = 16 || x1 || y = 16 | y1) {
//System.out.println("输入错误，请从新输入");
isRight = false;
}
if (board[x][y].equals("●") || board[x][y].equals("○")) {
isRight = false;
}
return isRight;
}
//判断谁赢了
public void whoWin(Games wz) {
// 从数组挨个查找找到某个类型的棋子就从该棋子位置向右，向下，斜向右下各查找5连续的位置看是否为5个相同的
int xlabel;// 记录第一次找到某个棋子的x坐标
int ylabel;// 记录第一次找到某个棋子的y坐标
// ●○╋
// 判断人是否赢了
for (int i = 0; iSIZE; i) {
for (int j = 0; jSIZE; j) {
if (board[i][j].equals("○")) {
xlabel = i;
ylabel = j;
// 横向找 x坐标不变 y坐标以此加1连成字符串
String heng = "";
if (i5SIZEj5SIZE) {
for (int k = j; kj5; k) {
heng= board[i][k];
}
if (heng.equals("○○○○○")) {
System.out.println(roles "赢了！您输了！");
System.exit(0);
}
// 向下判断y不变 x逐增5 连成字符串
String xia = "";
for (int l = j; li5; l) {
xia= board[l][j];
// System.out.println(xia);
}
if (xia.equals("○○○○○")) {
System.out.println(roles "赢了！您输了！");
System.exit(0);
}
// 斜向右下判断
String youxia = "";
for (int a = 1; a = 5; a) {
youxia= board[xlabel][ylabel];
}
if (youxia.equals("○○○○○")) {
System.out.println(roles "赢了！您输了！");
System.exit(0);
}
}
}
}
}
// 判断电脑是否赢了
for (int i = 0; iSIZE; i) {
for (int j = 0; jSIZE; j) {
if (board[i][j].equals("●")) {
xlabel = i;
ylabel = j;
// 横向找 x坐标不变 y坐标以此加1连成字符串
String heng = "";
if (j5SIZEi5SIZE) {
for (int k = j; kj5; k) {
heng= board[i][k];
}
if (heng.equals("●●●●●")) {
System.out.println(roles "赢输了！您输了！");
System.exit(0);
}
// 向下判断y不变 x逐增5 连成字符串
String xia = "";
for (int l = i; li5; l) {
xia= board[l][ylabel];
// System.out.println(xia);
}
if (xia.equals("●●●●●")) {
System.out.println(roles "赢了！您输了！");
System.exit(0);
}
// 斜向右下判断
String youxia = "";
for (int a = 1; a = 5; a) {
youxia= board[xlabel][ylabel];
}
if (youxia.equals("●●●●●")) {
System.out.println(roles "赢了！您输了！");
System.exit(0);
}
}
}
}
}
}
public static void main(String[] args) {
Games wz = new Games();
Scanner sc = new Scanner(System.in);
wz.initBoard();
wz.printBoard();
while (true) {
System.out.print("请" roles "输入X，Y坐标，必须在0－15范围内，xy以空格隔开,输入16 16结束程序");
int x = sc.nextInt();
int y = sc.nextInt();
if (x == SIZEy == SIZE) {
System.out.println("程序结束");
System.exit(0);
}
if (xSIZE || x0 || ySIZE | y0) {
System.out.println("输入错误，请从新输入");
continue;
}
//如果roles是A玩家就让A玩家下棋，否则就让B玩家下棋。
if (wz.board[x][y].equals("╋")roles.equals("A玩家")) {
wz.board[x][y] = "○";
wz.printBoard();
//判断输赢
wz.whoWin(wz);
}else if(wz.board[x][y].equals("╋")roles.equals("B玩家")){
wz.board[x][y] = "●";
wz.printBoard();
//判断输赢
wz.whoWin(wz);
} else {
System.out.println("此处已经有棋子,从新输入");
continue;
}
if(roles.equals("A玩家")){
roles = "B玩家";
}else if(roles.equals("B玩家")){
roles = "A玩家";
}
}
}
}
急?。。?Java五子棋源代码注释package org.liky.game.frame;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Toolkit;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
public class FiveChessFrame extends JFrame implements MouseListener, Runnable {
// 取得屏幕的宽度
int width = Toolkit.getDefaultToolkit().getScreenSize().width;
// 取得屏幕的高度
int height = Toolkit.getDefaultToolkit().getScreenSize().height;
// 背景图片
BufferedImage bgImage = null;
// 保存棋子的坐标
int x = 0;
int y = 0;
// 保存之前下过的全部棋子的坐标
// 其中数据内容 0：表示这个点并没有棋子，1：表示这个点是黑子， 2：表示这个点是白子
int[][] allChess = new int[19][19];
// 标识当前应该黑棋还是白棋下下一步
boolean isBlack = true;
// 标识当前游戏是否可以继续
boolean canPlay = true;
// 保存显示的提示信息
String message = "黑方先行";
// 保存最多拥有多少时间(秒)
int maxTime = 0;
// 做倒计时的线程类
Thread t = new Thread(this);
// 保存黑方与白方的剩余时间
int blackTime = 0;
int whiteTime = 0;
// 保存双方剩余时间的显示信息
String blackMessage = "无限制";
String whiteMessage = "无限制";
public FiveChessFrame() {
// 设置标题
this.setTitle("五子棋");
// 设置窗体大小
this.setSize(500, 500);
// 设置窗体出现位置
this.setLocation((width - 500) / 2, (height - 500) / 2);
// 将窗体设置为大小不可改变
this.setResizable(false);
// 将窗体的关闭方式设置为默认关闭后程序结束
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
// 为窗体加入监听器
this.addMouseListener(this);
// 将窗体显示出来
this.setVisible(true);
t.start();
t.suspend();
// 刷新屏幕,防止开始游戏时出现无法显示的情况.
this.repaint();
String imagePath = "" ;
try {
imagePath = System.getProperty("user.dir") "/bin/image/background.jpg" ;
bgImage = ImageIO.read(new File(imagePath.replaceAll("\\\\", "/")));
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public void paint(Graphics g) {
// 双缓冲技术防止屏幕闪烁
BufferedImage bi = new BufferedImage(500, 500,
BufferedImage.TYPE_INT_RGB);
Graphics g2 = bi.createGraphics();
g2.setColor(Color.BLACK);
// 绘制背景
g2.drawImage(bgImage, 1, 20, this);
// 输出标题信息
g2.setFont(new Font("黑体", Font.BOLD, 20));
g2.drawString("游戏信息："message, 130, 60);
// 输出时间信息
g2.setFont(new Font("宋体", 0, 14));
g2.drawString("黑方时间："blackMessage, 30, 470);
g2.drawString("白方时间："whiteMessage, 260, 470);
// 绘制棋盘
for (int i = 0; i19; i) {
g2.drawLine(10, 7020 * i, 370, 7020 * i);
g2.drawLine(1020 * i, 70, 1020 * i, 430);
}
// 标注点位
g2.fillOval(68, 128, 4, 4);
g2.fillOval(308, 128, 4, 4);
g2.fillOval(308, 368, 4, 4);
g2.fillOval(68, 368, 4, 4);
g2.fillOval(308, 248, 4, 4);
g2.fillOval(188, 128, 4, 4);
g2.fillOval(68, 248, 4, 4);
g2.fillOval(188, 368, 4, 4);
g2.fillOval(188, 248, 4, 4);
/*
* //绘制棋子 x = (x - 10) / 20 * 2010 ; y = (y - 70) / 20 * 2070 ;
* //黑子 g.fillOval(x - 7, y - 7, 14, 14); //白子 g.setColor(Color.WHITE) ;
* g.fillOval(x - 7, y - 7, 14, 14); g.setColor(Color.BLACK) ;
* g.drawOval(x - 7, y - 7, 14, 14);
*/
// 绘制全部棋子
for (int i = 0; i19; i) {
for (int j = 0; j19; j) {
if (allChess[i][j] == 1) {
// 黑子
int tempX = i * 2010;
int tempY = j * 2070;
g2.fillOval(tempX - 7, tempY - 7, 14, 14);
}
if (allChess[i][j] == 2) {
// 白子
int tempX = i * 2010;
int tempY = j * 2070;
g2.setColor(Color.WHITE);
g2.fillOval(tempX - 7, tempY - 7, 14, 14);
g2.setColor(Color.BLACK);
g2.drawOval(tempX - 7, tempY - 7, 14, 14);
}
}
}
g.drawImage(bi, 0, 0, this);
}
public void mouseClicked(MouseEvent e) {
// TODO Auto-generated method stub
}
public void mouseEntered(MouseEvent e) {
// TODO Auto-generated method stub
}
public void mouseExited(MouseEvent e) {
// TODO Auto-generated method stub
}
public void mousePressed(MouseEvent e) {
// TODO Auto-generated method stub
/*
* System.out.println("X:" e.getX()); System.out.println("Y:" e.getY());
*/
if (canPlay == true) {
x = e.getX();
y = e.getY();
if (x = 10x = 370y = 70y = 430) {
x = (x - 10) / 20;
y = (y - 70) / 20;
if (allChess[x][y] == 0) {
// 判断当前要下的是什么颜色的棋子
if (isBlack == true) {
allChess[x][y] = 1;
isBlack = false;
message = "轮到白方";
} else {
allChess[x][y] = 2;
isBlack = true;
message = "轮到黑方";
}
// 判断这个棋子是否和其他的棋子连成5连，即判断游戏是否结束
boolean winFlag = this.checkWin();
if (winFlag == true) {
JOptionPane.showMessageDialog(this, "游戏结束,"
(allChess[x][y] == 1 ? "黑方" : "白方")"获胜！");
canPlay = false;
}
} else {
JOptionPane.showMessageDialog(this, "当前位置已经有棋子，请重新落子！");
}
this.repaint();
}
}
/* System.out.println(e.getX()" -- "e.getY()); */
// 点击开始游戏按钮
if (e.getX() = 400e.getX() = 470e.getY() = 70
e.getY() = 100) {
int result = JOptionPane.showConfirmDialog(this, "是否重新开始游戏?");
if (result == 0) {
// 现在重新开始游戏
// 重新开始所要做的操作: 1)把棋盘清空,allChess这个数组中全部数据归0.
// 2) 将游戏信息: 的显示改回到开始位置
// 3) 将下一步下棋的改为黑方
for (int i = 0; i19; i) {
for (int j = 0; j19; j) {
allChess[i][j] = 0;
}
}
// 另一种方式 allChess = new int[19][19];
message = "黑方先行";
isBlack = true;
blackTime = maxTime;
whiteTime = maxTime;
if (maxTime0) {
blackMessage = maxTime / 3600":"
(maxTime / 60 - maxTime / 3600 * 60)":"
(maxTime - maxTime / 60 * 60);
whiteMessage = maxTime / 3600":"
(maxTime / 60 - maxTime / 3600 * 60)":"
(maxTime - maxTime / 60 * 60);
t.resume();
} else {
blackMessage = "无限制";
whiteMessage = "无限制";
}
this.canPlay = true;
this.repaint();
}
}
// 点击游戏设置按钮
if (e.getX() = 400e.getX() = 470e.getY() = 120
e.getY() = 150) {
String input = JOptionPane
.showInputDialog("请输入游戏的最大时间(单位:分钟),如果输入0,表示没有时间限制:");
try {
maxTime = Integer.parseInt(input) * 60;
if (maxTime0) {
JOptionPane.showMessageDialog(this, "请输入正确信息,不允许输入负数!");
}
if (maxTime == 0) {
int result = JOptionPane.showConfirmDialog(this,
"设置完成,是否重新开始游戏?");
if (result == 0) {
for (int i = 0; i19; i) {
for (int j = 0; j19; j) {
allChess[i][j] = 0;
}
}
// 另一种方式 allChess = new int[19][19];
message = "黑方先行";
isBlack = true;
blackTime = maxTime;
whiteTime = maxTime;
blackMessage = "无限制";
whiteMessage = "无限制";
this.canPlay = true;
this.repaint();
}
}
if (maxTime0) {
int result = JOptionPane.showConfirmDialog(this,
"设置完成,是否重新开始游戏?");
if (result == 0) {
for (int i = 0; i19; i) {
for (int j = 0; j19; j) {
allChess[i][j] = 0;
}
}
// 另一种方式 allChess = new int[19][19];
message = "黑方先行";
isBlack = true;
blackTime = maxTime;
whiteTime = maxTime;
blackMessage = maxTime / 3600":"
(maxTime / 60 - maxTime / 3600 * 60)":"
(maxTime - maxTime / 60 * 60);
whiteMessage = maxTime / 3600":"
(maxTime / 60 - maxTime / 3600 * 60)":"
(maxTime - maxTime / 60 * 60);
t.resume();
this.canPlay = true;
this.repaint();
}
}
} catch (NumberFormatException e1) {
// TODO Auto-generated catch block
JOptionPane.showMessageDialog(this, "请正确输入信息!");
}
}
// 点击游戏说明按钮
if (e.getX() = 400e.getX() = 470e.getY() = 170
e.getY() = 200) {
JOptionPane.showMessageDialog(this,
"这个一个五子棋游戏程序，黑白双方轮流下棋，当某一方连到五子时，游戏结束。");
}
// 点击认输按钮
if (e.getX() = 400e.getX() = 470e.getY() = 270
e.getY() = 300) {
int result = JOptionPane.showConfirmDialog(this, "是否确认认输?");
if (result == 0) {
if (isBlack) {
JOptionPane.showMessageDialog(this, "黑方已经认输,游戏结束!");
} else {
JOptionPane.showMessageDialog(this, "白方已经认输,游戏结束!");
}
canPlay = false;
}
}
// 点击关于按钮
if (e.getX() = 400e.getX() = 470e.getY() = 320
e.getY() = 350) {
JOptionPane.showMessageDialog(this,
"本游戏由MLDN制作，有相关问题可以访问");
}
// 点击退出按钮
if (e.getX() = 400e.getX() = 470e.getY() = 370
e.getY() = 400) {
JOptionPane.showMessageDialog(this, "游戏结束");
System.exit(0);
}
}
public void mouseReleased(MouseEvent e) {
// TODO Auto-generated method stub
}
private boolean checkWin() {
boolean flag = false;
// 保存共有相同颜色多少棋子相连
int count = 1;
// 判断横向是否有5个棋子相连，特点纵坐标是相同，即allChess[x][y]中y值是相同
int color = allChess[x][y];
/*
* if (color == allChess[x 1][y]) { count; if (color ==
* allChess[x 2][y]) { count; if (color == allChess[x 3][y]) {
* count; } } }
*/
// 通过循环来做棋子相连的判断
/*
* int i = 1; while (color == allChess[xi][y0]) { count; i; }
* i = 1; while (color == allChess[x - i][y - 0]) { count; i; } if
* (count = 5) { flag = true; } // 纵向的判断 int i2 = 1 ; int count2 = 1 ;
* while (color == allChess[x0][yi2]) { count2; i2; } i2 = 1;
* while (color == allChess[x - 0][y - i2]) { count2; i2; } if
* (count2 = 5) { flag = true ; } // 斜方向的判断（右上左下） int i3 = 1 ; int
* count3 = 1 ; while (color == allChess[xi3][y - i3]) { count3;
* i3; } i3 = 1; while (color == allChess[x - i3][yi3]) { count3;
* i3; } if (count3 = 5) { flag = true ; } // 斜方向的判断（右下左上） int i4 =
* 1 ; int count4 = 1 ; while (color == allChess[xi4][yi4]) {
* count4; i4; } i4 = 1; while (color == allChess[x - i4][y - i4]) {
* count4; i4; } if (count4 = 5) { flag = true ; }
*/
// 判断横向
count = this.checkCount(1, 0, color);
if (count = 5) {
flag = true;
} else {
// 判断纵向
count = this.checkCount(0, 1, color);
if (count = 5) {
flag = true;
} else {
// 判断右上、左下
count = this.checkCount(1, -1, color);
if (count = 5) {
flag = true;
} else {
// 判断右下、左上
count = this.checkCount(1, 1, color);
if (count = 5) {
flag = true;
}
}
}
}
return flag;
}
// 判断棋子连接的数量
private int checkCount(int xChange, int yChange, int color) {
int count = 1;
int tempX = xChange;
int tempY = yChange;
while (xxChange = 0xxChange = 18yyChange = 0
yyChange = 18
color == allChess[xxChange][yyChange]) {
count;
if (xChange != 0)
xChange;
if (yChange != 0) {
if (yChange0)
yChange;
else {
yChange--;
}
}
}
xChange = tempX;
yChange = tempY;
while (x - xChange = 0x - xChange = 18y - yChange = 0
y - yChange = 18
color == allChess[x - xChange][y - yChange]) {
count;
if (xChange != 0)
xChange;
if (yChange != 0) {
if (yChange0)
yChange;
else {
yChange--;
}
}
}
return count;
}
public void run() {
// TODO Auto-generated method stub
// 判断是否有时间限制
if (maxTime0) {
while (true) {
if (isBlack) {
blackTime--;
if (blackTime == 0) {
JOptionPane.showMessageDialog(this, "黑方超时,游戏结束!");
}
} else {
whiteTime--;
if (whiteTime == 0) {
JOptionPane.showMessageDialog(this, "白方超时,游戏结束!");
}
}
blackMessage = blackTime / 3600":"
(blackTime / 60 - blackTime / 3600 * 60)":"
(blackTime - blackTime / 60 * 60);
whiteMessage = whiteTime / 3600":"
(whiteTime / 60 - whiteTime / 3600 * 60)":"
(whiteTime - whiteTime / 60 * 60);
this.repaint();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(blackTime" -- "whiteTime);
}
}
}
}
用JAVA做五子棋源代码java网络五子棋
下面的源代码分为4个文件；
chessClient.java:客户端主程序。
chessInterface.java:客户端的界面。
chessPad.java:棋盘的绘制。
chessServer.java:服务器端。
可同时容纳50个人同时在线下棋，聊天。
没有加上详细注释，不过绝对可以运行，j2sdk1.4下通过。
/*********************************************************************************************
1.chessClient.java
**********************************************************************************************/
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.net.*;
import java.util.*;
class clientThread extends Thread
{
chessClient chessclient;
clientThread(chessClient chessclient)
{
this.chessclient=chessclient;
}
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(userNumber0!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.inputWords.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;i50;i)
{
userList.add(i "." "没有用户");
}
add(userList,BorderLayout.CENTER);
}
}
class chatPad extends Panel
{
TextArea chatLineArea=new 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);
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;i50;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=1chessOptNum=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 "))
{
chesspad.chessSelfName=recMessage.substring(10);
}
else if(recMessage.equals("/error"))
{
chesspad.statusText.setText("错误:没有这个用户，请退出程序，重新加入");
}
else
{
//System.out.println(recMessage);
}
}
public void run()
{
String message="";
try
{
while(true)
{
message=chesspad.inData.readUTF();
acceptMessage(message);
}
}
catch(IOException es)
{
}
}
}
class chessPad extends Panel implements MouseListener,ActionListener
{
int chessPoint_x=-1,chessPoint_y=-1,chessColor=1;
int chessBlack_x[]=new int[200];
int chessBlack_y[]=new int[200];
int chessWhite_x[]=new int[200];
int chessWhite_y[]=new int[200];
int chessBlackCount=0,chessWhiteCount=0;
int chessBlackWin=0,chessWhiteWin=0;
boolean isMouseEnabled=false,isWin=false,isInGame=false;
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=https://www.04ip.com/post/new DataInputStream(chessSocket.getInputStream());
outData=https://www.04ip.com/post/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);
}
}
【java五子棋的源代码 java五子棋源代码及uml类图】java五子棋的源代码的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java五子棋源代码及uml类图、java五子棋的源代码的信息别忘了在本站进行查找喔。

java五子棋的源代码 java五子棋源代码及uml类图

推荐阅读

计算机编程分析题

微信余额生成器ios，什么软件可以做微信零钱明细

公众号怎么找推广，去哪找公众号做推广

灵动岛苹果怎么用，easyconnect苹果怎么用

东风风神奕炫哪里产的东风风神奕炫三大件哪产的

欢乐颂2哪个台重播欢乐颂2哪个台

sql2000查询分析器打不开,SQL2000查询分析器

有没有那种很伤感,很悲伤的歌曲？听了很有感悟的那种？

广西玉米产地在哪里

六七十年代“上河工”,每个生产队里要去多少人,妇女要去吗？

地暖分水器开关示意图威能地暖压力显示

民间故事——王八骨头状元牙

苏格兰英国为什么分四个国家

共青团申请书范文

系列|13用户的狂欢，苹果12用户的孤单，一夜降价1000，为何还是十三香

抢劫罪会判几年徒刑抢劫罪会判几年

想要开通蚂蚁借呗怎么办？蚂蚁借呗开通小技巧！

晚上吃10个饺子会胖吗

论持久战读后感500字大学生论持久战读后感800字

三岁半的小孩睡前喝牛奶还会吸收吗