chessmainframe.java

java写的象棋程序

package org.acerge.main;

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

import org.acerge.engine.*;
import org.acerge.message.*;
import org.acerge.message.impl.ChessMessage;
import org.acerge.message.impl.ChessMessageQueue;
import org.acerge.message.impl.MessageConsumer;
import org.acerge.message.impl.MessageProducer;
import org.acerge.message.impl.PieceMessageDeliver;
import org.acerge.message.support.MsgNetConnection;
import org.acerge.message.support.OuterMsgReceiver;
import org.acerge.message.support.OuterMsgSender;
import org.acerge.pieces.*;
import org.acerge.rule.*;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import java.io.*;

public class ChessMainFrame extends JFrame {
	private static Log log = LogFactory.getLog(ChessMainFrame.class);
	private JLabel noteinfo;
	private JButton button_setSysCfg, button_resetAll;
	private JButton button_reverseBoard;

	private JButton button_cmpMove;

	private JButton button_turnBack;

	private JButton button_saveFile;

	private JButton button_openFile;

	private JButton button_preStep, button_nextStep, button_endStep;

	private JFileChooser fileChooserButton;

	private JTextField textField_redTime, textField_blackTime;

	private JButton button_getConnect;

	private JButton button_setRule, button_displayRule;

	private JButton button_start;

	JPanel panel0, panel1, panel2, panel3, panel4;// select red or black

	private Container content;

	private PictureBoard pictureBoard;

	private int player = 0;

	private boolean boardReversed = false;

	// private boolean boardChangedWhenComputerIsThingking = false;

	private boolean computerIsThingking = false;

	private final TimeRule timeRule = new TimeRule();

	private TimeRuleConfig timeRuleConfig = new TimeRuleConfig();

	private SysConfigInfo sysCfg = new SysConfigInfo();

	private ReadyToPlay readyToPlay;

	private boolean competitorStarted = false;

	// computer.

	private boolean started = false;

	private boolean isFirstStep = true;// 第一步

	private String competitorName;

	private static final String SET_RULE_COMMAND = "set time rule";

	private static final String DISPLAY_RULE_COMMAND = "display time rule";

	private int boardGridSize;// 棋板格子的大小

	private int view = 0;// 视角0：红方在下方

	private int lineLoc;

	private ActiveBoard activeBoard;

	private PieceArray pieceArr = new PieceArray();;

	private Qizi pieceIndex[] = new Qizi[90];;// [90]

	private PieceArray capturedArr = new PieceArray();;

	private Qizi lastSelected;

	private SortedMoveNodes AllMoves;

	private int[][] HisTable = new int[90][90];;

	private Translation translation;

	private SearchEngine searchEngine;

	/***************************************************************************
	 * message processer
	 **************************************************************************/
	private MessageQueue msgQueue = new ChessMessageQueue();

	private Producer producer = new MessageProducer(msgQueue);

	private Consumer consumer = new MessageConsumer();

	private PieceMessageDeliver deliver = new PieceMessageDeliver(msgQueue);

	private MessageListener localListener = new LocalMessageListener();

	private MessageListener remoteListener = new RemoteMessageListener();

	private MsgNetConnection netConnection = new MsgNetConnection();

	private OuterMsgSender outSender = new OuterMsgSender(netConnection);

	private OuterMsgReceiver outReceiver = new OuterMsgReceiver(producer,
			netConnection);

	/***************************************************************************
	 * button Listeners
	 **************************************************************************/
	private LastNextTurnBackButtonListener lnt = new LastNextTurnBackButtonListener();

	private OpenSaveButtonListener fhl = new OpenSaveButtonListener();

	private ConnectActionListener connectListener = new ConnectActionListener();

	private SysInfoButtonsListener sral = new SysInfoButtonsListener();

	/***************************************************************************
	 * Constructors
	 **************************************************************************/
	public ChessMainFrame() {
		super();
		initialize();
		createGui();
	}

	public ChessMainFrame(int bs, int view, String appname) {
		super(appname);
		setBoardGridSize(bs);
		setView(view);
		initialize();
		createGui();
	}

