chessmainframe.java

java写的象棋程序

				} else {
					return false;
				}
			}
		}
		return false;
	}

	// for remoteMove computer Move or redo or undo
	public void movePiece(int src, int dst, boolean needSave) {
		Qizi qz = pieceIndex[src];
		int dstX = dst / 10;
		int dstY = dst % 10;
		if (qz == null)
			return;
		if (lastSelected != null) {
			lastSelected.setBorderPainted(false);
		}
		if (movePiece(qz, dst / 10, dst % 10, needSave)) {
			// if true, model data and other information are saved,
			// following is to alter the view
			changeLocation(qz, dst / 10, dst % 10);
			lastSelected = qz;
			timeRule.updateTotalTime(player);
			player = 1 - player;
		}
	}

	public void decideFailer() {// send lose message
		AllMoves.GenMoves(activeBoard, HisTable);
		for (int i = 0; i < AllMoves.MoveNum; i++) {
			MoveNode tmp = AllMoves.MoveList[i];
			if (activeBoard.movePiece(tmp)) {
				activeBoard.undoMove();
				return;
			}
		}
		if (activeBoard.getPlayer() == 0)
			producer.send(new ChessMessage(Header.RED_FAILED, null, true));
		producer.send(new ChessMessage(Header.BLACK_FAILED, null, true));
	}

	public boolean ignoreMouseAction(Object eventSource) {
		if (computerIsThingking && eventSource!=button_cmpMove) {
			outputInfo("cannot take any action,computer is thingking");
			return true;
		}
		if (started) {
			if (eventSource == button_start || eventSource == button_setRule
					|| eventSource == button_setSysCfg
					|| eventSource == button_getConnect)
				return true;
		}
		if (eventSource instanceof Qizi)
			if (!started)
				return true;
		if (sysCfg.getBattleModel() == 2) {// network
			if (eventSource == button_cmpMove || eventSource == button_endStep
					|| eventSource == button_preStep
					|| eventSource == button_resetAll
					|| eventSource == button_turnBack
					|| eventSource == button_nextStep)
				return true;
			if (eventSource instanceof Qizi) {
				Qizi tmp = (Qizi) eventSource;
				int rb1 = (tmp.getPieceType() < 7 ? 0 : 1);
				if (player != sysCfg.getSelectedRb())
					return true;
				if (rb1 != sysCfg.getSelectedRb()) {
					if (lastSelected == null)
						return true;
				}

			}
			if (eventSource == pictureBoard) {
				if (lastSelected != null) {
					int rb2 = (lastSelected.getPieceType() < 7 ? 0 : 1);
					if (rb2 != sysCfg.getSelectedRb())
						return true;
				}
			}
		}
		return false;
	}

	public void afterMoved(boolean mouseAction) {
		if (mouseAction) {
			int src, dst;
			src = activeBoard.lastMove().src;
			dst = activeBoard.lastMove().dst;
			producer.send(new ChessMessage(Header.PIECE_MOVEED,
					src + "-" + dst, true));
		}
		decideFailer();
	}

	private void setTimeRule(TimeRuleConfig trc) {
		SetRuleDialog.createAndDisplay(this, trc, true, null);
	}

	private void setSysCfgInfo(SysConfigInfo scfi) {
		SetSysCfgDialog.createAndDisplay(this, scfi, true, "设置系统信息");
	}

	private void displayTimeRule(TimeRuleConfig trc, String title) {
		SetRuleDialog.createAndDisplay(this, trc, false, title);
	}

	private int showMessageBox(String showmsg) {
		return JOptionPane.showConfirmDialog(ChessMainFrame.this, showmsg,
				"Information", JOptionPane.YES_NO_OPTION);
	}

	public void resizePictureBoard(int newSize) {
		setBoardGridSize(newSize);
		clearPicturePieces();
		content.remove(pictureBoard);
		pictureBoard.setBoardGridSize(newSize);
		this.repaint();
		initPictureBoardAndPieces();
	}

	private void resetAll() {
		if (sysCfg.getBattleModel() == 2)
			sysCfg.setSelectedRb(1 - sysCfg.getSelectedRb());
		timeRule.paulseCount();
		clearPicturePieces();
		initActiveBoard();
		translation = new Translation();
		// resizePictureBoard(30);
		msgQueue.removeAll();
		initPictureBoardAndPieces();
		displayAllQizi();
		textField_redTime.setText("red:");
		textField_blackTime.setText("black:");
		started = false;
		isFirstStep = true;
		loadBook("./data/book.txt");
	}

	private void outputInfo(String info) {
		noteinfo.setText(info);
	}

	private void computerMove() {
		if (button_cmpMove.getText() == "Computer") {
			button_cmpMove.setText("Stop");
			new Thread() {
				public void run() {
					computerIsThingking = true;
					outputInfo("Computer is thinking...");
					// ActiveBoard
					// tmpactive=(ActiveBoard)ObjectCopyer.getACopy(activeBoard);
					searchEngine.setActiveBoard(activeBoard);
					MoveNode bestMove=null;
					try {
						bestMove = searchEngine.getBestMove();
					} catch (LostException e) {
						e.printStackTrace();
					}
					button_cmpMove.setText("Computer");
					if (bestMove == null) {
						outputInfo("Computer cannot find best Move!!!");
						button_cmpMove.setEnabled(true);
						return;
					}
					// if(boardChangedWhenComputerIsThingking){
					// reloadPreActiveBoard(tmpactive);
					// }
					movePiece(bestMove.src, bestMove.dst, true);
					afterMoved(false);
					outputInfo("computer moved:"
							+ String.copyValueOf(bestMove.location())
							+ "轮到你走棋，快点！");
					computerIsThingking = false;
				}
			}.start();
		} else {
			searchEngine.stopSearch();
			button_cmpMove.setText("Computer");
		}

	}

	/***************************************************************************
	 * private class section.
	 **************************************************************************/
	private class ConnectActionListener implements ActionListener {
		public void actionPerformed(ActionEvent e) {
			if (ignoreMouseAction(e.getSource()))
				return;
			if (sysCfg.getSelectedSc() == 1) {
				netConnection.setPointAsServer(sysCfg.getPortNum());
				log.info("Server started!!");
			} else {
				netConnection.setPointAsClient(sysCfg.getIpAddress(), sysCfg
						.getPortNum());
				log.info("Client started!!");
			}
			new Thread() {
				public void run() {
					netConnection.createConnection();
					if (netConnection.available()) {
						log.info("Server and Client connected!");
						log.info("Starting outReceiver");
						outReceiver.setConnection(netConnection);
						outReceiver.startReceiveData();
						readyToPlay.setConnectionReady(true);
						competitorStarted = true;
						if (sysCfg.getSelectedSc() == 1) {// as server
							outSender.send(new ChessMessage(Header.SYSINFO,
									sysCfg, false));
						}
					}
				}
			}.start();
		}
	}

	private class LocalMessageListener implements MessageListener {
		public void onMessage(Message msg) {
			if (!msg.isLocalMessage())
				return;
			Header head = msg.getMessageHeader();
			Object body = msg.getMessageBody();
			if (head.equals(Header.CHART)) {
				// sendout
			} else if (head.equals(Header.PIECE_MOVEED)) {
				if (outSender.available()) {
					outSender.send(new ChessMessage(head, body, false));
				}
			} else if (head.equals(Header.RED_TIME_USED)
					|| head.equals(Header.RED_FAILED)) {
				System.err.println("RED LOST!!!!!!!!!!!!!!");
				int n = showMessageBox("红方输了,是否保存?");
				if (n == JOptionPane.YES_OPTION)
					saveFile();
				resetAll();
				// button_openFile.getActionListeners()[0].actionPerformed(new
				// ActionEvent(button_openFile,12324,"ffff"));
			} else if (head.equals(Header.BLACK_TIME_USED)
					|| head.equals(Header.BLACK_FAILED)) {
				System.err.println("BLACK LOST!!!!!!!!!!!!!!");
				int n = showMessageBox("黑方输了,是否保存?");
				if (n == JOptionPane.YES_OPTION)
					saveFile();
				resetAll();
			}
		}
	}

	private class RemoteMessageListener implements MessageListener {
		public void onMessage(Message msg) {
			if (msg.isLocalMessage())
				return;
			if (!outSender.available())
				return;
			Header head = msg.getMessageHeader();
			Object body = msg.getMessageBody();
			if (head.equals(Header.SET_TIME_RULE)) {
				System.err.println("received time rule from competitor!");
				displayTimeRule((TimeRuleConfig) body, "协商规则");
				int n = showMessageBox("Do you agree the time rule ?");
				if (n == JOptionPane.YES_OPTION) {
					timeRuleConfig = (TimeRuleConfig) body;
					timeRule.resetTimeRule(timeRuleConfig);
					readyToPlay.setTimeRuleReady(true);
					outSender.send(new ChessMessage(Header.AGREE, null, false));
				} else {
					System.err
							.println("send a message of disagree on time rule from competitor!");
					outSender.send(new ChessMessage(Header.DISAGREE, null,
							false));
				}
			} else if (head.equals(Header.AGREE)) {
				readyToPlay.setTimeRuleReady(true);
				timeRule.resetTimeRule(timeRuleConfig);
				showMessageBox("Competitor agreed!!!");
			} else if (head.equals(Header.DISAGREE)) {
				showMessageBox("Competitor disagree!!!!!");
			} else if (head.equals(Header.SYSINFO)) {
				competitorStarted = true;
				readyToPlay.setSysCfgReady(true);
				SysConfigInfo cpt = (SysConfigInfo) body;
				competitorName = cpt.getUserName();
				log.info("Competitor name" + competitorName);
				sysCfg.setSelectedRb(1 - cpt.getSelectedRb());
			} else if (head.equals(Header.PIECE_MOVEED)) {
				String tmpStr = (String) body;
				int src = Integer.parseInt(tmpStr.substring(0, tmpStr
						.indexOf('-')));
				int dst = Integer.parseInt(tmpStr
						.substring(tmpStr.indexOf('-') + 1));
				// log.info("receive a Message to move!");
				movePiece(src, dst, true);
				afterMoved(false);
			}
		}
	}

	/***************************************************************************
	 * for set time rule, display time rule,set syscfg and start Button
	 **************************************************************************/
	private class SysInfoButtonsListener implements ActionListener {
		public void actionPerformed(ActionEvent e) {
			// button_setRull
			if (ignoreMouseAction(e.getSource()))
				return;
			if (e.getActionCommand().equals(SET_RULE_COMMAND)) {
				setTimeRule(timeRuleConfig);
				timeRule.resetTimeRule(timeRuleConfig);
				timeRule.getPlayerTimer().setNeedCount(true);
				if (sysCfg.getBattleModel() == 2)// network
					outSender.send(new ChessMessage(Header.SET_TIME_RULE,
							timeRuleConfig, false));
				else {
					readyToPlay.setTimeRuleReady(true);
				}
			} else
			// button_displayRule
			if (e.getActionCommand().equals(DISPLAY_RULE_COMMAND)) {
				displayTimeRule(timeRuleConfig, "现在所用的规则");
			} else
			// button_start
			if (e.getSource() == button_start) {
				if (!readyToPlay.isTimeRuleReady()) {
					timeRule.resetToDefault();
					readyToPlay.setTimeRuleReady(true);
				}
				if (readyToPlay.canPlay()) {
					if (view != sysCfg.getSelectedRb())
						reverseBoard();
					started = true;
				}
			} else
			// button_setSysCfg
			if (e.getSource() == button_setSysCfg) {
				if (started)
					return;
				setSysCfgInfo(sysCfg);
				if (sysCfg.getBattleModel() == 2) {// network battle
					button_getConnect.setEnabled(true);
				} else {
					readyToPlay.setConnectionReady(true);
					// newBoard.setMovableQz(3);
					button_getConnect.setEnabled(false);
					competitorStarted = true;
				}
				readyToPlay.setSysCfgReady(true);
			}
		}

	}

	private class PictureBoardMouseListener extends MouseAdapter {
		public void mouseClicked(MouseEvent e) {
			if (ignoreMouseAction(e.getSource()))
				return;
			int x = e.getX();
			int y = e.getY();
			Dimension d = pictureBoard.getXYCoordinate(x, y);
			x = d.width;
			y = d.height;
			if (boardReversed) {
				x = 8 - x;
				y = 9 - y;
			}
			pictureBoard.test.setText("x=" + x + ",y=" + y);
			if (lastSelected != null) {
				int src = lastSelected.getCoordinate();
				if (movePiece(lastSelected, x, y, true)) {
					changeLocation(lastSelected, x, y);
					if (sysCfg.getBattleModel() == 3) {
						computerMove();
					}
					timeRule.updateTotalTime(player);
					player = 1 - player;
					afterMoved(true);
				}
			}
		}
	}

	private class PieceMouseListener extends MouseAdapter {
		public void mouseClicked(MouseEvent e) {
			// log.info(((Qizi)e.getSource()).getCoordinate());
			if (ignoreMouseAction(e.getSource()))
				return;
			if (lastSelected == null) {
				lastSelected = (Qizi) e.getSource();
				lastSelected.setBorderPainted(true);
			} else {
				Qizi tmpQizi = (Qizi) e.getSource();
				int x1 = tmpQizi.getCoordinateX();
				int y1 = tmpQizi.getCoordinateY();
				int src = lastSelected.getCoordinate();
				if (movePiece(lastSelected, x1, y1, true)) {
					changeLocation(lastSelected, x1, y1);
					if (sysCfg.getBattleModel() == 3) {
						computerMove();
					}
					timeRule.updateTotalTime(player);
					player = 1 - player;
					afterMoved(true);
				} else {
					lastSelected.setBorderPainted(false);
					lastSelected = tmpQizi;
					lastSelected.setBorderPainted(true);
				}
			}
		}
	}

	private class OpenSaveButtonListener implements ActionListener {
		public void actionPerformed(ActionEvent e) {
			// Handle open button action.
			if (ignoreMouseAction(e.getSource()))
				return;
			if (e.getSource() == button_openFile) {
				openFile();
				// Handle save button action.
			} else if (e.getSource() == button_saveFile) {
				saveFile();
			}
		}

	}

	/***************************************************************************
	 * for lastButton,nextButton,turnBack,computerStop,resetAllBt
	 **************************************************************************/
	private class LastNextTurnBackButtonListener implements ActionListener {
		public void actionPerformed(ActionEvent e) {