chessserver.java

Java五子棋编程

package org.main;

import java.io.*;
import java.net.*;
import java.awt.*;
import java.util.*;
import java.awt.event.*;

class MessageServer extends Panel // implements ActionListener
{
	TextArea messageBoard = new 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 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));
						chessPeerTalk(chessServerName, "/OK");
						publicTalk(getUserList());
					}
					else
						if (message.startsWith("/joingame "))
						{
							StringTokenizer userToken = new StringTokenizer(
									message, " ");
							String getUserToken, serverName, selfName;
							String[] chessNameOpt =
							{"0","0"};
							int getOptNum = 0;

							while (userToken.hasMoreTokens())
							{
								getUserToken = (String) userToken
										.nextToken(" ");
								if (getOptNum >= 1 && getOptNum <= 2)
								{
									chessNameOpt[getOptNum - 1] = getUserToken;
								}
								getOptNum++;
							}
							serverName = chessNameOpt[0];
							selfName = chessNameOpt[1];

							if (chessPeerHash.containsKey(serverName)
									&& chessPeerHash.get(serverName).equals(
											"wait"))
							{
								synchronized (clientNameHash)
								{
									clientNameHash.put(clientSocket,
											("[inchess]" + selfName));
								}
								synchronized (chessPeerHash)
								{
									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