	private void initialize() {
		JPanel jContentPane = new JPanel();
		jContentPane.setLayout(null);
		this.setContentPane(jContentPane);
		// this.getContentPane().setLayout(null);
		for (int k = 0; k < 90; k++)
			for (int j = 0; j < 90; j++)
				HisTable[k][j] = 0;
		setBoardGridSize(50);
		this.getActiveBoard();
		this.getSearchEngine();
		this.initActiveBoard();
		this.getTranslation();
		this.getPictureBoard();
		this.addWindowListener(new WindowAdapter() {
			public void windowClosing(WindowEvent e) {
				System.exit(0);
			}
		});

		timeRuleConfig = new TimeRuleConfig();
		timeRule.setProducer(producer);
		timeRule.setPlayerTimer(new TimeCounter());
		sysCfg = new SysConfigInfo();
		readyToPlay = new ReadyToPlay();
		AllMoves = new SortedMoveNodes();
		deliver.registerAConsumer(consumer);
		consumer.RegisterAListener(localListener);
		consumer.RegisterAListener(remoteListener);
		outReceiver.setProducer(producer);
		deliver.start();
	}

	public void createGui() {
		JDialog.setDefaultLookAndFeelDecorated(true);
		content = this.getContentPane();
		// content.
		// content.setLayout(null);
		// this.setContentPane(newBoard);
		// newBoard.
		fileChooserButton = new JFileChooser();
		fileChooserButton.setCurrentDirectory(new File("./save"));
		this.setSize(new Dimension(getPictureBoard().getWidth() + 140,
				getPictureBoard().getHeight() + 80));
		this.setLocation(SCREEN.getLocationForCenter(getSize()));
		getNoteinfo().setBounds(10, pictureBoard.getHeight() + 15,
				pictureBoard.getWidth() - 20, 25);
		getPanel0().setLocation(pictureBoard.getWidth() + 15, 5);
		getPanel1().setLocation(pictureBoard.getWidth() + 15, 135);
		getPanel2().setLocation(pictureBoard.getWidth() + 15, 203);
		getPanel3().setLocation(pictureBoard.getWidth() + 15, 273);
		getPanel4().setLocation(pictureBoard.getWidth() + 15, 400);

		content.add(noteinfo);
		content.add(getPanel0());
		content.add(getPanel1());
		content.add(getPanel2());
		content.add(getPanel3());
		content.add(getPanel4());
		content.add(getPictureBoard());

		initPictureBoardAndPieces();
		displayAllQizi();

	}// end of createGui

	public void initActiveBoard() {
		getActiveBoard()
				.loadFen(
						"rnbakabnr/9/1c5c1/p1p1p1p1p/9/9/P1P1P1P1P/1C5C1/9/RNBAKABNR w - - 0 1");
		getTranslation()
				.setFenStr(
						"rnbakabnr/9/1c5c1/p1p1p1p1p/9/9/P1P1P1P1P/1C5C1/9/RNBAKABNR w - - 0 1");
		loadBook("./data/book.txt");
		player = 0;
	}

	public void initActiveBoard(String fenStr) {
		getActiveBoard().loadFen(fenStr);
		player = activeBoard.getPlayer();
	}

	/***************************************************************************
	 * add all picture pieces to content
	 **************************************************************************/
	public void initPictureBoardAndPieces() {
		initPieces();
		for (int i = 0; i < pieceArr.size(); i++)
			content.add(pieceArr.getPiece(i));
		content.add(pictureBoard);
	}

	public void reloadPreActiveBoard(ActiveBoard newBoard) {
		clearPicturePieces();
		this.activeBoard = newBoard;
		initPieces();
		initPictureBoardAndPieces();
		displayAllQizi();
		player = getActiveBoard().getPlayer();
	}

	private void initPieces() {
		// if (content==null) content = this.getContentPane();
		PieceFactory.setPieceSize((int) (getBoardGridSize() * 0.9));
		String s = activeBoard.getFenStr();
		Qizi tmpQizi;
		int row = 9;//
		int col = 0;
		for (int i = 0; i < 90; i++) {
			pieceIndex[i] = null;
		}
		PieceMouseListener PML = new PieceMouseListener();
		for (int i = 0; i < s.length() && row >= 0;) {
			char tmpChar = s.charAt(i);
			if (tmpChar >= '1' && tmpChar <= '9') {
				i++;
				col += tmpChar - '0';
			}
			if (s.charAt(i) == '/' || s.charAt(i) == ' ') {
				row--;
				col = 0;
			} else {
				tmpQizi = PieceFactory.getAPiece(s.charAt(i), col, row);
				tmpQizi.addMouseListener(PML);
				pieceArr.add(tmpQizi);
				pieceIndex[col * 10 + row] = pieceArr
						.getPiece(pieceArr.size() - 1);
				col++;
			}
			i++;
		}
	}

	public void loadBook(String book) {
		try {
			getSearchEngine().clearHash();
			getSearchEngine().clearHistTab();
			// arch.LoadBook("./data/BOOK.DAT");
			getSearchEngine().loadBook(book);
		} catch (IOException e1) {
			e1.printStackTrace();
		}
	}

