org/homelinux/largo/games/board/Board.java
changeset 16 55b0d5006e7b
parent 15 d4b2b9a87d80
--- a/org/homelinux/largo/games/board/Board.java
+++ b/org/homelinux/largo/games/board/Board.java
@@ -14,379 +14,379 @@
 import javax.swing.JPanel;
 
 public class Board extends JPanel {
-    static final long serialVersionUID = 1L;
+	static final long serialVersionUID = 1L;
 
-    protected boolean UNDO_DEBUG = false;
+	protected boolean UNDO_DEBUG = false;
 
-    protected Piece board_pieces[];
-    private Piece pieces[];
+	protected Piece board_pieces[];
+	private Piece pieces[];
 
-    protected ArrayList<History> stack;
-    protected int moveNr;
+	protected ArrayList<History> stack;
+	protected int moveNr;
 
-    protected static final int EMPTY = 0;
+	protected static final int EMPTY = 0;
 
-    Color color_black;
-    Color color_white;
+	Color color_black;
+	Color color_white;
 
-    int iHeight;
-    int iWidth;
-    int xPos;
-    int yPos;
+	int iHeight;
+	int iWidth;
+	int xPos;
+	int yPos;
 
-    boolean black;
-    boolean blacksTurn;
+	boolean black;
+	boolean blacksTurn;
 
-    MouseListener listener;
+	MouseListener listener;
 
-    /**
-     * The init method initializes an empty board with a history.
-     */
-    public void init() {
-        int i;
-        pieces = new Piece[64];
+	/**
+	 * 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);
-        }
+		for (i = 0; i < 64; i++) {
+			pieces[i] = new Piece(null, null, EMPTY, 0);
+		}
 
-        xPos = 0;
-        yPos = 0;
+		xPos = 0;
+		yPos = 0;
 
-        black = false;
-        blacksTurn = false;
-        board_pieces = getPieces(pieces);
-        stack = new ArrayList<History>();
-        moveNr = 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));
+	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);
-    }
+		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];
-    }
+	/**
+	 * 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;
-    }
+	/**
+	 * 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);
-    }
+	protected Piece[] getPieces() {
+		return getPieces(pieces);
+	}
 
-    private Piece[] getPieces(Piece[] which_pieces) {
-        Piece[] p = new Piece[64];
-        int i;
+	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]);
+		for (i = 0; i < 64; i++)
+			p[i] = new Piece(which_pieces[i]);
 
-        return p;
-    }
+		return p;
+	}
 
-    protected void setPieces(Piece[] p) {
-        pieces = p;
-    }
+	protected void setPieces(Piece[] p) {
+		pieces = p;
+	}
 
-    /**
-     * needed in paint(Graphics g)
-     */
-    private Image getBoardImage(int i) {
-        return board_pieces[i].image;
-    }
+	/**
+	 * 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;
-    }
+	/**
+	 * 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();
-    }
+	/**
+	 * 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 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;
-    }
+	/**
+	 * 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;
-    }
+	/**
+	 * 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;
-    }
+	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;
-    }
+	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;
-    }
+	/**
+	 * blacksTurn = true -> Black moves blacksTurn = false -> White moves
+	 */
+	public boolean isBlacksTurn() {
+		return blacksTurn;
+	}
 
-    public void setBlacksTurn(boolean b) {
-        blacksTurn = b;
-    }
+	public void setBlacksTurn(boolean b) {
+		blacksTurn = b;
+	}
 
-    /**
-     * returns true, when piece[i] is white
-     */
-    public boolean isWhite(int i) {
-        if (isEmpty(i))
-            return false;
+	/**
+	 * 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;
-    }
+		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;
+	/**
+	 * 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;
-    }
+		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;
+	/**
+	 * 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;
-    }
+		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;
+	/**
+	 * 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;
-    }
+		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;
+	/**
+	 * 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;
-    }
+		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;
-        }
+	/**
+	 * 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);
+		push(pieces[t], t, pieces[o], o);
 
-        pieces[t] = new Piece(pieces[o]);
-        pieces[o] = new Piece(null, null, EMPTY, 0);
+		pieces[t] = new Piece(pieces[o]);
+		pieces[o] = new Piece(null, null, EMPTY, 0);
 
-        return true;
-    }
+		return true;
+	}
 
-    /**
-     * Moves a Piece on the Board at Point p
-     */
-    public boolean move(Point p) {
-        int t;
-        int o;
+	/**
+	 * 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;
+		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 (t < 0 || t > 63)
+			return false;
+		if (o < 0 || o > 63)
+			return false;
 
-        if (validTurn(o))
-            return doMove(t, o);
+		if (validTurn(o))
+			return doMove(t, o);
 
-        System.out.println("It's not your turn!");
-        return false;
-    }
+		System.out.println("It's not your turn!");
+		return false;
+	}
 
-    /**
-     * Moves one half-move backward.
-     */
-    public void backwards() {
-        History h1;
-        History h2;
+	/**
+	 * Moves one half-move backward.
+	 */
+	public void backwards() {
+		History h1;
+		History h2;
 
-        if (moveNr < 2)
-            return;
+		if (moveNr < 2)
+			return;
 
-        moveNr -= 2;
+		moveNr -= 2;
 
-        h1 = stack.get(moveNr);
-        h2 = stack.get(moveNr + 1);
+		h1 = stack.get(moveNr);
+		h2 = stack.get(moveNr + 1);
 
-        board_pieces[h1.pos] = h1.piece;
-        board_pieces[h2.pos] = h2.piece;
+		board_pieces[h1.pos] = h1.piece;
+		board_pieces[h2.pos] = h2.piece;
 
-        repaint();
-    }
+		repaint();
+	}
 
-    /**
-     * Moves one half-move forward.
-     */
-    public void forward() {
-        History h1;
-        History h2;
+	/**
+	 * Moves one half-move forward.
+	 */
+	public void forward() {
+		History h1;
+		History h2;
 
-        if (moveNr > stack.size() - 2)
-            return;
+		if (moveNr > stack.size() - 2)
+			return;
 
-        h1 = stack.get(moveNr);
-        h2 = stack.get(moveNr + 1);
+		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);
+		board_pieces[h1.pos] = h2.piece;
+		board_pieces[h2.pos] = new Piece(null, null, EMPTY, 0);
 
-        moveNr += 2;
-        repaint();
-    }
+		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()));
-    }
+	/**
+	 * 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();
+	/**
+	 * pop: undo the push operation.
+	 */
+	public void undo() {
+		History h1;
+		History h2;
+		int size = stack.size();
 
-        if (size < 2)
-            return;
+		if (size < 2)
+			return;
 
-        h1 = stack.remove(size - 1);
-        h2 = stack.remove(size - 2);
+		h1 = stack.remove(size - 1);
+		h2 = stack.remove(size - 2);
 
-        pieces[h1.pos] = h1.piece;
-        pieces[h2.pos] = h2.piece;
+		pieces[h1.pos] = h1.piece;
+		pieces[h2.pos] = h2.piece;
 
-        /* Reset the current player */
-        setBlacksTurn(h2.turn);
-    }
+		/* 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 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;
-    }
+	/**
+	 * 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 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;
-    }
+	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;
+	}
 }