BoardWidget.java

package amazons;

import ucb.gui2.Pad;

import java.io.IOException;

import java.util.ArrayList;
import java.util.concurrent.ArrayBlockingQueue;

import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.Polygon;
import java.awt.event.MouseEvent;
import java.awt.image.BufferedImage;
import javax.imageio.ImageIO;

import static amazons.Piece.*;
import static amazons.Square.sq;
import static amazons.Move.mv;

/** A widget that displays an Amazons game.
 *  @author Khang
 */
class BoardWidget extends Pad {

    /* Parameters controlling sizes, speeds, colors, and fonts. */

    /** Colors of empty squares and grid lines. */
    static final Color
        SPEAR_COLOR = new Color(64, 64, 64),
        LIGHT_SQUARE_COLOR = new Color(238, 207, 161),
        DARK_SQUARE_COLOR = new Color(205, 133, 63);

    /** Locations of images of white and black queens. */
    private static final String
        WHITE_QUEEN_IMAGE = "wq4.png",
        BLACK_QUEEN_IMAGE = "bq4.png",
        ARROW = "arrow.png";

    /** Size parameters. */
    private static final int
        SQUARE_SIDE = 30,
        BOARD_SIDE = SQUARE_SIDE * 10;

    /** A graphical representation of an Amazons board that sends commands
     *  derived from mouse clicks to COMMANDS.  */
    BoardWidget(ArrayBlockingQueue<String> commands) {
        _commands = commands;
        setMouseHandler("click", this::mouseClicked);
        setPreferredSize(BOARD_SIDE, BOARD_SIDE);

        try {
            _whiteQueen = ImageIO.read(Utils.getResource(WHITE_QUEEN_IMAGE));
            _blackQueen = ImageIO.read(Utils.getResource(BLACK_QUEEN_IMAGE));
            _arrow = ImageIO.read(Utils.getResource(ARROW));
        } catch (IOException excp) {
            System.err.println("Could not read queen images.");
            System.exit(1);
        }
        _acceptingMoves = false;
    }

    /** Draw the bare board G.  */
    private void drawGrid(Graphics2D g) {
        g.setColor(DARK_SQUARE_COLOR);
        g.fillRect(0, 0, BOARD_SIDE, BOARD_SIDE);
        for (int i = 0; i < BOARD_SIDE; i += SQUARE_SIDE * 2) {
            for (int j = 0; j < BOARD_SIDE; j += SQUARE_SIDE * 2) {
                g.setColor(LIGHT_SQUARE_COLOR);
                g.fillRect(i, j, SQUARE_SIDE, SQUARE_SIDE);
            }
        }
        for (int i = SQUARE_SIDE; i < BOARD_SIDE; i += SQUARE_SIDE * 2) {
            for (int j = SQUARE_SIDE; j < BOARD_SIDE; j += SQUARE_SIDE * 2) {
                g.setColor(LIGHT_SQUARE_COLOR);
                g.fillRect(i, j, SQUARE_SIDE, SQUARE_SIDE);
            }
        }
        if (_selectedFrom != null) {
            g.setColor(Color.GREEN);
            g.fillRect(cx(_selectedFrom.col()),
                    cy(_selectedFrom.row()), SQUARE_SIDE, SQUARE_SIDE);
            if (_selectedTo != null) {
                g.setColor(Color.GREEN);
                g.fillRect(cx(_selectedTo.col()),
                        cy(_selectedTo.row()), SQUARE_SIDE, SQUARE_SIDE);
            }
        }

        try {
            _blackQueen = ImageIO.read
                    (getClass().getResourceAsStream("bq4.png"));
        } catch (IOException e) {
            e.printStackTrace();
        }

        try {
            _whiteQueen = ImageIO.read
                    (getClass().getResourceAsStream("wq4.png"));
        } catch (IOException e) {
            e.printStackTrace();
        }

        for (int col = 0; col < _board.SIZE; col++) {
            for (int row = 0; row < _board.SIZE; row++) {
                if (_board.get(col, row) == BLACK) {
                    g.drawImage(_blackQueen, SQUARE_SIDE * (col),
                            SQUARE_SIDE * (Board.SIZE - 1 - row), null);
                } else if (_board.get(col, row) == WHITE) {
                    g.drawImage(_whiteQueen, SQUARE_SIDE * (col),
                            SQUARE_SIDE * (Board.SIZE - 1 - row), null);
                } else if (_board.get(col, row) == SPEAR) {
                    g.drawImage(_arrow, SQUARE_SIDE * (col),
                            SQUARE_SIDE * (Board.SIZE - 1 - row), null);
                }
            }
        }
    }

