Merge pull request #6 from Eric-Butcher/make_solvers

Make solvers

Author: Eric-Butcher

.idea/workspace.xml

@@ -18,5 +18,6 @@ public SolveAction(Model model, View view){
     @Override
     public void actionPerformed(ActionEvent e) {
         this.model.solve();
+        this.view.updateView(this.model.updateView());
     }
 }

src/controller/SolveAction.java

@@ -1,6 +1,8 @@
 package controller;
 
 import model.Model;
+import model.solvers.Solver;
+import model.solvers.SolverAlgorithms;
 import view.View;
 
 import javax.swing.*;
@@ -18,7 +20,9 @@ public SolverSelectAction(Model model, View view){
     }
     @Override
     public void actionPerformed(ActionEvent e) {
-        String algo = ((JComboBox)e.getSource()).getSelectedItem().toString();
-//        this.model.changeSelectedSolvingAlgo(algo);
+        String algoString = ((JComboBox)e.getSource()).getSelectedItem().toString();
+        SolverAlgorithms algoEnum = SolverAlgorithms.valueOf(algoString);
+        Class<Solver> algoClass = (Class<Solver>) algoEnum.getClazz();
+        this.model.changeSelectedSolvingAlgo(algoClass);
     }
 }

src/controller/SolverSelectAction.java

@@ -1,4 +1,6 @@
-package model.generators;
+package model;
+
+import controller.TileUpdate;
 
 import java.util.Objects;
 
@@ -70,6 +72,15 @@ public void removeLeftBorder(){
         this.leftBorder = false;
     }
 
