GameBoard.java

package org.cis1200.sudoku;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
// import java.awt.event.MouseAdapter;
// import java.awt.event.MouseEvent;
import java.io.*;
// import java.util.Arrays;
import java.util.LinkedList;
import java.util.Objects;
import java.util.Random;
// import java.util.random.RandomGenerator;

/**
 * This class instantiates a GameBoard Object.
 */
@SuppressWarnings("serial")
public class GameBoard extends JPanel {

    private Sudoku s; // model for the game
    private JLabel mistakesLeft; // current status text
    private Tile[][] fields;
    private StatusPanel sp;

    // Game constants
    public static final int BOARD_WIDTH = 300;
    public static final int BOARD_HEIGHT = 300;
    public static final int EASY = 1;
    public static final int MEDIUM = 2;
    public static final int HARD = 3;

    /**
     * Initializes the game board.
     */
    public GameBoard() {
        // creates border around the court area, JComponent method
        setBorder(BorderFactory.createLineBorder(Color.BLACK));

        // Enable keyboard focus on the court area. When this component has the
        // keyboard focus, key events are handled by its key listener.
        setFocusable(true);

        s = new Sudoku(); // initializes model for the game
        GridLayout l = new GridLayout(3, 3);
        setLayout(l);
        fields = new Tile[9][9];
        sp = new StatusPanel();
    }

    public void setStatusPanel(StatusPanel sp) {
        this.sp = sp;
    }

    /**
     * Undo last move.
     */
    public void undo() {
        LinkedList<Tile> moves = s.getMoves();
        if (!moves.isEmpty()) {
            Tile last = moves.getLast();
            s.setCurrent(last.getDigit(), last.getRow(), last.getCol());
            paint();
            moves.removeLast();
        } // WRITE TEST CASE FOR UNDO ON EMPTY LIST
    }

    /**
     * Restart game.
     */
    public void restart() {
        s.reset(s.getInitial(), s.getAnswer());
        paint();
    }

    public void newGame() {
        JButton easy = new JButton("EASY");
        easy.addActionListener(e -> easy());

        JButton medium = new JButton("MEDIUM");
        medium.addActionListener(e -> medium());

        JButton hard = new JButton("HARD");
        hard.addActionListener(e -> hard());

        JButton[] buttons = { easy, medium, hard };
        JTextArea instructions = new JTextArea();
        // instructions.setAlignmentX(Component.CENTER_ALIGNMENT);
        instructions.setText(
                "HOW TO PLAY: The goal of the game is to fill in " +
                        "each box with a number from 1-9. \n" +
                        "There can only be one of each digit in each row, each column," +
                        " and each 3x3 box. \n" +
                        "To submit a digit for a box, type in your guess and then click " +
                        "enter. \n" +
                        "If you use all 3 mistakes, you lose. If you correctly fill in " +
                        "the entire 9x9 grid, you win. \n" +
                        "Choose your difficulty level below then click OK to begin. Good luck!"
        );
        instructions.setEditable(false);

        JOptionPane jPane = new JOptionPane(
                instructions, JOptionPane.PLAIN_MESSAGE,
                JOptionPane.DEFAULT_OPTION, null, buttons
        );
        JOptionPane.showMessageDialog(
                null, jPane, "Sudoku",
                JOptionPane.PLAIN_MESSAGE
        );
        // generate new game
    }

