static final long serialVersionUID = 1L;

	protected boolean UNDO_DEBUG = false;

	protected Piece board_pieces[];

	private Piece pieces[];

	protected ArrayList<History> stack;

	protected int moveNr;

	protected static final int EMPTY = 0;

	Color color_black;

	Color color_white;

	int iHeight;

	int iWidth;

	int xPos;

	int yPos;

	boolean black;

	boolean blacksTurn;

	MouseListener listener;

	/**

	 * The init method initializes an empty board with a history.

	 */

	public void init() {

		int i;

		pieces = new Piece[64];

		for (i = 0; i < 64; i++) {

			pieces[i] = new Piece(null, null, EMPTY, 0);

		}

		xPos = 0;

		yPos = 0;

		black = false;

		blacksTurn = false;

		board_pieces = getPieces(pieces);

		stack = new ArrayList<History>();

		moveNr = 0;

	}

	public Board(int w, int h) {

		iWidth = w;

		iHeight = h;

		color_white = new Color(255, 255, 255);

		color_black = new Color(50, 100, 200);

		setPreferredSize(new Dimension(8 * iWidth, 8 * iHeight));

		init();

		listener = new MouseListener(iWidth, iHeight);

		addMouseListener(listener);

	}

	/**

	 * getPiece returns a Piece-Object from the Board Cache. It might not be

	 * visible on the current board.

	 */

	public Piece getPiece(int t) {

		return pieces[t];

	}

	/**

	 * setPiece sets a Piece-Object into the Board Cache and will not be

	 * visible.

	 */

	protected void setPiece(int t, Piece p) {

		pieces[t] = p;

	}

	protected Piece[] getPieces() {

		return getPieces(pieces);

	}

	private Piece[] getPieces(Piece[] which_pieces) {

		Piece[] p = new Piece[64];

		int i;

		for (i = 0; i < 64; i++)

			p[i] = new Piece(which_pieces[i]);

		return p;

	}

	protected void setPieces(Piece[] p) {

		pieces = p;

	}

	/**

	 * needed in paint(Graphics g)

	 */

	private Image getBoardImage(int i) {

		return board_pieces[i].image;

	}

	/**

	 * getMouseListener returns a valid MouseListener for this Board.

	 */

	public MouseListener getMouseListener() {

		return listener;

	}

	/**

	 * currentMove returns the current stack.size().

	 */

	public int currentMove() {

		return stack.size();

	}

	/**

	 * returns the color of piece[i].

	 */

	public String getColor(int i) {

		return pieces[i].color;

	}

	/**

	 * returns the current Value of a particular piece.

	 */

	public int getValue(int i) {

		return pieces[i].value;

	}

	/**

	 * Defined Integer Constants: EMTPY = 0

	 */

	public int getType(int i) {

		return pieces[i].type;

	}

	public boolean isEmpty(int i) {

		if (pieces[i].type == EMPTY)

			return true;

		return false;

	}

	boolean BoardisEmpty(int i) {

		if (board_pieces[i].type == EMPTY)

			return true;

		return false;

	}

	/**

	 * blacksTurn = true -> Black moves blacksTurn = false -> White moves

	 */

	public boolean isBlacksTurn() {

		return blacksTurn;

	}

	public void setBlacksTurn(boolean b) {

		blacksTurn = b;

	}

	/**

	 * returns true, when piece[i] is white

	 */

	public boolean isWhite(int i) {

		if (isEmpty(i))

			return false;

		if (pieces[i].color.equals("white"))

			return true;

		return false;

	}

	/**

	 * returns true, when piece[i] is black

	 */

	public boolean isBlack(int i) {

		if (isEmpty(i))

			return false;

		if (pieces[i].color.equals("black"))

			return true;

		return false;

	}

	/**

	 * returns true, when both pieces have opposite colors

	 */

	public boolean isEnemy(int t, int o) {

		if (isEmpty(t))

			return false;

		if (!pieces[t].color.equals(pieces[o].color))

			return true;

		return false;

	}

	/**

	 * returns true, when both pieces have the same color

	 */

	public boolean isSamePiece(int t, int o) {

		if (isEmpty(t))

			return false;

		if (pieces[t].color.equals(pieces[o].color))

			return true;

		return false;

	}

	/**

	 * This function checks for the color of the piece at piece[i] and returns

	 * true, if the color matches the current Turn.

	 */

	public boolean validTurn(int i) {

		if (isEmpty(i))

			return false;

		if (getColor(i).equals("white") && isBlacksTurn())

			return false;

		if (getColor(i).equals("black") && !isBlacksTurn())

			return false;

		return true;

	}

	/**

	 * simulates a "valid" move or returns false. all changes are relative to

	 * pieces and will not be painted. This method sets internal variables for

	 * the rochade() method, which will be overidden.

	 */

	public boolean simulateMove(int t, int o) {

		if (!validMove(t, o)) {

			return false;

		}

		push(pieces[t], t, pieces[o], o);

		pieces[t] = new Piece(pieces[o]);

		pieces[o] = new Piece(null, null, EMPTY, 0);

		return true;

	}

	/**

	 * Moves a Piece on the Board at Point p

	 */

	public boolean move(Point p) {

		int t;

		int o;

		t = (p.endy * 8) + p.endx;

		o = (p.starty * 8) + p.startx;

		if (t < 0 || t > 63)

			return false;

		if (o < 0 || o > 63)

			return false;

		if (validTurn(o))

			return doMove(t, o);

		System.out.println("It's not your turn!");

		return false;

	}

	/**

	 * Moves one half-move backward.

	 */

	public void backwards() {

		History h1;

		History h2;

		if (moveNr < 2)

			return;

		moveNr -= 2;

		h1 = stack.get(moveNr);

		h2 = stack.get(moveNr + 1);

		board_pieces[h1.pos] = h1.piece;

		board_pieces[h2.pos] = h2.piece;

		repaint();

	}

	/**

	 * Moves one half-move forward.

	 */

	public void forward() {

		History h1;

		History h2;

		if (moveNr > stack.size() - 2)

			return;

		h1 = stack.get(moveNr);

		h2 = stack.get(moveNr + 1);

		board_pieces[h1.pos] = h2.piece;

		board_pieces[h2.pos] = new Piece(null, null, EMPTY, 0);

		moveNr += 2;

		repaint();

	}

	/**

	 * pushes 2 pieces onto the stack.

	 */

	public void push(Piece p1, int t, Piece p2, int o) {

		stack.add(new History(p1, t, isBlacksTurn()));

		stack.add(new History(p2, o, isBlacksTurn()));

	}

	/**

	 * pop: undo the push operation.

	 */

	public void undo() {

		History h1;

		History h2;

		int size = stack.size();

		if (size < 2)

			return;

		h1 = stack.remove(size - 1);

		h2 = stack.remove(size - 2);

		pieces[h1.pos] = h1.piece;

		pieces[h2.pos] = h2.piece;

		/* Reset the current player */

		setBlacksTurn(h2.turn);

	}

	/**

	 * This method must be implemented in your "GameBoard" Return value: TRUE:

	 * the move IS possible Return value: FALSE: the move IS NOT possible

	 */

	public boolean validMove(int t, int o) {

		System.out.println("public boolean validMove(int t, int o): Implement me");

		return false;

	}

	/**

	 * This method must be implemented in your "GameBoard" Return value: TRUE:

	 * the move was performed Return value: FALSE: the move was not performed

	 */

	public boolean doMove(int t, int o) {

		System.out.println("public boolean doMove(int t, int o): Implement me");

		return false;

	}

	public void update(Graphics g) {

		paint(g);

	}

	public void paint(Graphics g) {

		for (int i = 0; i < 8; i++) {

			for (int j = 0; j < 8; j++) {

				if (black == true) {

					g.setColor(color_black);

					g.fillRect(xPos, yPos, iWidth, iHeight);

					black = false;

				} else {

					g.setColor(color_white);

					g.fillRect(xPos, yPos, iWidth, iHeight);

					black = true;

				}

				if (!BoardisEmpty((i * 8) + j))

					g.drawImage(getBoardImage((i * 8) + j), xPos + 5, yPos, this);

				xPos += iWidth;

			}

			xPos = 0;

			yPos += iHeight;

			black = !black;

		}

		xPos = 0;

		yPos = 0;

	}