User Playing option Added(Only works by file as of now)

Author: Dev-eloperr

src/com/company/Main.java

@@ -30,6 +30,7 @@ public class Main {
     static protected int[][] sudoku_array = new int[9][9]; //Stores the sudoku
     static protected ArrayList<Point> points = new ArrayList<>(); //stores the EMPTY points
     static protected guiController gui = new guiController();//Initializes program, calls sudokuInitializer as well
+    static protected boolean checkSol = false;
 
 
     public static void main(String[] args) {

src/com/company/guiController.java

@@ -8,7 +8,7 @@ class guiController extends JFrame implements Runnable{
 This class handle GUI related functions and also allows GUI refresh whenever any move is taken by AI
  */
     private JPanel grid = new JPanel(new GridLayout(9, 9)); //Grid layout
-    private JPanel buttons = new JPanel(new GridLayout(2, 2));
+    private JPanel buttons = new JPanel(new GridLayout(2, 3));
     private JTextField[][] fieldArray = new JTextField[9][9]; //array of fields for easy extraction
 
     sudokuInitializer sud = new sudokuInitializer(); //initializes array from file
@@ -49,6 +49,7 @@ private void guiInit() {
                 if (Main.sudoku_array[i][j] != 0) {
                     fieldArray[i][j].setText(Main.sudoku_array[i][j] + "");
                     fieldArray[i][j].setEditable(false);
+                    fieldArray[i][j].setBackground(Color.lightGray);
                 } else
                     fieldArray[i][j].setText("");
                 fieldArray[i][j].setFont(new Font("Arial", Font.ITALIC, 24));
@@ -82,15 +83,22 @@ private void guiInit() {
 
         JButton solve = new JButton("Solve");//Button to compute
         JButton Clear = new JButton("Clear");//Button to compute
+        JButton CheckSol = new JButton("Checksol"); //Button to check
+
+        CheckSol.setBorder(null);
+        CheckSol.setBackground(Color.white);
+        buttons.add(CheckSol);
+
         solve.setBorder(null);
         solve.setBackground(Color.white);
         buttons.add(solve);
         buttons.setBackground(Color.white);
         add(buttons, BorderLayout.SOUTH);
         solve.addActionListener(e -> { //If the button is pressed
+            Main.checkSol = false;
             if (flag != 0) {
                 try {
-                    getText(); //takes in text from the GUI
+                    getText(true); //takes in text from the GUI
                     callSolver.run();
 
 
@@ -112,13 +120,40 @@ private void guiInit() {
 
         });
 
+        CheckSol.addActionListener(e -> { //If the button is pressed
+            Main.checkSol = true;
+            if (flag != 0) {
+                try {
+                    getText(false); //takes in text from the GUI
+                    callSolver.run();
+
+
+                } catch (Exception ex) {
+                    JOptionPane.showMessageDialog(null,"Invalid Input");//Throws error if the input is invalid
+                    clearGUI();
+                    //flag=-1;
+                }
+            }else {
+                try {
+                    getText(false);
+                    callSolver.run();
+
+                } catch (Exception ex) {
+                    JOptionPane.showMessageDialog(null,"Invalid Input");//Throws error if the input is invalid
+                    clearGUI();
+                    //flag=-1;
+                }
+            }
+
+        });
 
         Clear.setBorder(null);
         Clear.setBackground(Color.white);
         buttons.add(Clear);
         Clear.addActionListener(e -> { //If the button is pressed
             clearGUI();
 
+
         });
 
 
@@ -136,12 +171,13 @@ private void guiInit() {
          */
         callSolver = () -> {
             sud.printArray(); //debugging purpose
-            solve.setEnabled(false);//cell value becomes fixed
+
             solver solver = new solver(Integer.parseInt(delay_input.getText()));
             Thread t2 = new Thread(solver);
             t2.start();
             System.out.println("Solving...");
-            Clear.setEnabled(false);
+            //Clear.setEnabled(false);
+            //solve.setEnabled(false);//cell value becomes fixed
         };
     }
 
@@ -163,17 +199,22 @@ private void clearGUI(){
 /*
 takes in valid input and sets the GUI cells as non editable
  */
-    private void getText() throws Exception{
+    private void getText(boolean editable) throws Exception{
         String temp;
         for (int i = 0; i < 9; i++) {
             for (int j = 0; j < 9; j++) {
                     temp = fieldArray[i][j].getText();
                     if (!temp.equals("")) {
                         if(sud.checkValidInput(temp+""))
                             Main.sudoku_array[i][j] = Integer.parseInt(temp + "");//checks valid input, catches exception
-                        fieldArray[i][j].setEditable(false);
-                    }else
+                        if (editable) {
+                            fieldArray[i][j].setEditable(false);
+                            fieldArray[i][j].setBackground(Color.lightGray);
+                        }
+                    }else {
                         Main.points.add(new Point(i, j));
+                        Main.sudoku_array[i][j] = 0;
+                    }
             }
         }
         sud.printPoints();
@@ -188,5 +229,30 @@ protected void refreshGUI(){
             else
                 fieldArray[(int)Main.points.get(i).getX()][(int)Main.points.get(i).getY()].setText("");
     }
+    protected void errorCell(int i, int j){
+        for(int k=0,x=0,y=0;k<=Math.max(i,j);k++) {
+            if (x<i)
+                x++;
+            if (y<j)
+                y++;
+            fieldArray[x][j].setBackground(Color.red);
+            fieldArray[i][y].setBackground(Color.red);
+            try {
+                Thread.sleep(50);
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+            if (Main.points.contains(new Point(x,j)))
+                fieldArray[x][j].setBackground(Color.white);
+            else
+                fieldArray[x][j].setBackground(Color.lightGray);
+            if (Main.points.contains(new Point(i,y)))
+                fieldArray[i][y].setBackground(Color.white);
+            else
+                fieldArray[i][y].setBackground(Color.lightGray);
+
+        }
+    }
+
 
 }

src/com/company/solver.java

@@ -1,5 +1,6 @@
 package com.company;
 
+import javax.swing.*;
 import java.awt.*;
 import java.util.*;
 import java.util.List;
@@ -8,13 +9,50 @@ class solver implements Runnable{ //Implemented as a Thread to avoid freezing an
     //Chooses a box with MINIMUM VALUES REMAINING (It acts as a heuristic which optimizes the search for the solution
     ArrayList<Point> sortedPoints = new ArrayList<>(); //It stores the sorted points according
                                                 // to box with least number of values unfilled
-    public void run(){              //acts as a constructor for the class, works with Thread.start function
+    public void run(){//acts as a constructor for the class, works with Thread.start function
+
         setSortedPoints();          //sets sorted point
-        if(getResult())             //calls the solving function
-            Main.gui.sud.printArray();
+        //new addition
+
+        if (Main.checkSol) {
+            int checkSolved=0,temp,i,j, err_i=0,err_j=0;
+
+            for (Point pointIndex : sortedPoints) {
+                if (Main.sudoku_array[(int) pointIndex.getX()][(int) pointIndex.getY()] != 0) {
+                    i = (int) pointIndex.getX();
+                    j = (int) pointIndex.getY();
+
+                    temp=Main.sudoku_array[i][j];
+                    Main.sudoku_array[i][j]=0;
+                    if (temp!=0 && !checkConstraint(temp, i, j)) {
+                        err_i=i;
+                        err_j=j;
+                        checkSolved = 1;
+                        Main.sudoku_array[i][j]=temp;
+                        break;
+                    }
+                    Main.sudoku_array[i][j]=temp;
+
+                }
+            }
+            if (checkSolved==0){
+                JOptionPane.showMessageDialog(null,"correct");
+            }else {
+                //System.out.println(err_i+" "+i+" "+err_j+" "+j);
+                Main.gui.errorCell(err_i,err_j);
+                //JOptionPane.showMessageDialog(null,"Wrong");
+            }
+        }
+        else {
+
+            if (getResult()) {      //calls the solving function
+                Main.gui.sud.printArray();
+                System.out.println("Count of backtracking: " + count_iteration);
+            }
+        }
 
     }
-    int delay_time=5;
+    private int delay_time=5;
     solver(int time){
         delay_time=time;
     }
@@ -92,9 +130,12 @@ private static HashMap<String, Integer> sortByValue(HashMap<String , Integer> ma
         }
         return temp;
     }
+
+
     /*
     This is the MAIN function which solves the sudoku by using sortedpoints arraylist and constraints
      */
+    int count_iteration=0;
     private boolean getResult(){
         if (checkSolved()) {
             return true;
@@ -124,11 +165,12 @@ private boolean getResult(){
                 Main.gui.refreshGUI();
                 timer();
                 if (getResult()){
+                    //count_iteration++;
                     return true;
                 }
                 else{
                     Main.sudoku_array[row_num][col_num] = 0;
-
+                    count_iteration++;
                     //Main.gui.sud.printArray();
                     Main.gui.refreshGUI();
                     timer();