+    public void setTraversed(boolean traversed){
+        this.isTraversed = traversed;
+    }
+
+    public static TileUpdate makeTileUpdateFromCell(Cell cell, boolean isCurrent, boolean toHighlight){
+        TileUpdate retVal = new TileUpdate(cell.getxPos(), cell.getyPos(), cell.isTopBorder(), cell.isRightBorder(), cell.isBottomBorder(), cell.isLeftBorder(), false, cell.isInitialized(), cell.isTraversed(), toHighlight, isCurrent);
+        return retVal;
+    }
+
     @Override
     public boolean equals(Object o) {
         if (this == o) return true;

src/model/generators/Cell.java src/model/Cell.javasrc/model/generators/Cell.java renamed to src/model/Cell.java

@@ -0,0 +1,121 @@
+package model;
+
+import utilities.Constants;
+
+import java.util.ArrayList;
+import java.util.concurrent.ThreadLocalRandom;
+
+public class Grid {
+    private Cell[][] cellGrid = new Cell[Constants.mazeLength][Constants.mazeLength];
+    public Grid(){
+        for (int i = 0; i < 16; i++){
+            for (int j = 0; j < 16; j++){
+                Cell cell = new Cell(i, j);
+                this.cellGrid[i][j] = cell;
+            }
+        }
+    }
+
+    public Cell getCell(int xLoc, int yLoc){
+        if (((xLoc < 0) || (xLoc > 16)) || ((yLoc < 0) || (yLoc > 16))){
+            throw new IllegalArgumentException("Gave location(s) outside of maze bounds. ");
+        };
+        return this.cellGrid[xLoc][yLoc];
+    }
+
+    public Cell getRandomGridCell() {
+
+        int from = 0;
+        int to = 16;
+
+        int x = ThreadLocalRandom.current().nextInt(from, to);
+        int y = ThreadLocalRandom.current().nextInt(from, to);
+
+        return this.getCell(x, y);
+    }
+
+    public void createPathBetweenCells(Cell from, Cell to){
+
+        int fromX = from.getxPos();
+        int fromY = from.getyPos();
+        int toX = to.getxPos();
+        int toY = to.getyPos();
+
+        if ((fromY == toY) && (fromX > toX)){
+            from.removeLeftBorder();
+            to.removeRightBorder();
+        } else if ((fromY == toY) && (fromX < toX)){
+            from.removeRightBorder();
+            to.removeLeftBorder();
+        } else if ((fromX == toX) && (fromY > toY)){
+            from.removeTopBorder();
+            to.removeBottomBorder();
+        } else if ((fromX == toX) && (fromY < toY)){
+            from.removeBottomBorder();
+            to.removeTopBorder();
+        } else {
+            throw new IllegalStateException("Cells provided have malformed coordinates.");
+        }
+
+    }
+
+    public ArrayList<Cell> getAdjacentCells(Cell centerCell){
+        int centerX = centerCell.getxPos();
+        int centerY = centerCell.getyPos();
+
+        int newXIndex;
+        int newYIndex;
+
+        ArrayList<Cell> adjacentCells = new ArrayList<>(4);
+
+        for (int xBump = -1; xBump < 2; xBump++){
+            for (int yBump = -1; yBump < 2; yBump++){
+
+                if (Math.abs(xBump) != Math.abs(yBump)){
+                    newXIndex = centerX + xBump;
+                    newYIndex = centerY + yBump;
+                    if ((newXIndex >= Constants.minCellIndex) &&
+                            (newXIndex <= Constants.maxCellIndex) &&
+                            (newYIndex >= Constants.minCellIndex) &&
+                            (newYIndex <= Constants.maxCellIndex)
+                    ){
+                        Cell adjacent = this.getCell(newXIndex, newYIndex);
+                        adjacentCells.add(adjacent);
+                    }
+
+                }
+            }
+        }
+
+        return adjacentCells;
+    }
+
+    public static boolean isTherePathBetweenCells(Cell from, Cell to){
+
+        int fromX = from.getxPos();
+        int fromY = from.getyPos();
+        int toX = to.getxPos();
+        int toY = to.getyPos();
+
+        if (((fromY == toY) && (fromX == toX + 1)) && ((!from.isLeftBorder()) && (!to.isRightBorder()))){
+            return true;
+        } else if (((fromY == toY) && (fromX + 1 == toX)) && ((!from.isRightBorder()) && (!to.isLeftBorder()))){
+            return true;
+        } else if (((fromX == toX) && (fromY == toY + 1)) && ((!from.isTopBorder()) && (!to.isBottomBorder()))){
+            return true;
+        } else if (((fromX == toX) && (fromY + 1 == toY)) && ((!from.isBottomBorder()) && (!to.isTopBorder()))){
+            return true;
+        }
+        return false;
+    }
+
+    public void unSolveGrid(){
+        for (int i = 0; i < Constants.mazeLength; i++){
+            for (int j = 0; j < Constants.mazeLength; j++){
+                this.cellGrid[i][j].setTraversed(false);
+            }
+        }
+
+    }
+
+}

src/model/Grid.java

@@ -2,6 +2,7 @@
 
 import controller.TileUpdate;
 import controller.ViewUpdatePacket;
+import model.Cell;
 import utilities.Constants;
 
 import java.util.ArrayList;
@@ -33,23 +34,23 @@ public ViewUpdatePacket makeViewUpdatePacket() {
         for (int x = Constants.minCellIndex; x <= Constants.maxCellIndex; x++){
             for (int y = Constants.minCellIndex; y <= Constants.maxCellIndex; y++){
 
-                Cell cell = this.getCell(x, y);
-                TileUpdate tileUpdate = makeTileUpdateFromCell(cell, false, false);
+                Cell cell = this.getGrid().getCell(x, y);
+                TileUpdate tileUpdate = Cell.makeTileUpdateFromCell(cell, false, false);
                 updatePacket.addTileUpdate(tileUpdate);
             }
         }
 
         // Add the current cell at the end, will override its earlier addition
         if (currentCell != null){
-            TileUpdate tileUpdate = makeTileUpdateFromCell(this.getCurrentCell(), true, false);
+            TileUpdate tileUpdate = Cell.makeTileUpdateFromCell(this.getCurrentCell(), true, false);
             updatePacket.addTileUpdate(tileUpdate);
         }
 
         return updatePacket;
     }
 
     private void startStep(){
-        currentCell = this.getRandomGridCell();
+        currentCell = this.getGrid().getRandomGridCell();
         currentCell.initializeCell();
         cellsInitialized++;
     }
@@ -64,10 +65,10 @@ public void iterate(){
             this.startStep();
         }
         else {
-            ArrayList<Cell> neighbors = this.getAdjacentCells(currentCell);
+            ArrayList<Cell> neighbors = this.getGrid().getAdjacentCells(currentCell);
             Cell chosen = popRandomCellFromList(neighbors);
             if (!chosen.isInitialized()){
-                this.clearPathBetweenCells(currentCell, chosen);
+                this.getGrid().createPathBetweenCells(currentCell, chosen);
                 chosen.initializeCell();
 
                 cellsInitialized++;