import java.awt.*;

/** Klassen definierar en spelplan.
 * Spelplanen är uppdelad i ett antal rutor.
 * @author Markus Forsberg
 * @version 2003-03-04 */
public class Board extends Canvas{

    private int width; // bredden på spelplanen.
    private int height; // höjden på spelplanen.
    private int xDot; // storleken på en ruta i x-led.
    private int yDot; // storleken på en ruta i y-led.
    private int columns; // antal kolumner på spelplanen. 
    private int rows; // antal rader på spelplanen.
    private boolean grid; // om vi skall rita ett rutmönster eller inte.
    private boolean gameover; // om vi skall skriva ut 'Game Over'.
    private int[][] board; // spelplanen är en matris av konstanterna nedan.
    
    // Konstanter som beskriver vad som kan finnas på spelplanen.
    private final int NOTHING = 0; 
    private final int BLOCK   = 1;
    private final int FRUIT   = 2;
    private final int PLAYER  = 3;

    /**
     * @param width bredden på spelplanen
     * @param height höjden på spelplanen
     * @param columns antal kolumner på spelplanen
     * @param rows antal rader på spelplanen
     * @param grid om vi skall rita ut rutmönster eller inte. */
    public Board(int width, int height, int columns, int rows, boolean grid){
    this.width = width;
    this.height = height;
    this.columns = columns;
    this.rows = rows;
    this.grid = grid;
    gameover = false;
    xDot = (int) width/columns; 
    yDot = (int) height/rows;
    board = new int[columns][rows];
    setSize(new Dimension(width,height));
    setBackground(Color.white);
    reset();
    } 
   
    /** Rensar spelplanen. Sätter varje punkt till NOTHING, 
     * och sätter gameover till false.*/
    public void reset(){
    for(int i=0;i<columns;i++)
        for(int j=0;j<rows;j++)
        board[i][j] = NOTHING;
    gameover = false;
    }

    /** Antal kolumner på spelplanen. */
    public int columnCount(){
    return columns;
    }

    /** Antal rader på spelplanen. */
    public int rowCount(){
    return rows;
    }

    /** Sätter ut en fruktruta. */
    public void setFruit(int column, int row){
    if(column > 0 && row > 0 && column <= columns && row <= rows)
    board[column-1][row-1] = FRUIT;
    }
    
    /** Sätter ut en spelarruta. */
    public void setPlayer(int column, int row){
    if(column > 0 && row > 0 && column <= columns && row <= rows)
     board[column-1][row-1] = PLAYER;
    }

    /** Sätter ut en blockruta. */
    public void setBlock(int column, int row){
    if(column > 0 && row > 0 && column <= columns && row <= rows)    
    board[column-1][row-1] = BLOCK;
    }

    /** Sätter en ruta till ingenting */
    public void setNothing(int column, int row){
     if(column > 0 && row > 0 && column <= columns && row <= rows)
      board[column-1][row-1] = NOTHING;
    }

    /** Undersöker om en spelruta innehåller ingenting. */
    public boolean isNothing(int column, int row){
        if(column > 0 && row > 0 && column <= columns && row <= rows)
         return board[column-1][row-1] == NOTHING;
        else return false;
    }

   /** Undersöker om en spelruta innehåller en fruktprick. */
   public boolean isFruit(int column, int row){
        if(column > 0 && row > 0 && column <= columns && row <= rows)
         return board[column-1][row-1] == FRUIT;
        else return false;
    }

   /** Undersöker om en spelruta innehåller en blockprick. */
   public boolean isBlock(int column, int row){
        if(column > 0 && row > 0 && column <= columns && row <= rows)
         return board[column-1][row-1] == BLOCK;
        else return false;
    }
    
    /** Undersöker om en spelruta innehåller en spelarprick. */
       public boolean isPlayer(int column, int row){
        if(column > 0 && row > 0 && column <= columns && row <= rows)
         return board[column-1][row-1] == PLAYER;
        else return false;
    }

    /** Metoden ser till att texten 'Game Over' skrivs ut på spelplanen. */
    public void gameover(){
    gameover = true;
    repaint();
    }
        
    /** Omdefinierar update för att åstadkomma dubbelbuffering.
     * Att vi använder dubbelbuffering innebär att vi slipper flimret. */
    public void update(Graphics g) {
    Graphics offgc;
    Image offscreen = null;
    Dimension d = getSize();
    offscreen = createImage(d.width, d.height);
    offgc = offscreen.getGraphics();
    offgc.setColor(getBackground());
    offgc.fillRect(0, 0, d.width, d.height);
    offgc.setColor(getForeground());
    paint(offgc);
    g.drawImage(offscreen, 0, 0, this);
    }
    
    /** Ritar upp spelplanen. */
    public void paint(Graphics g){
    if(!gameover){
        // Ritar om (hela) spelplanen
        for(int i = 0; i < columns; i++){
            for(int j=0; j < rows; j++){
            if(board[i][j] == NOTHING){
                g.setColor(getBackground());
            } else if(board[i][j] == BLOCK){
                g.setColor(Color.black);
            } else if(board[i][j] == FRUIT){
                g.setColor(Color.green);
            } else if(board[i][j] == PLAYER){
                g.setColor(Color.red);
            }
            g.fillRect(xDot*i,yDot*j,(xDot*i)+xDot,(yDot*j)+yDot);
            }
        }
        if (grid) drawGrid(g);
        }
    else {
        g.setColor(getBackground());
        g.fillRect(0,0,width,height);
        g.setColor(Color.black);
        g.setFont(new Font("Monospaced",Font.BOLD,36));
        g.drawString("Game Over",(int)width/4,(int)height/2);
    }
    }
    
    /** Ritar ut ett rutmönster på spelplanen. */
    private void drawGrid(Graphics g){
     g.setColor(Color.black);
     for(int i = 0; i < columns; i++){
     g.drawLine(i*xDot,0,i*xDot,height);
     }
     for(int j=0; j < rows; j++){
     g.drawLine(0,j*yDot,width,j*yDot);
     }
    }
}