    /**
     * New game.
     */
    public void initialStartGame(int l) {
        Random r = new Random();
        String filePath = "";
        if (l == EASY) {
            File f = new File(
                    "src\\main\\java\\org\\cis1200\\sudokufiles\\easy"
            );
            int rand = r.nextInt(Objects.requireNonNull(f.listFiles()).length) + 1;
            filePath = f.getPath() + "\\Easy Game " + String.valueOf(rand);
        } else if (l == MEDIUM) {
            File f = new File(
                    "src\\main\\java\\org\\cis1200\\sudokufiles\\medium"
            );
            int rand = r.nextInt(Objects.requireNonNull(f.listFiles()).length) + 1;
            filePath = f.getPath() + "\\Medium Game " + String.valueOf(rand);
        } else {
            File f = new File(
                    "src\\main\\java\\org\\cis1200\\sudokufiles\\hard"
            );
            int rand = r.nextInt(Objects.requireNonNull(f.listFiles()).length) + 1;
            filePath = f.getPath() + "\\Hard Game " + String.valueOf(rand);
        }
        BufferedReader br = null;
        int[][] initial = new int[9][9];
        int[][] answer = new int[9][9];

        try {
            br = new BufferedReader(new FileReader(filePath));
            for (int i = 0; i < 19; i++) {
                try {
                    String line = br.readLine();
                    String[] currLine = line.split(",");
                    for (int j = 0; j < currLine.length; j++) {
                        if (i < 9) {
                            initial[i][j] = Integer.parseInt(currLine[j].trim());
                        }
                        if (i >= 10) {
                            answer[i - 10][j] = Integer.parseInt(currLine[j].trim());
                        }
                    }
                } catch (IOException e) {
                    throw new IllegalArgumentException("Out of bounds");
                }
            }
        } catch (FileNotFoundException e) {
            throw new IllegalArgumentException("File doesn't exist");
        } finally {
            try {
                if (br != null) {
                    br.close();
                }
            } catch (IOException e) {
                System.out.println("Cannot close");
            }
        }
        s.reset(initial, answer);
        paint();
    }

    /**
     * Updates the JLabel to reflect the current state of the game.
     */
    private void updateBoard(String input, int row, int col) {
        s.input(input, row, col);
        // mistakesLeft.setText("Mistakes Left:") ;
        paint();
    }

    /**
     * Draws the game board.
     */

    public void paint() {
        removeAll();
        updateUI();
        sp.updateLabel(s.getMistakesLeft());
        for (int i = 0; i < 3; i++) {
            for (int k = 0; k < 3; k++) {
                JPanel p = new JPanel();
                p.setBorder(BorderFactory.createLineBorder(Color.BLACK));
                p.setLayout(new GridLayout(3, 3));
                for (int a = 0; a < 3; a++) {
                    for (int b = 0; b < 3; b++) {
                        int r = i * 3 + a;
                        int c = k * 3 + b;
                        Tile j;
                        if (s.getInitial()[r][c] != 0) { // initial = answer
                            j = new Tile(r, c, s.getInitial()[r][c], s.getAnswer()[r][c]);
                            j.setText(String.valueOf(s.getInitial()[r][c]));
                            j.setEditable(false); // make the initial integers not editable
                        } else {
                            j = new Tile(r, c, 0, s.getAnswer()[r][c]);
                            if (s.getCurrent()[r][c] != 0) {
                                j.setText(String.valueOf(s.getCurrent()[r][c]));
                            }
                            if (s.getGameOver()) {
                                j.setEditable(false); // if game over, cannot edit any tiles
                            }
                        }
                        j.setHorizontalAlignment(JTextField.CENTER);
                        fields[r][c] = j;
                        p.add(j);
                    }
                }
                add(p);
            }
        }
        addListeners();
    }

    public void addListeners() {
        for (int r = 0; r < 9; r++) {
            for (int c = 0; c < 9; c++) {
                fields[r][c].addActionListener(new FieldListener());
            }
        }
    }

    public void easy() {
        initialStartGame(EASY);
    }

    public void medium() {
        initialStartGame(MEDIUM);
    }

    public void hard() {
        initialStartGame(HARD);
    }

    // inner class FieldListener
    public class FieldListener implements ActionListener {

        public FieldListener() {
        }

        @Override
        public void actionPerformed(ActionEvent e) {
            Tile t = (Tile) e.getSource(); // field listener for tile
            updateBoard(t.getText(), t.getRow(), t.getCol());
        }
    }

    /**
     * Returns the size of the game board.
     */
    @Override
    public Dimension getPreferredSize() {
        return new Dimension(BOARD_WIDTH, BOARD_HEIGHT);
    }
}