    @Override
    public synchronized void paintComponent(Graphics2D g) {
        drawGrid(g);
        if (_moveList.size() == 3) {
            Polygon arrowHead = new Polygon();

            drawQueen(g, _moveList.get(1), _board.get(_moveList.get(0)));
            g.drawImage(_arrow, cx(_moveList.get(2).col()),
                    cy(_moveList.get(2).row()), null);
            _acceptingMoves = true;
            _moveList.clear();

        }
    }

    /** Draw a queen for side PIECE at square S on G.  */
    private void drawQueen(Graphics2D g, Square s, Piece piece) {
        g.drawImage(piece == WHITE ? _whiteQueen : _blackQueen,
                    cx(s.col()) + 2, cy(s.row()) + 4, null);

    }

    /** Handle a click on S. */
    private void click(Square s) {

        if (_selectedFrom == null && _selectedTo == null) {
            if (_board.isLegal(s)) {
                _selectedFrom = s;
            }
        } else if (_selectedFrom != null && _selectedTo == null) {
            if (_board.isLegal(_selectedFrom, s)) {
                _selectedTo = s;
            } else {
                _selectedFrom = null;
            }
        } else if (_selectedFrom != null && _selectedTo != null) {
            if (_board.isLegal(_selectedFrom, _selectedTo, s)) {
                _commands.add(mv(_selectedFrom, _selectedTo, s).toString());

            }
            _selectedTo = null;
            _selectedFrom = null;
        }
        repaint();
    }


    /** Handle mouse click event E. */
    private synchronized void mouseClicked(String unused, MouseEvent e) {
        int xpos = e.getX(), ypos = e.getY();
        int x = xpos / SQUARE_SIDE,
            y = (BOARD_SIDE - ypos) / SQUARE_SIDE;
        if (_acceptingMoves
            && x >= 0 && x < Board.SIZE && y >= 0 && y < Board.SIZE) {
            click(sq(x, y));
        }
    }

    /** Revise the displayed board according to BOARD. */
    synchronized void update(Board board) {
        _board.copy(board);
        repaint();
    }

    /** Turn on move collection iff COLLECTING, and clear any current
     *  partial selection.   When move collection is off, ignore clicks on
     *  the board. */
    void setMoveCollection(boolean collecting) {
        _acceptingMoves = collecting;
        repaint();
    }

    /** Return x-pixel coordinate of the left corners of column X
     *  relative to the upper-left corner of the board. */
    private int cx(int x) {
        return x * SQUARE_SIDE;
    }

    /** Return y-pixel coordinate of the upper corners of row Y
     *  relative to the upper-left corner of the board. */
    private int cy(int y) {
        return (Board.SIZE - y - 1) * SQUARE_SIDE;
    }

    /** Return x-pixel coordinate of the left corner of S
     *  relative to the upper-left corner of the board. */
    private int cx(Square s) {
        return cx(s.col());
    }

    /** Return y-pixel coordinate of the upper corner of S
     *  relative to the upper-left corner of the board. */
    private int cy(Square s) {
        return cy(s.row());
    }

    /** Queue on which to post move commands (from mouse clicks). */
    private ArrayBlockingQueue<String> _commands;
    /** Board being displayed. */
    private final Board _board = new Board();

    /** Image of white queen. */
    private BufferedImage _whiteQueen;
    /** Image of black queen. */
    private BufferedImage _blackQueen;
    /** Image of arrow. */
    private BufferedImage _arrow;

    /** True iff accepting moves from user. */
    private boolean _acceptingMoves;

    /** Selet Move.*/
    private Square _selectedFrom;

    /** Select TO.*/
    private Square _selectedTo;

    /** List stores Move.*/
    private ArrayList<Square> _moveList = new ArrayList<Square>();


}