src/com/patryk/mathdoku/ArrayConversions.java

+package com.patryk.mathdoku;
+
+public class ArrayConversions {
+    public static float[] toNative(Float[] arr) {
+        float[] out = new float[arr.length];
+        for(int i = 0; i < arr.length; ++i) {
+            out[i] = arr[i];
+        }
+
+        return out;
+    }
+
+    public static int[] toNative(Object[] arr) {
+
+        int[] out = new int[arr.length];
+        for(int i = 0; i < arr.length; ++i) {
+            out[i] = (Integer)arr[i];
+        }
+
+        return out;
+    }
+
+    public static double[] toDouble(float[] arr) {
+        double[] out = new double[arr.length];
+        for(int i = 0; i < arr.length; ++i) {
+            out[i] = arr[i];
+        }
+
+        return out;
+    }
+
+    public static Float[] fromNative(float[] arr) {
+        Float[] out = new Float[arr.length];
+        for(int i = 0; i < arr.length; ++i) {
+            out[i] = arr[i];
+        }
+
+        return out;
+    }
+
+}
+

src/com/patryk/mathdoku/GameContext.java

-package com.patryk.mathdoku;
-
-import com.patryk.mathdoku.actions.*;
-import com.patryk.mathdoku.cageData.CageData;
-import com.patryk.mathdoku.cageData.DataFormatException;
-import com.patryk.mathdoku.errorChecking.UserErrorChecker;
-import com.patryk.mathdoku.util.BoardPosVec;
-
-/**
- * Represents one status of the playing of the game e.g. the cage data, what the user has entered
- */
-public class GameContext {
-
-    private int boardWidth;
-
-    private CageData cageData;
-    private UserData userData;
-    private UserErrorChecker userErrorChecker;
-
-    StackActionRecorder<Action> actionRecorder;
-
-    public StackActionRecorder<Action> getActionRecorder() {
-        return actionRecorder;
-    }
-
-
-    UserData.ChangeListener updateErrorState = (UserData.ChangeListener.ChangeData changeData) -> {
-        userErrorChecker.onGridChange(changeData);
-    };
-
-
-    public GameContext(String data) throws DataFormatException {
-        cageData = new CageData(data);
-        this.boardWidth = cageData.getWidth();
-        BoardPosVec.setBoardWidth(boardWidth);
-        Action.setGameContext(this);
-        userData = new UserData(boardWidth);
-        actionRecorder = new StackActionRecorder<>(5);
-        //userData.fill();
-
-        userErrorChecker = new UserErrorChecker(boardWidth, userData, cageData);
-
-        userData.addChangeListener(updateErrorState);
-
-    }
-
-
-
-
-    public CageData getCageData() {
-        return cageData;
-    }
-
-    public UserData getUserData() {
-        return userData;
-    }
-
-
-    public void setValueAtCell(BoardPosVec cell, int value, boolean record ) {
-        int oldValue = userData.getValueAtCell(cell);
-        userData.setValueAtCell(cell, value);
-
-        if (record)
-            actionRecorder.record(new CellValueChangeAction(cell, oldValue, value));
-    }
-
-    public void clear(boolean record) {
-        UserData copy = UserData.move(userData);
-
-        if(record) {
-            actionRecorder.record(new ClearAction(copy));
-        }
-
-    }
-
-    public int getBoardWidth() {
-        return boardWidth;
-    }
-
-    public void undo() {
-        actionRecorder.undo().undo();
-    }
-
-    public void redo() {
-        actionRecorder.redo().redo();
-        UndoRedoButtonManager.me().onRedoButtonPressed();
-    }
-
-
-    public UserErrorChecker getErrorChecker() {
-        return userErrorChecker;
-    }
-
-
-    public boolean isWon() {
-        if (userData.isFull()) {
-            if (userErrorChecker.noErrors()) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-}
\ No newline at end of file

src/com/patryk/mathdoku/MathDoku.java

 package com.patryk.mathdoku;
 
+import com.patryk.mathdoku.cageData.Cage;
+import com.patryk.mathdoku.cageData.CageData;
 import com.patryk.mathdoku.cageData.DataFormatException;
+import com.patryk.mathdoku.solver.CageSolver;
 import com.patryk.mathdoku.gui.GameUI;
 import com.patryk.mathdoku.gui.ManualGameInputDialog;
+import com.patryk.mathdoku.gui.RandGameDialog;
+import com.patryk.mathdoku.randomGame.RandomGame;
+import com.patryk.mathdoku.solver.Solver;
 import javafx.application.Application;
 import javafx.application.Platform;
 import javafx.event.ActionEvent;
@@ -16,7 +22,9 @@ import java.io.File;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Paths;
+import java.util.List;
 import java.util.Optional;
+import java.util.Random;
 
 public class MathDoku extends Application {
     GameUI gameUI;
@@ -65,6 +73,29 @@ public class MathDoku extends Application {
 
     };
 
+    EventHandler<ActionEvent> onRanGameButtonPressed = (event) -> {
+        RandGameDialog dialog = new RandGameDialog();
+
+        Optional<RandGameDialog.RanGameInfo> result = dialog.showAndWait();
+
+        if (result.isPresent()) {
+            int seed;
+            seed = result.get().seed;
+            int size = result.get().width;
+
+            CageData cageData = RandomGame.randomGame(seed, size);
+            setGameContext(new GameContext(cageData));
+        }
+
+
+    };
+
+    private void onSolveButtonPressed(ActionEvent event) {
+        gameContext.userData.clear();
+        gameUI.wonBefore = true;
+        Solver.solve(gameContext.getUserData(), gameContext.getCageData());
+    }
+
 
 
     //key event handler
@@ -124,6 +155,8 @@ public class MathDoku extends Application {
         gameUI.checkButton.addEventHandler(ActionEvent.ANY,(event) ->  gameUI.gameGridView.showErrors());
         gameUI.fileLoadButton.addEventHandler(ActionEvent.ANY, onFileLoadButtonPressed);
         gameUI.textLoadButton.addEventHandler(ActionEvent.ANY, onManualInputButtonPressed);
+        gameUI.ranGameButton.addEventHandler(ActionEvent.ANY, onRanGameButtonPressed);
+        gameUI.solveButton.addEventHandler(ActionEvent.ANY, this::onSolveButtonPressed);
 
         gameUI.setNumberButtonCallback((digit) -> gameUI.gameGridView.getInputHandler().injectNumberKey(digit));
 
@@ -136,13 +169,15 @@ public class MathDoku extends Application {
     }
 
     public boolean wantsToExit() {
-        if (shouldDisplayExitDialog()) {
-            //show confirmation dialog
-
-
-            return gameUI.showConfirmExitDialog();
-        }
+        //todo debug
         return true;
+//        if (shouldDisplayExitDialog()) {
+//            //show confirmation dialog
+//
+//
+//            return gameUI.showConfirmExitDialog();
+//        }
+//        return true;
     }
 
     public boolean shouldDisplayExitDialog() {

src/com/patryk/mathdoku/UserData.java

@@ -5,9 +5,7 @@ import com.patryk.mathdoku.util.BoardPosVec;
 import java.io.BufferedWriter;
 import java.io.FileWriter;
 import java.io.IOException;
-import java.util.Arrays;
-import java.util.LinkedList;
-import java.util.List;
+import java.util.*;
 
 public class UserData {
     public interface ChangeListener {
@@ -98,6 +96,10 @@ public class UserData {
         notifyListener(new ChangeListener.MultipleCellChange(false));
     }
 
+    public int getBoardWidth() {
+        return boardWidth;
+    }
+
     public int getPopulationCount() {
         return populationCount;
     }
@@ -122,17 +124,20 @@ public class UserData {
 
 
     public void setValueAtCell(BoardPosVec cell, int value) {
-        int oldValue = data[cell.toIndex()];
+        setValueAtCell(cell.toIndex(), value);
+    }
+    public void setValueAtCell(int index, int value) {
+        int oldValue = data[index];
 
         if (oldValue != value) {
-            data[cell.toIndex()] = value;
+            data[index] = value;
             if (oldValue == 0)
                 populationCount++;
 
             if (value == 0) {
                 populationCount--;
             }
-            notifyListener(new ChangeListener.SingleCellChange(cell, oldValue, value));
+            notifyListener(new ChangeListener.SingleCellChange(new BoardPosVec(index), oldValue, value));
 
         }
     }
@@ -167,6 +172,28 @@ public class UserData {
         return builder.toString();
     }
 
+    public Set<Integer> getAllowedDigits(int index) {
+        BoardPosVec posVec = new BoardPosVec(index);
+        int r = posVec.r;
+        int c = posVec.c;
+
+        Set<Integer> allDigits = new HashSet<>();
+        for(int i = 1; i <= boardWidth; i++) {
+            allDigits.add(i);
+        }
+
+
+        //remove row digits
+        for (int vcol = 0; vcol < c; vcol++) {
+            allDigits.remove(Integer.valueOf(getValueAtCell(new BoardPosVec(r, vcol))));
+        }
+        //remove column digits
+        for (int vrow = 0; vrow < r; vrow++) {
+            allDigits.remove(Integer.valueOf(getValueAtCell(new BoardPosVec(vrow, c))));
+        }
+        return allDigits;
+    }
+
     public void fill() {
         for (int i = 0; i < fullSize;i ++) {
             int val = (int)( 5 * Math.random()) + 1;

src/com/patryk/mathdoku/cageData/Cage.java

 package com.patryk.mathdoku.cageData;
 
+import java.util.ArrayList;
 import java.util.List;
 
 public class Cage {
     int target;
-    Cage.Operator operator;
-    int markedCell;
-    private final List<Integer> memberCells;
+    Cage.Operator operator = Operator.ADD;
+    int markedCell = 0;
+    private List<Integer> memberCells = new ArrayList<>();
+
+    public Cage() {}
 
     public Cage(int target, Cage.Operator operator, int markedCell, List<Integer> memberCells) {
         this.target = target;
@@ -39,6 +42,18 @@ public class Cage {
         return s;
     }
 
+    public void setTarget(int target) {
+        this.target = target;
+    }
+
+    public void setOperator(Operator operator) {
+        this.operator = operator;
+    }
+
+    public void setMemberCells(List<Integer> memberCells) {
+        this.memberCells = memberCells;
+    }
+
     public enum Operator {
         ADD('+'), SUBTRACT('-'), MULTIPLY('x'), DIVIDE('÷');
 
@@ -72,7 +87,7 @@ public class Cage {
                 case MULTIPLY:
                     return operand1 * operand2;
                 case DIVIDE:
-                    return Math.floorDiv(operand1, operand2);
+                    return Math.max(1, Math.floorDiv(operand1, operand2));
                 default:
                     return -1;
             }

src/com/patryk/mathdoku/cageData/CageData.java

@@ -8,18 +8,34 @@ import java.util.*;
 
 public class CageData {
     int width;
-
     Cell[] data;
+
+    public List<Cage> getCageList() {
+        return cageList;
+    }
+
     List<Cage> cageList = new ArrayList<Cage>();
     int cageCount;
 
+    public CageData(int width) {
+        this.width = width;
+        data = new Cell[width * width];
+        for (int i = 0; i < width * width; i++) {
+            data[i] = new Cell(-1);
+        }
+        this.cageList = new ArrayList<>();
+
+    }
     public CageData(String data) throws DataFormatException{
         parseData(data);
     }
 
-
+    public Cell[] getData() {
+        return data;
+    }
     public List<Cage> getCages() {return cageList; }
 
+
     public boolean cellConnectsTo(BoardPosVec pos, Direction direction) {
 
         Cell nextCell = getCellAt(pos.add(direction.vector));
@@ -45,7 +61,7 @@ public class CageData {
         if (size > 81)
             throw new DataFormatException(-1, "Too many cells! Max is 81.");
         initData();
-        cageCount = parser.parseData(new Scanner(rawData), data, cageList);
+        parser.parseData(new Scanner(rawData), data, cageList);
 
     }
 
@@ -71,17 +87,11 @@ public class CageData {
     }
 
     public int getCageCount() {
-        return cageCount;
+        return cageList.size();
     }
 
-}
-
-class Cell {
-    private int cageID;
 
-    public Cell (int cageID) {
-        this.cageID = cageID;
+    public void setCageList(List<Cage> cageList) {
+        this.cageList = cageList;
     }
-
-    public int getCageId() {return cageID; }
 }

src/com/patryk/mathdoku/cageData/Cell.java

+package com.patryk.mathdoku.cageData;
+
+public class Cell {
+    private int cageID;
+
+    public Cell(int cageID) {
+        this.cageID = cageID;
+    }
+
+    public int getCageId() {
+        return cageID;
+    }
+
+    public void setCageId(int cageID) {
+        this.cageID = cageID;
+    }
+}

src/com/patryk/mathdoku/errorChecking/CageInfo.java

@@ -45,7 +45,7 @@ public class CageInfo {
         populationCount++;
         if (isFull()) {
             int[] cageMemberData = getMembersOfCage();
-            isInvalid = !RecursiveSolver.testSign(cageMemberData, cage.getTarget(), cage.getOperator());
+            isInvalid = !RecursiveChecker.testSign(cageMemberData, cage.getTarget(), cage.getOperator());
         }
     }