	private void clearPicturePieces() {
		for (int i = 0; i < pieceIndex.length; i++) {
			pieceIndex[i] = null;
		}
		Qizi tmpQz = null;
		int len = pieceArr.size();
		for (int i = 0; i < len; i++) {
			if ((tmpQz = pieceArr.remove(0)) != null) {
				content.remove(tmpQz);
			}
		}
	}

	public void reverseBoard() {
		boardReversed = !boardReversed;
		displayAllQizi();
	}

	// public void
	public void displayAllQizi() {
		for (int i = 0; i < pieceIndex.length; i++) {
			displayAQizi(pieceIndex[i]);
		}
	}

	public void displayAQizi(Qizi qz) {
		int x0, y0;
		if (qz == null)
			return;
		setQzLocation(qz);
		qz.setVisible(true);
	}

	public void setQzLocation(Qizi qz) {
		int x0, y0;
		x0 = qz.getCoordinateX();
		y0 = qz.getCoordinateY();
		if (boardReversed) {
			x0 = 8 - x0;
			y0 = 9 - y0;
		}
		qz.setLocation((int) (lineLoc + (x0 - 0.45) * boardGridSize),
				(int) (lineLoc + (9 - y0 - 0.45) * boardGridSize));
	}

	public boolean undo() {
		int oldSrc = activeBoard.lastMove().src;
		int oldDst = activeBoard.lastMove().dst;
		int oldCap = activeBoard.lastMove().cap;
		if (oldSrc < 0 || oldDst < 0) {
			log.info("End of undo!!.");
			return false;
		}
		activeBoard.undoMove();
		translation.moveCurrentToHis();
		if (lastSelected != null) {
			lastSelected.setBorderPainted(false);
		}
		lastSelected = pieceIndex[oldDst];
		lastSelected.setBorderPainted(true);
		changeLocation(lastSelected, oldSrc / 10, oldSrc % 10);
		if (oldCap != 0) {
			pieceIndex[oldDst] = capturedArr.remove(capturedArr.size() - 1);
			pieceIndex[oldDst].setVisible(true);
		}
		return true;
	}

	public boolean redo() {
		MoveNode tmpMove = translation.getHisMoveStruct();
		if (tmpMove != null) {
			int src = tmpMove.src;
			int dst = tmpMove.dst;
			movePiece(src, dst, false);
			translation.moveHisToCurrent();
			return true;
		} else {
			log.info("end of redo");
			return false;
		}
	}

	public void setAQizi(Qizi srcQz, int x, int y) {
		pieceIndex[x * 10 + y] = srcQz;
		srcQz.setCoordinate(x, y);
	}

	public void changeLocation(Qizi srcQz, int dstX, int dstY) {
		// if dst has a qizi, move it to captured place[dst][1] and set to
		// visible to false
		int src = srcQz.getCoordinate();
		int dst = dstX * 10 + dstY;
		if (pieceIndex[dst] != null) {
			pieceIndex[dst].setVisible(false);
			capturedArr.add(pieceIndex[dst]);
			pieceIndex[dst] = null;
		}
		pieceIndex[dst] = srcQz;
		pieceIndex[dst].setCoordinate(dstX, dstY);
		setQzLocation(pieceIndex[dst]);
		pieceIndex[dst].setBorderPainted(true);
		pieceIndex[src] = null;
	}

	// for mouseAction
	public boolean movePiece(Qizi qz, int dstX, int dstY, boolean needSave) {
		if (qz == null)
			return false;
		int srcX = qz.getCoordinateX(), srcY = qz.getCoordinateY();
		AllMoves.GenMoves(activeBoard, HisTable);
		MoveNode tmpMove = null;
		int tmpSrc, tmpDst, moveNum = AllMoves.MoveNum;
		for (int i = 0; i < moveNum; i++) {
			tmpSrc = AllMoves.MoveList[i].src;
			tmpDst = AllMoves.MoveList[i].dst;
			if (tmpSrc == srcX * 10 + srcY && tmpDst == dstX * 10 + dstY) {
				BitBoard pieceBoard = (activeBoard.getPieceBits(qz
						.getPieceType())).getLeftShift(0);// copy to
				// pieceBoard
				tmpMove = new MoveNode(tmpSrc, tmpDst);
				if (activeBoard.movePiece(tmpMove)) {
					if (needSave)
						translation.addMoveInfo(pieceBoard, qz, dstX, dstY);
					log.info(translation.getEMoveStr() + "  "
							+ translation.getCMoveStr());
					if (isFirstStep) {
						timeRule.resetTimeAndBeginCount();
						isFirstStep = false;
					}
					return true;