用JAVA设计游戏:五子棋游戏

最新问答

• cocomooner

  下面的源代分为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(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.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;i<50;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;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 "))
  {
  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=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]))
  {
  

  浏览 178赞 73时间 2021-12-23