Cell.java

/*----------------------------------------------------------------
 *  Author:   Apurva Gandhi
 *  Email:    ahgand22@g.holycross.edu
 *  Written:  12/01/2018
 *  
 *  Each Cell object manages information about and draws a
 *  single "cell" of the game grid. 
 *----------------------------------------------------------------*/

import GUI.*;
import java.awt.Color;

/**
 * A <i>Cell</i> object holds all information about the state of a single cell
 * of the minesweeper game board. This includes:
 *   - whether a mine is hidden in this cell or not
 *   - how many of its neighboring cells contain mines
 *   - whether it has been revealed yet or is still hidden
 * Each Cell object knows how to draw itself in a graphical window, and it will
 * draw itself in different styles depending on all the above state information.
 */
public class Cell extends Widget
{
    /**
     * Size of one cell when it is drawn on the screen, in pixels.
     */
    public static final int SIZE = 20;

    /**
     * Whether a mine is hidden in this cell or not.
     */
    protected boolean isMine;

    /**
     * Whether this cell is "revealed" or not.
     */
    protected boolean isRevealed;

    /**
     * Count of how many neighboring cells have mines.
     */
    protected int neighborMineCount;
    
    /**
     * Whether this cell has "flag" or not.
     */
    protected boolean isFlag;
    
    /**
     * Count of how many  cells have flags.
     */
    protected int flagCount;

    /**
     * Constructor: Initialize a cell to be drawn at the given x, y coordinates
     * on the screen. The cell will be blank. That is, it will not be a mine,
     * and it will have no neighboring mines so a neighbor mine count of zero.
     */
    public Cell(int x, int y)
    {
        super(x, y, SIZE, SIZE);
        this.isMine = false;
        this.isRevealed = false;
        this.neighborMineCount = 0;
    }

    /**
     * Hide a mine in this cell by changing the isMine variable to true.
     */
    public void plantMine()
    {
        isMine = true;
    }
    
    /**
     * plant a flag in this cell by changing the isFlag variable to true.
     */
    public void plantFlag()
    {
        isFlag = true;
    }
    
     /**
     * removes a flag in this cell by changing the isFlag variable to false.
     */
    public void unplantFlag()
    {
        isFlag = false;
    }
    
    /**
     * Returns true if a mine is hidden in this cell, otherwise returns false.
     */
    public boolean isMine()
    {
        return isMine;
    }

     /**
     * Returns true if a flag is present in this cell, otherwise returns false.
     */
    public boolean isFlag()
    {
        return isFlag;
    }
    
    /**
     * Increment the neighbor mine count variable by one. 
     */
    public void incrementNeighborMineCount()
    {
        neighborMineCount++;
    }

    /**
     * Increment the flag count variable by one. 
     */
    public void incrementFlagCount()
    {
        flagCount++;
    }
    
    /**
     * Set the neighbor mine count variable to a given value.
     */
    public void setNeighborMineCount(int count)
    {
        neighborMineCount = count;
    }

    /**
     * Returns the value of the neighbor mine count variable.
     */
    public int getNeighborMineCount()
    {
        return neighborMineCount;
    }

     /**
     * Returns the value of the flag count variable.
     */
    public int getFlagCount()
    {
        return flagCount;
    }
    
    /**
     * Change this cell so that it is "revealed" by setting isRevealed to true.
     */
    public void reveal()
    {
        isRevealed = true;
    }

    /**
     * Returns true if this cell is "revealed", otherwise returns false.
     */
    public boolean isRevealed()
    {
        return isRevealed;
    }

    /**
     * Hide a mine in this cell by changing the isMine variable to true.
     */
    public void makeMine()
    {
        isMine = true;
    }

    /**
     * Change this cell so that it shows the mine that is hiding in it.
     */
    public void showMine()
    {
        if (isMine)
            isRevealed = true;
    }

    /**
     * Check whether there are neighboring mines.
     */
    public boolean coastIsClear()
    {
        return (neighborMineCount == 0);
    }
    
    /**
     * Paint this cell on the canvas. Don't call this directly, it is called by
     * the GUI system automatically. This function should draw something on the
     * canvas. Usually the drawing should stay within the bounds (x, y, width,
     * height) which are protected member variables of GUI.Widget, which this
     * class extends.
     * @param canvas the canvas on which to draw.
     */
    public void repaint(GUI.Canvas canvas)
    {
        //Draws the grid as all the cells are unrevealed
        canvas.setPenColor(Color.GRAY);
        canvas.raisedBevelRectangle(x, y, SIZE, SIZE, 4.0);
        
        /**
         * If cell is revelaed and there is no mine on it,
         * it will print out the neighboring mine counts to the grid in various colors
         */
        if (isRevealed() && !isMine())
        {
            canvas.setFont(15);
            canvas.setPenColor(Color.WHITE);
            canvas.raisedBevelRectangle(x, y, SIZE, SIZE, 2.0);
            canvas.setPenRadius(5.0);
            //Based on the neighboring mine count it will print the number to the grid
            if(getNeighborMineCount() == 1)
            {
                canvas.setPenColor(Color.BLUE);
                canvas.text(x+10,y+10,"" + getNeighborMineCount());
            }
            else if(getNeighborMineCount() == 2)
            {
                canvas.setPenColor(Color.GREEN);
                canvas.text(x+10,y+10,"" + getNeighborMineCount());
            }
            else if(getNeighborMineCount() == 3)
            {
                canvas.setPenColor(Color.RED);
                canvas.text(x+10,y+10,"" + getNeighborMineCount());
            }
            else if(getNeighborMineCount() == 4)
            {
                canvas.setPenColor(Color.MAGENTA);
                canvas.text(x+10,y+10,"" + getNeighborMineCount());
            }
            else if (getNeighborMineCount() > 4)
            {
                canvas.setPenColor(Color.PINK);
                canvas.text(x+10,y+10,"" + getNeighborMineCount());
            }  
        }//end of isRevealed() && !isMine()
        
         /**
         * If cell is revelaed and there is  mine on it,
         * it will print out the image of the mine
         */
        if(isRevealed() && isMine())
        {
            canvas.setPenColor(Color.WHITE);
            canvas.raisedBevelRectangle(x, y, SIZE, SIZE, 4.0);
            canvas.pictureCentered(x+10, y+10,"Mine2.jpg",20.0,20.0);
        }
        
         /**
         * If there is a flag, it print out a picture of the flag to the screen
         */
        if(isFlag())
        {
            canvas.pictureCentered(x+10, y+10,"indiaFlag1.jpg",20.0,20.0);
        }
    }//end of repaint
    
}//end of Cell