diff --git a/bin/main/edu/rpi/legup/legup/config b/bin/main/edu/rpi/legup/legup/config
deleted file mode 100644
index 4aef6de60..000000000
--- a/bin/main/edu/rpi/legup/legup/config
+++ /dev/null
@@ -1,47 +0,0 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/puzzles files/binary/6x6 easy/089764562 b/puzzles files/binary/6x6 easy/089764562
new file mode 100644
index 000000000..7b22ffc10
--- /dev/null
+++ b/puzzles files/binary/6x6 easy/089764562
@@ -0,0 +1,22 @@
+
+
+
+
+
+ |
+ |
+ |
+ |
+ |
+ |
+ |
+ |
+ |
+ |
+ |
+ |
+
+
+
+
+
\ No newline at end of file
diff --git a/puzzles files/binary/6x6 easy/128903434 b/puzzles files/binary/6x6 easy/128903434
new file mode 100644
index 000000000..ea8ef93b0
--- /dev/null
+++ b/puzzles files/binary/6x6 easy/128903434
@@ -0,0 +1,21 @@
+
+
+
+
+
+ |
+ |
+ |
+ |
+ |
+ |
+ |
+ |
+ |
+ |
+
+
+
+
+
+
\ No newline at end of file
diff --git a/puzzles files/binary/6x6 easy/876868768 b/puzzles files/binary/6x6 easy/876868768
new file mode 100644
index 000000000..0f0ff745e
--- /dev/null
+++ b/puzzles files/binary/6x6 easy/876868768
@@ -0,0 +1,25 @@
+
+
+
+
+
+ |
+ |
+ |
+ |
+ |
+ |
+ |
+ |
+ |
+ |
+ |
+ |
+ |
+ |
+
+
+
+
+
+
\ No newline at end of file
diff --git a/puzzles files/binary/6x6 easy/927364891 b/puzzles files/binary/6x6 easy/927364891
new file mode 100644
index 000000000..da76d067b
--- /dev/null
+++ b/puzzles files/binary/6x6 easy/927364891
@@ -0,0 +1,28 @@
+
+
+
+
+
+ |
+ |
+ |
+ |
+ |
+ |
+ |
+ |
+ |
+ |
+ |
+ |
+ |
+ |
+ |
+ |
+ |
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/main/java/edu/rpi/legup/model/gameboard/GridRegion.java b/src/main/java/edu/rpi/legup/model/gameboard/GridRegion.java
index 6718ab6f4..c41d5e1b2 100644
--- a/src/main/java/edu/rpi/legup/model/gameboard/GridRegion.java
+++ b/src/main/java/edu/rpi/legup/model/gameboard/GridRegion.java
@@ -4,18 +4,17 @@
import java.util.List;
public abstract class GridRegion {
-
+
protected List regionCells;
-
- /**
- * Region Constructor
- */
+
+ /** Region Constructor */
public GridRegion() {
this.regionCells = new ArrayList<>();
}
/**
* Adds the cell to the region
+ *
* @param cell cell to be added to the region
*/
public void addCell(T cell) {
@@ -24,6 +23,7 @@ public void addCell(T cell) {
/**
* Removes the cell from the region
+ *
* @param cell cell to be remove from the region
*/
public void removeCell(T cell) {
@@ -32,6 +32,7 @@ public void removeCell(T cell) {
/**
* Returns the list of cells in the region
+ *
* @return list of cells in region
*/
public List getCells() {
@@ -40,14 +41,15 @@ public List getCells() {
/**
* Returns the number of cells in the region
+ *
* @return number of cells in the region
*/
- public int getSize(){
+ public int getSize() {
return regionCells.size();
}
/*
public void colorRegion(){}
*/
-
+
}
diff --git a/src/main/java/edu/rpi/legup/puzzle/binary/Binary.java b/src/main/java/edu/rpi/legup/puzzle/binary/Binary.java
new file mode 100644
index 000000000..773513cda
--- /dev/null
+++ b/src/main/java/edu/rpi/legup/puzzle/binary/Binary.java
@@ -0,0 +1,71 @@
+package edu.rpi.legup.puzzle.binary;
+
+import edu.rpi.legup.model.Puzzle;
+import edu.rpi.legup.model.gameboard.Board;
+import edu.rpi.legup.model.gameboard.PuzzleElement;
+import edu.rpi.legup.model.rules.ContradictionRule;
+
+public class Binary extends Puzzle {
+ public Binary() {
+ super();
+
+ this.name = "Binary";
+
+ this.importer = new BinaryImporter(this);
+ this.exporter = new BinaryExporter(this);
+
+ this.factory = new BinaryCellFactory();
+ }
+
+ /** Initializes the game board. Called by the invoker of the class */
+ @Override
+ public void initializeView() {
+ boardView = new BinaryView((BinaryBoard) currentBoard);
+ boardView.setBoard(currentBoard);
+ addBoardListener(boardView);
+ }
+
+ /**
+ * Generates a random edu.rpi.legup.puzzle based on the difficulty
+ *
+ * @param difficulty level of difficulty (1-10)
+ * @return board of the random edu.rpi.legup.puzzle
+ */
+ @Override
+ public Board generatePuzzle(int difficulty) {
+ return null;
+ }
+
+ // /**
+ // * Determines if the given dimensions are valid for Binary
+ // *
+ // * @param rows the number of rows
+ // * @param columns the number of columns
+ // * @return true if the given dimensions are valid for Binary, false otherwise
+ // */
+ // @Override
+ // public boolean isValidDimensions(int rows, int columns){
+ // return rows >= 2 && rows % 2 == 0 && columns >= 2 && columns % 2 == 0;
+ // }
+
+ @Override
+ public boolean isBoardComplete(Board board) {
+ BinaryBoard binaryBoard = (BinaryBoard) board;
+
+ for (ContradictionRule rule : contradictionRules) {
+ if (rule.checkContradiction(binaryBoard) == null) {
+ return false;
+ }
+ }
+ for (PuzzleElement data : binaryBoard.getPuzzleElements()) {
+ BinaryCell cell = (BinaryCell) data;
+ if (cell.getType() == BinaryType.UNKNOWN) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ @Override
+ public void onBoardChange(Board board) {}
+}
diff --git a/src/main/java/edu/rpi/legup/puzzle/binary/BinaryBoard.java b/src/main/java/edu/rpi/legup/puzzle/binary/BinaryBoard.java
new file mode 100644
index 000000000..35c37b1a1
--- /dev/null
+++ b/src/main/java/edu/rpi/legup/puzzle/binary/BinaryBoard.java
@@ -0,0 +1,84 @@
+package edu.rpi.legup.puzzle.binary;
+
+import edu.rpi.legup.model.gameboard.GridBoard;
+import edu.rpi.legup.model.gameboard.PuzzleElement;
+import java.awt.*;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Set;
+
+public class BinaryBoard extends GridBoard {
+ private int size;
+
+ public BinaryBoard(int width, int height) {
+ super(width, height);
+ this.size = width;
+ }
+
+ public BinaryBoard(int size) {
+ super(size, size);
+ this.size = size;
+ }
+
+ @Override
+ public BinaryCell getCell(int x, int y) {
+ if (y * dimension.width + x >= puzzleElements.size()
+ || x >= dimension.width
+ || y >= dimension.height
+ || x < 0
+ || y < 0) {
+ return null;
+ }
+ return (BinaryCell) super.getCell(x, y);
+ }
+
+ public Set getRowCells(int rowNum) {
+ Set row = new HashSet<>();
+ for (int i = 0; i < size; i++) {
+ BinaryCell cell = getCell(i, rowNum);
+ row.add(cell);
+ }
+ return row;
+ }
+
+ public ArrayList getRowTypes(int rowNum) {
+ ArrayList row = new ArrayList();
+ for (int i = 0; i < size; i++) {
+ BinaryCell cell = getCell(i, rowNum);
+ row.add(cell.getType());
+ }
+ return row;
+ }
+
+ public ArrayList getColTypes(int colNum) {
+ ArrayList col = new ArrayList();
+ for (int i = 0; i < size; i++) {
+ BinaryCell cell = getCell(colNum, i);
+ col.add(cell.getType());
+ }
+ return col;
+ }
+
+ public Set getCol(int colNum) {
+ Set col = new HashSet<>();
+ for (int i = 0; i < size; i++) {
+ col.add(getCell(colNum, i));
+ }
+ return col;
+ }
+
+ @Override
+ public BinaryBoard copy() {
+ System.out.println("BinaryBoard copy()");
+ BinaryBoard copy = new BinaryBoard(dimension.width, dimension.height);
+ for (int x = 0; x < this.dimension.width; x++) {
+ for (int y = 0; y < this.dimension.height; y++) {
+ copy.setCell(x, y, getCell(x, y).copy());
+ }
+ }
+ for (PuzzleElement e : modifiedData) {
+ copy.getPuzzleElement(e).setModifiable(false);
+ }
+ return copy;
+ }
+}
diff --git a/src/main/java/edu/rpi/legup/puzzle/binary/BinaryCell.java b/src/main/java/edu/rpi/legup/puzzle/binary/BinaryCell.java
new file mode 100644
index 000000000..9007215ad
--- /dev/null
+++ b/src/main/java/edu/rpi/legup/puzzle/binary/BinaryCell.java
@@ -0,0 +1,35 @@
+package edu.rpi.legup.puzzle.binary;
+
+import edu.rpi.legup.model.gameboard.GridCell;
+import java.awt.Point;
+
+public class BinaryCell extends GridCell {
+ public BinaryCell(int valueInt, Point location) {
+ super(valueInt, location);
+ }
+
+ public BinaryType getType() {
+ switch (data) {
+ case 0:
+ return BinaryType.ZERO;
+ case 1:
+ return BinaryType.ONE;
+ case 2:
+ return BinaryType.UNKNOWN;
+ default:
+ if (data > 1) {
+ return BinaryType.UNKNOWN;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public BinaryCell copy() {
+ BinaryCell copy = new BinaryCell(data, (Point) location.clone());
+ copy.setIndex(index);
+ copy.setModifiable(isModifiable);
+ copy.setGiven(isGiven);
+ return copy;
+ }
+}
diff --git a/src/main/java/edu/rpi/legup/puzzle/binary/BinaryCellFactory.java b/src/main/java/edu/rpi/legup/puzzle/binary/BinaryCellFactory.java
new file mode 100644
index 000000000..890c26656
--- /dev/null
+++ b/src/main/java/edu/rpi/legup/puzzle/binary/BinaryCellFactory.java
@@ -0,0 +1,59 @@
+package edu.rpi.legup.puzzle.binary;
+
+import edu.rpi.legup.model.gameboard.Board;
+import edu.rpi.legup.model.gameboard.ElementFactory;
+import edu.rpi.legup.model.gameboard.PuzzleElement;
+import edu.rpi.legup.save.InvalidFileFormatException;
+import java.awt.*;
+import org.w3c.dom.Document;
+import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.Node;
+
+public class BinaryCellFactory extends ElementFactory {
+
+ public BinaryCell importCell(Node node, Board board) throws InvalidFileFormatException {
+ try {
+ if (!node.getNodeName().equalsIgnoreCase("cell")) {
+ throw new InvalidFileFormatException(
+ "binary Factory: unknown puzzleElement puzzleElement");
+ }
+
+ BinaryBoard binaryBoard = (BinaryBoard) board;
+ int width = binaryBoard.getWidth();
+ int height = binaryBoard.getHeight();
+
+ NamedNodeMap attributeList = node.getAttributes();
+ int value = Integer.valueOf(attributeList.getNamedItem("value").getNodeValue());
+ int x = Integer.valueOf(attributeList.getNamedItem("x").getNodeValue());
+ int y = Integer.valueOf(attributeList.getNamedItem("y").getNodeValue());
+
+ if (x >= width || y >= height) {
+ throw new InvalidFileFormatException("binary Factory: cell location out of bounds");
+ }
+ if (value < -2) {
+ throw new InvalidFileFormatException("binary Factory: cell unknown value");
+ }
+
+ BinaryCell cell = new BinaryCell(value, new Point(x, y));
+ cell.setIndex(y * height + x);
+ return cell;
+ } catch (NumberFormatException e) {
+ throw new InvalidFileFormatException(
+ "binary Factory: unknown value where integer expected");
+ } catch (NullPointerException e) {
+ throw new InvalidFileFormatException("binary Factory: could not find attribute(s)");
+ }
+ }
+
+ public org.w3c.dom.Element exportCell(Document document, PuzzleElement puzzleElement) {
+ org.w3c.dom.Element cellElement = document.createElement("cell");
+
+ BinaryCell cell = (BinaryCell) puzzleElement;
+ Point loc = cell.getLocation();
+ cellElement.setAttribute("value", String.valueOf(cell.getData()));
+ cellElement.setAttribute("x", String.valueOf(loc.x));
+ cellElement.setAttribute("y", String.valueOf(loc.y));
+
+ return cellElement;
+ }
+}
diff --git a/src/main/java/edu/rpi/legup/puzzle/binary/BinaryController.java b/src/main/java/edu/rpi/legup/puzzle/binary/BinaryController.java
new file mode 100644
index 000000000..0bad559d9
--- /dev/null
+++ b/src/main/java/edu/rpi/legup/puzzle/binary/BinaryController.java
@@ -0,0 +1,45 @@
+package edu.rpi.legup.puzzle.binary;
+
+import edu.rpi.legup.controller.ElementController;
+import edu.rpi.legup.model.gameboard.PuzzleElement;
+import java.awt.event.MouseEvent;
+
+public class BinaryController extends ElementController {
+
+ @Override
+ public void changeCell(MouseEvent e, PuzzleElement data) {
+ BinaryCell cell = (BinaryCell) data;
+ if (e.getButton() == MouseEvent.BUTTON1) {
+ if (e.isControlDown()) {
+ this.boardView
+ .getSelectionPopupMenu()
+ .show(
+ boardView,
+ this.boardView.getCanvas().getX() + e.getX(),
+ this.boardView.getCanvas().getY() + e.getY());
+ } else {
+ if (cell.getData() == 0) {
+ data.setData(1);
+ } else {
+ if (cell.getData() == 1) {
+ data.setData(2);
+ } else {
+ data.setData(0);
+ }
+ }
+ }
+ } else {
+ if (e.getButton() == MouseEvent.BUTTON3) {
+ if (cell.getData() == 0) {
+ data.setData(1);
+ } else {
+ if (cell.getData() == 1) {
+ data.setData(2);
+ } else {
+ data.setData(0);
+ }
+ }
+ }
+ }
+ }
+}
diff --git a/src/main/java/edu/rpi/legup/puzzle/binary/BinaryElementView.java b/src/main/java/edu/rpi/legup/puzzle/binary/BinaryElementView.java
new file mode 100644
index 000000000..9ac99c958
--- /dev/null
+++ b/src/main/java/edu/rpi/legup/puzzle/binary/BinaryElementView.java
@@ -0,0 +1,120 @@
+package edu.rpi.legup.puzzle.binary;
+
+import edu.rpi.legup.ui.boardview.GridElementView;
+import java.awt.*;
+
+public class BinaryElementView extends GridElementView {
+
+ private static final Font FONT = new Font("TimesRoman", Font.BOLD, 17);
+ private static final Color FONT_COLOR = Color.BLACK;
+
+ public BinaryElementView(BinaryCell cell) {
+ super(cell);
+ }
+
+ /**
+ * Gets the PuzzleElement associated with this view
+ *
+ * @return PuzzleElement associated with this view
+ */
+ @Override
+ public BinaryCell getPuzzleElement() {
+ return (BinaryCell) super.getPuzzleElement();
+ }
+
+ @Override
+ public void drawGiven(Graphics2D graphics2D) {
+ BinaryCell cell = (BinaryCell) puzzleElement;
+ BinaryType type = cell.getType();
+ if (type == BinaryType.ZERO) {
+ graphics2D.setStroke(new BasicStroke(1));
+ graphics2D.setColor(Color.LIGHT_GRAY);
+ graphics2D.fillRect(location.x, location.y, size.width, size.height);
+ graphics2D.setColor(Color.BLACK);
+ graphics2D.drawRect(location.x, location.y, size.width, size.height);
+ graphics2D.setColor(FONT_COLOR);
+ graphics2D.setFont(FONT);
+ FontMetrics metrics = graphics2D.getFontMetrics(FONT);
+ String value = String.valueOf(puzzleElement.getData());
+ int xText = location.x + (size.width - metrics.stringWidth(value)) / 2;
+ int yText =
+ location.y + ((size.height - metrics.getHeight()) / 2) + metrics.getAscent();
+ graphics2D.drawString(String.valueOf(puzzleElement.getData()), xText, yText);
+ } else {
+ if (type == BinaryType.ONE) {
+ graphics2D.setStroke(new BasicStroke(1));
+ graphics2D.setColor(Color.LIGHT_GRAY);
+ graphics2D.fillRect(location.x, location.y, size.width, size.height);
+ graphics2D.setColor(Color.BLACK);
+ graphics2D.drawRect(location.x, location.y, size.width, size.height);
+ graphics2D.setColor(FONT_COLOR);
+ graphics2D.setFont(FONT);
+ FontMetrics metrics = graphics2D.getFontMetrics(FONT);
+ String value = String.valueOf(puzzleElement.getData());
+ int xText = location.x + (size.width - metrics.stringWidth(value)) / 2;
+ int yText =
+ location.y
+ + ((size.height - metrics.getHeight()) / 2)
+ + metrics.getAscent();
+ graphics2D.drawString(String.valueOf(puzzleElement.getData()), xText, yText);
+
+ } else {
+ if (type == BinaryType.UNKNOWN) {
+ graphics2D.setStroke(new BasicStroke(0));
+ graphics2D.setColor(Color.WHITE);
+ graphics2D.fillRect(location.x, location.y, size.width, size.height);
+ graphics2D.setColor(Color.BLACK);
+ graphics2D.drawRect(location.x, location.y, size.width, size.height);
+ }
+ }
+ }
+ }
+
+ @Override
+ public void drawElement(Graphics2D graphics2D) {
+ BinaryCell cell = (BinaryCell) puzzleElement;
+ BinaryType type = cell.getType();
+ if (type == BinaryType.ZERO) {
+ graphics2D.setStroke(new BasicStroke(1));
+ graphics2D.setColor(Color.WHITE);
+ graphics2D.fillRect(location.x, location.y, size.width, size.height);
+ graphics2D.setColor(Color.BLACK);
+ graphics2D.drawRect(location.x, location.y, size.width, size.height);
+ graphics2D.setColor(FONT_COLOR);
+ graphics2D.setFont(FONT);
+ FontMetrics metrics = graphics2D.getFontMetrics(FONT);
+ String value = String.valueOf(puzzleElement.getData());
+ int xText = location.x + (size.width - metrics.stringWidth(value)) / 2;
+ int yText =
+ location.y + ((size.height - metrics.getHeight()) / 2) + metrics.getAscent();
+ graphics2D.drawString(String.valueOf(puzzleElement.getData()), xText, yText);
+ } else {
+ if (type == BinaryType.ONE) {
+ graphics2D.setStroke(new BasicStroke(1));
+ graphics2D.setColor(Color.WHITE);
+ graphics2D.fillRect(location.x, location.y, size.width, size.height);
+ graphics2D.setColor(Color.BLACK);
+ graphics2D.drawRect(location.x, location.y, size.width, size.height);
+ graphics2D.setColor(FONT_COLOR);
+ graphics2D.setFont(FONT);
+ FontMetrics metrics = graphics2D.getFontMetrics(FONT);
+ String value = String.valueOf(puzzleElement.getData());
+ int xText = location.x + (size.width - metrics.stringWidth(value)) / 2;
+ int yText =
+ location.y
+ + ((size.height - metrics.getHeight()) / 2)
+ + metrics.getAscent();
+ graphics2D.drawString(String.valueOf(puzzleElement.getData()), xText, yText);
+
+ } else {
+ if (type == BinaryType.UNKNOWN) {
+ graphics2D.setStroke(new BasicStroke(0));
+ graphics2D.setColor(Color.WHITE);
+ graphics2D.fillRect(location.x, location.y, size.width, size.height);
+ graphics2D.setColor(Color.BLACK);
+ graphics2D.drawRect(location.x, location.y, size.width, size.height);
+ }
+ }
+ }
+ }
+}
diff --git a/src/main/java/edu/rpi/legup/puzzle/binary/BinaryExporter.java b/src/main/java/edu/rpi/legup/puzzle/binary/BinaryExporter.java
new file mode 100644
index 000000000..cd58314b6
--- /dev/null
+++ b/src/main/java/edu/rpi/legup/puzzle/binary/BinaryExporter.java
@@ -0,0 +1,39 @@
+package edu.rpi.legup.puzzle.binary;
+
+import edu.rpi.legup.model.PuzzleExporter;
+import edu.rpi.legup.model.gameboard.PuzzleElement;
+import org.w3c.dom.Document;
+
+public class BinaryExporter extends PuzzleExporter {
+
+ public BinaryExporter(Binary binary) {
+ super(binary);
+ }
+
+ @Override
+ protected org.w3c.dom.Element createBoardElement(Document newDocument) {
+ BinaryBoard board;
+ if (puzzle.getTree() != null) {
+ board = (BinaryBoard) puzzle.getTree().getRootNode().getBoard();
+ } else {
+ board = (BinaryBoard) puzzle.getBoardView().getBoard();
+ }
+
+ org.w3c.dom.Element boardElement = newDocument.createElement("board");
+ boardElement.setAttribute("width", String.valueOf(board.getWidth()));
+ boardElement.setAttribute("height", String.valueOf(board.getHeight()));
+
+ org.w3c.dom.Element cellsElement = newDocument.createElement("cells");
+ for (PuzzleElement puzzleElement : board.getPuzzleElements()) {
+ BinaryCell cell = (BinaryCell) puzzleElement;
+ if (cell.getData() != -2) {
+ org.w3c.dom.Element cellElement =
+ puzzle.getFactory().exportCell(newDocument, puzzleElement);
+ cellsElement.appendChild(cellElement);
+ }
+ }
+
+ boardElement.appendChild(cellsElement);
+ return boardElement;
+ }
+}
diff --git a/src/main/java/edu/rpi/legup/puzzle/binary/BinaryImporter.java b/src/main/java/edu/rpi/legup/puzzle/binary/BinaryImporter.java
new file mode 100644
index 000000000..2fc5b09ef
--- /dev/null
+++ b/src/main/java/edu/rpi/legup/puzzle/binary/BinaryImporter.java
@@ -0,0 +1,117 @@
+package edu.rpi.legup.puzzle.binary;
+
+import edu.rpi.legup.model.PuzzleImporter;
+import edu.rpi.legup.save.InvalidFileFormatException;
+import java.awt.*;
+import org.w3c.dom.Element;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+
+public class BinaryImporter extends PuzzleImporter {
+ public BinaryImporter(Binary binary) {
+ super(binary);
+ }
+
+ @Override
+ public boolean acceptsRowsAndColumnsInput() {
+ return true;
+ }
+
+ @Override
+ public boolean acceptsTextInput() {
+ return false;
+ }
+
+ @Override
+ public void initializeBoard(int rows, int columns) {
+ BinaryBoard binaryBoard = new BinaryBoard(columns, rows);
+
+ for (int y = 0; y < rows; y++) {
+ for (int x = 0; x < columns; x++) {
+ BinaryCell cell = new BinaryCell(BinaryType.UNKNOWN.toValue(), new Point(x, y));
+ cell.setIndex(y * columns + x);
+ cell.setModifiable(true);
+ binaryBoard.setCell(x, y, cell);
+ }
+ }
+ puzzle.setCurrentBoard(binaryBoard);
+ }
+
+ /**
+ * Creates the board for building
+ *
+ * @param node xml document node
+ * @throws InvalidFileFormatException if file is invalid
+ */
+ @Override
+ public void initializeBoard(Node node) throws InvalidFileFormatException {
+ try {
+ if (!node.getNodeName().equalsIgnoreCase("board")) {
+ throw new InvalidFileFormatException(
+ "binary Importer: cannot find board puzzleElement");
+ }
+ Element boardElement = (Element) node;
+ if (boardElement.getElementsByTagName("cells").getLength() == 0) {
+ throw new InvalidFileFormatException(
+ "binary Importer: no puzzleElement found for board");
+ }
+
+ Element dataElement = (Element) boardElement.getElementsByTagName("cells").item(0);
+ NodeList elementDataList = dataElement.getElementsByTagName("cell");
+
+ BinaryBoard binaryBoard = null;
+ if (!boardElement.getAttribute("size").isEmpty()) {
+ int size = Integer.valueOf(boardElement.getAttribute("size"));
+ binaryBoard = new BinaryBoard(size);
+ } else {
+ if (!boardElement.getAttribute("width").isEmpty()
+ && !boardElement.getAttribute("height").isEmpty()) {
+ int width = Integer.valueOf(boardElement.getAttribute("width"));
+ int height = Integer.valueOf(boardElement.getAttribute("height"));
+ binaryBoard = new BinaryBoard(width, height);
+ }
+ }
+
+ int width = binaryBoard.getWidth();
+ int height = binaryBoard.getHeight();
+
+ if (binaryBoard == null || width % 2 != 0 || height % 2 != 0) {
+ throw new InvalidFileFormatException("binary Importer: invalid board dimensions");
+ }
+
+ for (int i = 0; i < elementDataList.getLength(); i++) {
+ BinaryCell cell =
+ (BinaryCell)
+ puzzle.getFactory()
+ .importCell(elementDataList.item(i), binaryBoard);
+ Point loc = cell.getLocation();
+ if (cell.getData() != BinaryType.UNKNOWN.toValue()) {
+ cell.setModifiable(false);
+ cell.setGiven(true);
+ }
+ binaryBoard.setCell(loc.x, loc.y, cell);
+ }
+
+ for (int y = 0; y < height; y++) {
+ for (int x = 0; x < width; x++) {
+ if (binaryBoard.getCell(x, y) == null) {
+ BinaryCell cell =
+ new BinaryCell(BinaryType.UNKNOWN.toValue(), new Point(x, y));
+ cell.setIndex(y * height + x);
+ cell.setModifiable(true);
+ binaryBoard.setCell(x, y, cell);
+ }
+ }
+ }
+ puzzle.setCurrentBoard(binaryBoard);
+ } catch (NumberFormatException e) {
+ throw new InvalidFileFormatException(
+ "binary Importer: unknown value where integer expected");
+ }
+ }
+
+ @Override
+ public void initializeBoard(String[] statements) throws UnsupportedOperationException {
+ throw new UnsupportedOperationException("Binary cannot accept text input");
+ }
+}
diff --git a/src/main/java/edu/rpi/legup/puzzle/binary/BinaryType.java b/src/main/java/edu/rpi/legup/puzzle/binary/BinaryType.java
new file mode 100644
index 000000000..6e3413d7a
--- /dev/null
+++ b/src/main/java/edu/rpi/legup/puzzle/binary/BinaryType.java
@@ -0,0 +1,11 @@
+package edu.rpi.legup.puzzle.binary;
+
+public enum BinaryType {
+ ZERO,
+ ONE,
+ UNKNOWN;
+
+ public int toValue() {
+ return this.ordinal();
+ }
+}
diff --git a/src/main/java/edu/rpi/legup/puzzle/binary/BinaryView.java b/src/main/java/edu/rpi/legup/puzzle/binary/BinaryView.java
new file mode 100644
index 000000000..b11554f28
--- /dev/null
+++ b/src/main/java/edu/rpi/legup/puzzle/binary/BinaryView.java
@@ -0,0 +1,24 @@
+package edu.rpi.legup.puzzle.binary;
+
+import edu.rpi.legup.controller.BoardController;
+import edu.rpi.legup.model.gameboard.PuzzleElement;
+import edu.rpi.legup.ui.boardview.GridBoardView;
+import java.awt.*;
+
+public class BinaryView extends GridBoardView {
+
+ public BinaryView(BinaryBoard board) {
+ super(new BoardController(), new BinaryController(), board.getDimension());
+
+ for (PuzzleElement puzzleElement : board.getPuzzleElements()) {
+ BinaryCell cell = (BinaryCell) puzzleElement;
+ Point loc = cell.getLocation();
+ BinaryElementView elementView = new BinaryElementView(cell);
+ elementView.setIndex(cell.getIndex());
+ elementView.setSize(elementSize);
+ elementView.setLocation(
+ new Point(loc.x * elementSize.width, loc.y * elementSize.height));
+ elementViews.add(elementView);
+ }
+ }
+}
diff --git a/src/main/java/edu/rpi/legup/puzzle/binary/elements/BlankTile.java b/src/main/java/edu/rpi/legup/puzzle/binary/elements/BlankTile.java
new file mode 100644
index 000000000..8b1378917
--- /dev/null
+++ b/src/main/java/edu/rpi/legup/puzzle/binary/elements/BlankTile.java
@@ -0,0 +1 @@
+
diff --git a/src/main/java/edu/rpi/legup/puzzle/binary/elements/NumberTile.java b/src/main/java/edu/rpi/legup/puzzle/binary/elements/NumberTile.java
new file mode 100644
index 000000000..8b1378917
--- /dev/null
+++ b/src/main/java/edu/rpi/legup/puzzle/binary/elements/NumberTile.java
@@ -0,0 +1 @@
+
diff --git a/src/main/java/edu/rpi/legup/puzzle/binary/rules/CompleteRowColumnDirectRule.java b/src/main/java/edu/rpi/legup/puzzle/binary/rules/CompleteRowColumnDirectRule.java
new file mode 100644
index 000000000..e38c6b78d
--- /dev/null
+++ b/src/main/java/edu/rpi/legup/puzzle/binary/rules/CompleteRowColumnDirectRule.java
@@ -0,0 +1,55 @@
+package edu.rpi.legup.puzzle.binary.rules;
+
+import edu.rpi.legup.model.gameboard.Board;
+import edu.rpi.legup.model.gameboard.PuzzleElement;
+import edu.rpi.legup.model.rules.ContradictionRule;
+import edu.rpi.legup.model.rules.DirectRule;
+import edu.rpi.legup.model.tree.TreeNode;
+import edu.rpi.legup.model.tree.TreeTransition;
+import edu.rpi.legup.puzzle.binary.BinaryBoard;
+import edu.rpi.legup.puzzle.binary.BinaryCell;
+
+public class CompleteRowColumnDirectRule extends DirectRule {
+
+ public CompleteRowColumnDirectRule() {
+ super(
+ "BINA-BASC-0003",
+ "Complete Row Column",
+ "If a row/column of length n contains n/2 of a single value, the remaining cells must contain the other value",
+ "edu/rpi/legup/images/binary/rules/CompleteRowColumnDirectRule.png");
+ }
+
+ /**
+ * Checks whether the child node logically follows from the parent node at the specific
+ * puzzleElement index using this rule
+ *
+ * @param transition transition to check
+ * @param puzzleElement equivalent puzzleElement
+ * @return null if the child node logically follow from the parent node at the specified
+ * puzzleElement, otherwise error message
+ */
+ @Override
+ public String checkRuleRawAt(TreeTransition transition, PuzzleElement puzzleElement) {
+ BinaryBoard origBoard = (BinaryBoard) transition.getParents().get(0).getBoard();
+ ContradictionRule contraRule = new UnbalancedRowOrColumnContradictionRule();
+ BinaryCell binaryCell = (BinaryCell) puzzleElement;
+ BinaryBoard modified = origBoard.copy();
+ BinaryCell c = (BinaryCell) modified.getPuzzleElement(puzzleElement);
+
+ // System.out.println("ORIG" + binaryCell.getData());
+ // System.out.println("AFTER" + Math.abs(binaryCell.getData() - 1));
+ modified.getPuzzleElement(puzzleElement).setData(binaryCell.getData());
+ System.out.println(contraRule.checkContradictionAt(modified, puzzleElement));
+
+ if (contraRule.checkContradictionAt(modified, puzzleElement) != null) {
+ return null;
+ }
+
+ return "Grouping of Three Ones or Zeros not found";
+ }
+
+ @Override
+ public Board getDefaultBoard(TreeNode node) {
+ return null;
+ }
+}
diff --git a/src/main/java/edu/rpi/legup/puzzle/binary/rules/DuplicateRowsOrColumnsContradictionRule.java b/src/main/java/edu/rpi/legup/puzzle/binary/rules/DuplicateRowsOrColumnsContradictionRule.java
new file mode 100644
index 000000000..8b0d88ae4
--- /dev/null
+++ b/src/main/java/edu/rpi/legup/puzzle/binary/rules/DuplicateRowsOrColumnsContradictionRule.java
@@ -0,0 +1,55 @@
+package edu.rpi.legup.puzzle.binary.rules;
+
+import edu.rpi.legup.model.gameboard.Board;
+import edu.rpi.legup.model.gameboard.PuzzleElement;
+import edu.rpi.legup.model.rules.ContradictionRule;
+import edu.rpi.legup.puzzle.binary.BinaryBoard;
+import edu.rpi.legup.puzzle.binary.BinaryCell;
+import edu.rpi.legup.puzzle.binary.BinaryType;
+import java.util.ArrayList;
+
+public class DuplicateRowsOrColumnsContradictionRule extends ContradictionRule {
+ private final String NO_CONTRADICTION_MESSAGE =
+ "Does not contain a contradiction at this index";
+ private final String INVALID_USE_MESSAGE = "Row or column must have a value in each cell";
+
+ public DuplicateRowsOrColumnsContradictionRule() {
+ super(
+ "BINA-CONT-0003",
+ "Duplicate Rows Or Columns",
+ "There must not be two rows or two columns that are duplicates",
+ "edu/rpi/legup/images/binary/rules/DuplicateRowOrColumnContradictionRule.png");
+ }
+
+ @Override
+ public String checkContradictionAt(Board board, PuzzleElement puzzleElement) {
+ BinaryBoard binaryBoard = (BinaryBoard) board;
+ BinaryCell cell = (BinaryCell) binaryBoard.getPuzzleElement(puzzleElement);
+
+ ArrayList row = binaryBoard.getRowTypes(cell.getLocation().y);
+
+ int size = row.size();
+
+ for (int i = 0; i < size; i++) {
+ if (i > cell.getLocation().y) {
+ ArrayList currRow = binaryBoard.getRowTypes(i);
+ if (currRow.equals(row)) {
+ return null;
+ }
+ }
+ }
+
+ ArrayList col = binaryBoard.getColTypes(cell.getLocation().x);
+
+ for (int i = 0; i < size; i++) {
+ if (i > cell.getLocation().x) {
+ ArrayList currCol = binaryBoard.getColTypes(i);
+ if (currCol.equals(col)) {
+ return null;
+ }
+ }
+ }
+
+ return super.getNoContradictionMessage() + ": " + this.NO_CONTRADICTION_MESSAGE;
+ }
+}
diff --git a/src/main/java/edu/rpi/legup/puzzle/binary/rules/OneOrZeroCaseRule.java b/src/main/java/edu/rpi/legup/puzzle/binary/rules/OneOrZeroCaseRule.java
new file mode 100644
index 000000000..70549cd72
--- /dev/null
+++ b/src/main/java/edu/rpi/legup/puzzle/binary/rules/OneOrZeroCaseRule.java
@@ -0,0 +1,90 @@
+package edu.rpi.legup.puzzle.binary.rules;
+
+import edu.rpi.legup.model.gameboard.Board;
+import edu.rpi.legup.model.gameboard.CaseBoard;
+import edu.rpi.legup.model.gameboard.PuzzleElement;
+import edu.rpi.legup.model.rules.CaseRule;
+import edu.rpi.legup.model.tree.TreeTransition;
+import edu.rpi.legup.puzzle.binary.BinaryBoard;
+import edu.rpi.legup.puzzle.binary.BinaryCell;
+import edu.rpi.legup.puzzle.binary.BinaryType;
+import java.util.ArrayList;
+import java.util.List;
+
+public class OneOrZeroCaseRule extends CaseRule {
+
+ public OneOrZeroCaseRule() {
+ super(
+ "BINA-CASE-0001",
+ "One or Zero",
+ "Each blank cell is either a one or a zero.",
+ "edu/rpi/legup/images/binary/rules/OneOrZeroCaseRule.png");
+ }
+
+ @Override
+ public String checkRuleRaw(TreeTransition transition) {
+ List childTransitions = transition.getParents().get(0).getChildren();
+ if (childTransitions.size() != 2) {
+ return super.getInvalidUseOfRuleMessage() + ": This case rule must have 2 children.";
+ }
+
+ TreeTransition case1 = childTransitions.get(0);
+ TreeTransition case2 = childTransitions.get(1);
+ if (case1.getBoard().getModifiedData().size() != 1
+ || case2.getBoard().getModifiedData().size() != 1) {
+ return super.getInvalidUseOfRuleMessage()
+ + ": This case rule must have 1 modified cell for each case.";
+ }
+
+ BinaryCell mod1 = (BinaryCell) case1.getBoard().getModifiedData().iterator().next();
+ BinaryCell mod2 = (BinaryCell) case2.getBoard().getModifiedData().iterator().next();
+ if (!mod1.getLocation().equals(mod2.getLocation())) {
+ return super.getInvalidUseOfRuleMessage()
+ + ": This case rule must modify the same cell for each case.";
+ }
+
+ if (!((mod1.getType() == BinaryType.ZERO && mod2.getType() == BinaryType.ONE)
+ || (mod2.getType() == BinaryType.ZERO && mod1.getType() == BinaryType.ONE))) {
+ return super.getInvalidUseOfRuleMessage()
+ + ": This case rule must an empty white and black cell.";
+ }
+
+ return null;
+ }
+
+ @Override
+ public CaseBoard getCaseBoard(Board board) {
+ BinaryBoard binaryBoard = (BinaryBoard) board.copy();
+ CaseBoard caseBoard = new CaseBoard(binaryBoard, this);
+ binaryBoard.setModifiable(false);
+ for (PuzzleElement element : binaryBoard.getPuzzleElements()) {
+ if (((BinaryCell) element).getType() == BinaryType.UNKNOWN) {
+ caseBoard.addPickableElement(element);
+ }
+ }
+ return caseBoard;
+ }
+
+ @Override
+ public ArrayList getCases(Board board, PuzzleElement puzzleElement) {
+ ArrayList cases = new ArrayList<>();
+ Board case1 = board.copy();
+ PuzzleElement data1 = case1.getPuzzleElement(puzzleElement);
+ data1.setData(BinaryType.ZERO.toValue());
+ case1.addModifiedData(data1);
+ cases.add(case1);
+
+ Board case2 = board.copy();
+ PuzzleElement data2 = case2.getPuzzleElement(puzzleElement);
+ data2.setData(BinaryType.ONE.toValue());
+ case2.addModifiedData(data2);
+ cases.add(case2);
+
+ return cases;
+ }
+
+ @Override
+ public String checkRuleRawAt(TreeTransition transition, PuzzleElement puzzleElement) {
+ return null;
+ }
+}
diff --git a/src/main/java/edu/rpi/legup/puzzle/binary/rules/OneTileGapDirectRule.java b/src/main/java/edu/rpi/legup/puzzle/binary/rules/OneTileGapDirectRule.java
new file mode 100644
index 000000000..2e1e96fa5
--- /dev/null
+++ b/src/main/java/edu/rpi/legup/puzzle/binary/rules/OneTileGapDirectRule.java
@@ -0,0 +1,64 @@
+package edu.rpi.legup.puzzle.binary.rules;
+
+import edu.rpi.legup.model.gameboard.Board;
+import edu.rpi.legup.model.gameboard.PuzzleElement;
+import edu.rpi.legup.model.rules.ContradictionRule;
+import edu.rpi.legup.model.rules.DirectRule;
+import edu.rpi.legup.model.tree.TreeNode;
+import edu.rpi.legup.model.tree.TreeTransition;
+import edu.rpi.legup.puzzle.binary.BinaryBoard;
+import edu.rpi.legup.puzzle.binary.BinaryCell;
+
+public class OneTileGapDirectRule extends DirectRule {
+ private final String INVALID_USE_MESSAGE = "Number at cell is incorrect";
+
+ public OneTileGapDirectRule() {
+ super(
+ "BINA-BASC-0002",
+ "One Tile Gap",
+ "If an empty tile is in between the same value, fill the gap with the other value.",
+ "edu/rpi/legup/images/binary/rules/OneTileGapDirectRule.png");
+ }
+
+ boolean checkLeftRight(BinaryCell c, BinaryBoard board) {
+ int x = c.getLocation().x;
+ int y = c.getLocation().y;
+ return board.getCell(x - 1, y).getType() != c.getType()
+ || board.getCell(x + 1, y).getType() != c.getType();
+ }
+
+ boolean checkUpDown(BinaryCell c, BinaryBoard board) {
+ int x = c.getLocation().x;
+ int y = c.getLocation().y;
+ return board.getCell(x, y - 1).getType() != c.getType()
+ || board.getCell(x, y + 1).getType() != c.getType();
+ }
+
+ @Override
+ public String checkRuleRawAt(TreeTransition transition, PuzzleElement puzzleElement) {
+ BinaryBoard origBoard = (BinaryBoard) transition.getParents().get(0).getBoard();
+ ContradictionRule contraRule = new ThreeAdjacentContradictionRule();
+ BinaryCell binaryCell = (BinaryCell) puzzleElement;
+ BinaryBoard modified = origBoard.copy();
+
+ // System.out.println("ORIG" + binaryCell.getData());
+ // System.out.println("AFTER" + Math.abs(binaryCell.getData() - 1));
+ modified.getPuzzleElement(puzzleElement).setData(Math.abs(binaryCell.getData() - 1));
+
+ PuzzleElement newP = binaryCell;
+
+ System.out.println(contraRule.checkContradictionAt(modified, newP));
+
+ if (contraRule.checkContradictionAt(modified, newP) == null) {
+ return null;
+ }
+ modified.getPuzzleElement(puzzleElement).setData(Math.abs(binaryCell.getData() - 1));
+
+ return "Grouping of Three Ones or Zeros not found";
+ }
+
+ @Override
+ public Board getDefaultBoard(TreeNode node) {
+ return null;
+ }
+}
diff --git a/src/main/java/edu/rpi/legup/puzzle/binary/rules/SurroundPairDirectRule.java b/src/main/java/edu/rpi/legup/puzzle/binary/rules/SurroundPairDirectRule.java
new file mode 100644
index 000000000..dc2f07c8b
--- /dev/null
+++ b/src/main/java/edu/rpi/legup/puzzle/binary/rules/SurroundPairDirectRule.java
@@ -0,0 +1,48 @@
+package edu.rpi.legup.puzzle.binary.rules;
+
+import edu.rpi.legup.model.gameboard.Board;
+import edu.rpi.legup.model.gameboard.PuzzleElement;
+import edu.rpi.legup.model.rules.ContradictionRule;
+import edu.rpi.legup.model.rules.DirectRule;
+import edu.rpi.legup.model.tree.TreeNode;
+import edu.rpi.legup.model.tree.TreeTransition;
+import edu.rpi.legup.puzzle.binary.BinaryBoard;
+import edu.rpi.legup.puzzle.binary.BinaryCell;
+
+public class SurroundPairDirectRule extends DirectRule {
+
+ public SurroundPairDirectRule() {
+ super(
+ "BINA-BASC-0001",
+ "Surround Pair",
+ "If two adjacent tiles have the same value, surround the tiles with the other value.",
+ "edu/rpi/legup/images/binary/rules/SurroundPairDirectRule.png");
+ }
+
+ public String checkRuleRawAt(TreeTransition transition, PuzzleElement puzzleElement) {
+ BinaryBoard origBoard = (BinaryBoard) transition.getParents().get(0).getBoard();
+ ContradictionRule contraRule = new ThreeAdjacentContradictionRule();
+ BinaryCell binaryCell = (BinaryCell) puzzleElement;
+ BinaryBoard modified = origBoard.copy();
+
+ // System.out.println("ORIG" + binaryCell.getData());
+ // System.out.println("AFTER" + Math.abs(binaryCell.getData() - 1));
+ modified.getPuzzleElement(puzzleElement).setData(Math.abs(binaryCell.getData() - 1));
+
+ PuzzleElement newP = binaryCell;
+
+ System.out.println(contraRule.checkContradictionAt(modified, newP));
+
+ if (contraRule.checkContradictionAt(modified, newP) == null) {
+ return null;
+ }
+ modified.getPuzzleElement(puzzleElement).setData(Math.abs(binaryCell.getData() - 1));
+
+ return "Grouping of Three Ones or Zeros not found";
+ }
+
+ @Override
+ public Board getDefaultBoard(TreeNode node) {
+ return null;
+ }
+}
diff --git a/src/main/java/edu/rpi/legup/puzzle/binary/rules/ThreeAdjacentContradictionRule.java b/src/main/java/edu/rpi/legup/puzzle/binary/rules/ThreeAdjacentContradictionRule.java
new file mode 100644
index 000000000..075642246
--- /dev/null
+++ b/src/main/java/edu/rpi/legup/puzzle/binary/rules/ThreeAdjacentContradictionRule.java
@@ -0,0 +1,127 @@
+package edu.rpi.legup.puzzle.binary.rules;
+
+import edu.rpi.legup.model.gameboard.Board;
+import edu.rpi.legup.model.gameboard.PuzzleElement;
+import edu.rpi.legup.model.rules.ContradictionRule;
+import edu.rpi.legup.puzzle.binary.BinaryBoard;
+import edu.rpi.legup.puzzle.binary.BinaryCell;
+import edu.rpi.legup.puzzle.binary.BinaryType;
+
+public class ThreeAdjacentContradictionRule extends ContradictionRule {
+ private final String NO_CONTRADICTION_MESSAGE =
+ "Does not contain a contradiction at this index";
+ private final String INVALID_USE_MESSAGE = "Contradiction must be a zero or one";
+
+ public ThreeAdjacentContradictionRule() {
+ super(
+ "BINA-CONT-0001",
+ "Three Adjacent",
+ "There must not be three adjacent zeros or three adjacent ones in a row or column",
+ "edu/rpi/legup/images/binary/rules/ThreeAdjacentContradictionRule.png");
+ }
+
+ @Override
+ public String checkContradictionAt(Board board, PuzzleElement puzzleElement) {
+ BinaryBoard binaryBoard = (BinaryBoard) board;
+ int height = binaryBoard.getHeight();
+ int width = binaryBoard.getWidth();
+
+ BinaryCell cell = (BinaryCell) binaryBoard.getPuzzleElement(puzzleElement);
+ System.out.println("THE CELL IS : " + cell.getType());
+ int cellX = cell.getLocation().x;
+ int cellY = cell.getLocation().y;
+ BinaryCell oneUp = null;
+ BinaryCell oneDown = null;
+ BinaryCell oneForward = null;
+ BinaryCell oneBackward = null;
+ BinaryCell twoUp = null;
+ BinaryCell twoDown = null;
+ BinaryCell twoForward = null;
+ BinaryCell twoBackward = null;
+ if (binaryBoard.getCell(cellX, cellY + 1) != null) {
+ oneUp = binaryBoard.getCell(cellX, cellY + 1);
+ }
+ if (binaryBoard.getCell(cellX, cellY - 1) != null) {
+ oneDown = binaryBoard.getCell(cellX, cellY - 1);
+ }
+ if (binaryBoard.getCell(cellX + 1, cellY) != null) {
+ oneForward = binaryBoard.getCell(cellX + 1, cellY);
+ }
+ if (binaryBoard.getCell(cellX - 1, cellY) != null) {
+ oneBackward = binaryBoard.getCell(cellX - 1, cellY);
+ }
+ if (binaryBoard.getCell(cellX, cellY + 2) != null) {
+ twoUp = binaryBoard.getCell(cellX, cellY + 2);
+ }
+ if (binaryBoard.getCell(cellX, cellY - 2) != null) {
+ twoDown = binaryBoard.getCell(cellX, cellY - 2);
+ }
+ if (binaryBoard.getCell(cellX + 2, cellY) != null) {
+ twoForward = binaryBoard.getCell(cellX + 2, cellY);
+ }
+ if (binaryBoard.getCell(cellX - 2, cellY) != null) {
+ twoBackward = binaryBoard.getCell(cellX - 2, cellY);
+ }
+
+ if (cell.getType() == BinaryType.ONE || cell.getType() == BinaryType.ZERO) {
+ if (twoBackward != null
+ && oneBackward != null
+ && twoBackward.getType() != BinaryType.UNKNOWN
+ && oneBackward.getType() != BinaryType.UNKNOWN) {
+ if (twoBackward.getType() == cell.getType()
+ && oneBackward.getType() == cell.getType()) {
+ System.out.println("1");
+ return null;
+ }
+ }
+ if (twoForward != null
+ && oneForward != null
+ && twoForward.getType() != BinaryType.UNKNOWN
+ && oneForward.getType() != BinaryType.UNKNOWN) {
+ if (twoForward.getType() == cell.getType()
+ && oneForward.getType() == cell.getType()) {
+ System.out.println("2");
+ return null;
+ }
+ }
+ if (twoDown != null
+ && oneDown != null
+ && twoDown.getType() != BinaryType.UNKNOWN
+ && oneDown.getType() != BinaryType.UNKNOWN) {
+ if (twoDown.getType() == cell.getType() && oneDown.getType() == cell.getType()) {
+ System.out.println("3");
+ return null;
+ }
+ }
+ if (twoUp != null
+ && oneUp != null
+ && twoUp.getType() != BinaryType.UNKNOWN
+ && oneUp.getType() != BinaryType.UNKNOWN) {
+ if (twoUp.getType() == cell.getType() && oneUp.getType() == cell.getType()) {
+ System.out.println("4");
+ return null;
+ }
+ }
+ if (oneBackward != null
+ && oneForward != null
+ && oneBackward.getType() != BinaryType.UNKNOWN
+ && oneForward.getType() != BinaryType.UNKNOWN) {
+ if (oneBackward.getType() == cell.getType()
+ && oneForward.getType() == cell.getType()) {
+ System.out.println("5");
+ return null;
+ }
+ }
+ if (oneUp != null
+ && oneDown != null
+ && oneUp.getType() != BinaryType.UNKNOWN
+ && oneDown.getType() != BinaryType.UNKNOWN) {
+ if (oneUp.getType() == cell.getType() && oneDown.getType() == cell.getType()) {
+ System.out.println("6");
+ return null;
+ }
+ }
+ }
+ return super.getNoContradictionMessage() + ": " + this.NO_CONTRADICTION_MESSAGE;
+ }
+}
diff --git a/src/main/java/edu/rpi/legup/puzzle/binary/rules/UnbalancedRowOrColumnContradictionRule.java b/src/main/java/edu/rpi/legup/puzzle/binary/rules/UnbalancedRowOrColumnContradictionRule.java
new file mode 100644
index 000000000..5089b3b5f
--- /dev/null
+++ b/src/main/java/edu/rpi/legup/puzzle/binary/rules/UnbalancedRowOrColumnContradictionRule.java
@@ -0,0 +1,68 @@
+package edu.rpi.legup.puzzle.binary.rules;
+
+import edu.rpi.legup.model.gameboard.Board;
+import edu.rpi.legup.model.gameboard.PuzzleElement;
+import edu.rpi.legup.model.rules.ContradictionRule;
+import edu.rpi.legup.puzzle.binary.BinaryBoard;
+import edu.rpi.legup.puzzle.binary.BinaryCell;
+import edu.rpi.legup.puzzle.binary.BinaryType;
+import java.util.Set;
+
+public class UnbalancedRowOrColumnContradictionRule extends ContradictionRule {
+
+ private final String NO_CONTRADICTION_MESSAGE =
+ "Does not contain a contradiction at this index";
+ private final String INVALID_USE_MESSAGE = "Row or column must have a value in each cell";
+
+ public UnbalancedRowOrColumnContradictionRule() {
+ super(
+ "BINA-CONT-0002",
+ "Unbalanced Row Or Column",
+ "Each row or column must contain an equal number of zeros and ones",
+ "edu/rpi/legup/images/binary/rules/UnbalancedRowColumnContradictionRule.png");
+ }
+
+ @Override
+ public String checkContradictionAt(Board board, PuzzleElement puzzleElement) {
+ BinaryBoard binaryBoard = (BinaryBoard) board;
+
+ BinaryCell cell = (BinaryCell) binaryBoard.getPuzzleElement(puzzleElement);
+ Set row = binaryBoard.getRowCells(cell.getLocation().y);
+
+ int size = row.size();
+ int rowNumZeros = 0;
+ int rowNumOnes = 0;
+
+ for (BinaryCell item : row) {
+ if (item.getType() == BinaryType.ZERO) {
+ rowNumZeros++;
+ } else if (item.getType() == BinaryType.ONE) {
+ rowNumOnes++;
+ }
+ }
+
+ if (rowNumZeros == size / 2 && rowNumOnes == size / 2) {
+ return super.getNoContradictionMessage() + ": " + this.NO_CONTRADICTION_MESSAGE;
+ }
+
+ Set col = binaryBoard.getCol(cell.getLocation().x);
+
+ size = col.size();
+ int colNumZeros = 0;
+ int colNumOnes = 0;
+
+ for (BinaryCell item : col) {
+ if (item.getType() == BinaryType.ZERO) {
+ colNumZeros++;
+ } else if (item.getType() == BinaryType.ONE) {
+ colNumOnes++;
+ }
+ }
+
+ if (colNumZeros == size / 2 && colNumOnes == size / 2) {
+ return super.getNoContradictionMessage() + ": " + this.NO_CONTRADICTION_MESSAGE;
+ }
+
+ return null;
+ }
+}
diff --git a/src/main/java/edu/rpi/legup/puzzle/binary/rules/binary_reference_sheet.txt b/src/main/java/edu/rpi/legup/puzzle/binary/rules/binary_reference_sheet.txt
new file mode 100644
index 000000000..c8cb0d1b9
--- /dev/null
+++ b/src/main/java/edu/rpi/legup/puzzle/binary/rules/binary_reference_sheet.txt
@@ -0,0 +1,9 @@
+BINA-BASC-0001 : SurroundPairDirectRule
+BINA-BASC-0002 : OneTileGapDirectRule
+BINA-BASC-0003 : CompleteRowColumnDirectRule
+
+BINA-CONT-0001 : ThreeAdjacentContradictionRule
+BINA-CONT-0002 : UnbalancedRowOrColumnContradictionRule
+BINA-CONT-0003 : DuplicateRowsOrColumnsContradictionRule
+
+BINA-CASE-0001 : OneOrZeroCaseRule
\ No newline at end of file
diff --git a/src/main/java/edu/rpi/legup/puzzle/starbattle/StarBattle.java b/src/main/java/edu/rpi/legup/puzzle/starbattle/StarBattle.java
index 760fa88b2..39092bbc6 100644
--- a/src/main/java/edu/rpi/legup/puzzle/starbattle/StarBattle.java
+++ b/src/main/java/edu/rpi/legup/puzzle/starbattle/StarBattle.java
@@ -1,4 +1,5 @@
package edu.rpi.legup.puzzle.starbattle;
+
import edu.rpi.legup.model.Puzzle;
import edu.rpi.legup.model.gameboard.Board;
@@ -30,6 +31,5 @@ public boolean isBoardComplete(Board board) {
}
@Override
- public void onBoardChange(Board board) {
- }
+ public void onBoardChange(Board board) {}
}
diff --git a/src/main/java/edu/rpi/legup/puzzle/starbattle/StarBattleBoard.java b/src/main/java/edu/rpi/legup/puzzle/starbattle/StarBattleBoard.java
index 2c4a20ebc..5132f33e4 100644
--- a/src/main/java/edu/rpi/legup/puzzle/starbattle/StarBattleBoard.java
+++ b/src/main/java/edu/rpi/legup/puzzle/starbattle/StarBattleBoard.java
@@ -1,16 +1,16 @@
package edu.rpi.legup.puzzle.starbattle;
-import java.util.*;
-
import edu.rpi.legup.model.gameboard.GridBoard;
import edu.rpi.legup.model.gameboard.PuzzleElement;
+import java.util.*;
public class StarBattleBoard extends GridBoard {
private int size;
private int puzzleNum;
protected List regions;
- //private ArrayList groupSizes;
+
+ // private ArrayList groupSizes;
public StarBattleBoard(int size, int num) {
super(size, size);
@@ -24,10 +24,10 @@ public StarBattleBoard(int size, int num) {
@Override
public StarBattleCell getCell(int x, int y) {
- return (StarBattleCell) super.getCell(x,y);
+ return (StarBattleCell) super.getCell(x, y);
}
- /*
+ /*
public StarBattleCell getCell(int groupIndex, int x, int y) {
return getCell(x + (groupIndex % groupSize) * groupSize, y + (groupIndex / groupSize) * groupSize);
}*/
@@ -44,7 +44,9 @@ public Set getRow(int rowNum) {
return row;
}
- public int getPuzzleNumber() { return puzzleNum; }
+ public int getPuzzleNumber() {
+ return puzzleNum;
+ }
public Set getCol(int colNum) {
Set column = new HashSet<>();
@@ -72,7 +74,7 @@ public void setRegion(int regionNum, StarBattleRegion region) {
public int columnStars(int columnIndex) {
int stars = 0;
if (columnIndex < size) {
- for (StarBattleCell c: this.getCol(columnIndex)) {
+ for (StarBattleCell c : this.getCol(columnIndex)) {
if (c.getType() == StarBattleCellType.STAR) {
++stars;
}
@@ -84,7 +86,7 @@ public int columnStars(int columnIndex) {
public int rowStars(int rowIndex) {
int stars = 0;
if (rowIndex < size) {
- for (StarBattleCell c: this.getRow(rowIndex)) {
+ for (StarBattleCell c : this.getRow(rowIndex)) {
if (c.getType() == StarBattleCellType.STAR) {
++stars;
}
@@ -109,5 +111,3 @@ public StarBattleBoard copy() {
return copy;
}
}
-
-
diff --git a/src/main/java/edu/rpi/legup/puzzle/starbattle/StarBattleCell.java b/src/main/java/edu/rpi/legup/puzzle/starbattle/StarBattleCell.java
index a316872d9..ddae8f882 100644
--- a/src/main/java/edu/rpi/legup/puzzle/starbattle/StarBattleCell.java
+++ b/src/main/java/edu/rpi/legup/puzzle/starbattle/StarBattleCell.java
@@ -2,7 +2,6 @@
import edu.rpi.legup.model.elements.Element;
import edu.rpi.legup.model.gameboard.GridCell;
-
import java.awt.*;
import java.awt.event.MouseEvent;
@@ -13,10 +12,10 @@ public class StarBattleCell extends GridCell {
/**
* StarBattleCell Constructor - creates a new StarBattle cell to hold the puzzleElement
*
- * @param value value of the star battle cell denoting its state
- * @param location location of the cell on the board
+ * @param value value of the star battle cell denoting its state
+ * @param location location of the cell on the board
* @param groupIndex indicates what group # the cell is in.
- * @param size size of the star battle cell
+ * @param size size of the star battle cell
*/
public StarBattleCell(int value, Point location, int groupIndex, int size) {
super(value, location);
@@ -24,7 +23,9 @@ public StarBattleCell(int value, Point location, int groupIndex, int size) {
this.max = size;
}
- public int getGroupIndex() { return groupIndex; }
+ public int getGroupIndex() {
+ return groupIndex;
+ }
@Override
public void setType(Element e, MouseEvent m) {
@@ -38,27 +39,25 @@ public void setType(Element e, MouseEvent m) {
case "STBL-PLAC-0003":
this.data = -1;
break;
-
- case "STBL-UNPL-0001"://Not sure how button events work
- switch (m.getButton()){
+
+ case "STBL-UNPL-0001": // Not sure how button events work
+ switch (m.getButton()) {
case MouseEvent.BUTTON1:
if (this.data > 0 || this.data < -3) {
this.data = -3;
- }
- else {
+ } else {
this.data = this.data + 1;
}
break;
case MouseEvent.BUTTON3:
if (this.data > -4) {
this.data = this.data - 1;
- }
- else {
- this.data = -1;//Unsure
+ } else {
+ this.data = -1; // Unsure
}
break;
}
- break;
+ break;
}
}
@@ -85,4 +84,4 @@ public StarBattleCell copy() {
copy.setGiven(isGiven);
return copy;
}
-}
\ No newline at end of file
+}
diff --git a/src/main/java/edu/rpi/legup/puzzle/starbattle/StarBattleCellFactory.java b/src/main/java/edu/rpi/legup/puzzle/starbattle/StarBattleCellFactory.java
index 9f7fd0fee..eb2a830f6 100644
--- a/src/main/java/edu/rpi/legup/puzzle/starbattle/StarBattleCellFactory.java
+++ b/src/main/java/edu/rpi/legup/puzzle/starbattle/StarBattleCellFactory.java
@@ -1,20 +1,21 @@
package edu.rpi.legup.puzzle.starbattle;
+
import edu.rpi.legup.model.gameboard.Board;
import edu.rpi.legup.model.gameboard.ElementFactory;
import edu.rpi.legup.model.gameboard.PuzzleElement;
import edu.rpi.legup.save.InvalidFileFormatException;
+import java.awt.*;
import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
-import java.awt.*;
-
public class StarBattleCellFactory extends ElementFactory {
@Override
public StarBattleCell importCell(Node node, Board board) throws InvalidFileFormatException {
try {
if (!node.getNodeName().equalsIgnoreCase("cell")) {
- throw new InvalidFileFormatException("starbattle Factory: unknown puzzleElement puzzleElement");
+ throw new InvalidFileFormatException(
+ "starbattle Factory: unknown puzzleElement puzzleElement");
}
StarBattleBoard starbattleBoard = (StarBattleBoard) board;
@@ -24,28 +25,27 @@ public StarBattleCell importCell(Node node, Board board) throws InvalidFileForma
int value = Integer.valueOf(attributeList.getNamedItem("value").getNodeValue());
int x = Integer.valueOf(attributeList.getNamedItem("x").getNodeValue());
int y = Integer.valueOf(attributeList.getNamedItem("y").getNodeValue());
- int groupIndex = Integer.valueOf(attributeList.getNamedItem("groupIndex").getNodeValue());
+ int groupIndex =
+ Integer.valueOf(attributeList.getNamedItem("groupIndex").getNodeValue());
if (x >= size || y >= size) {
- throw new InvalidFileFormatException("starbattle Factory: cell location out of bounds");
+ throw new InvalidFileFormatException(
+ "starbattle Factory: cell location out of bounds");
}
if (groupIndex >= size || groupIndex < 0) {
throw new InvalidFileFormatException("starbattle Factory: not in a valid region");
}
- if (value != 0) { //ALL INITIAL PUZZLES ARE BLANK, SUBJECT TO CHANGE
+ if (value != 0) { // ALL INITIAL PUZZLES ARE BLANK, SUBJECT TO CHANGE
throw new InvalidFileFormatException("starbattle Factory: cell unknown value");
}
StarBattleCell cell = new StarBattleCell(value, new Point(x, y), groupIndex, size);
cell.setIndex(y * size + x);
return cell;
- }
-
- catch (NumberFormatException e1) {
+ } catch (NumberFormatException e1) {
e1.printStackTrace();
- throw new InvalidFileFormatException("starbattle Factory: unknown value where integer expected");
- }
-
- catch (NullPointerException e2) {
+ throw new InvalidFileFormatException(
+ "starbattle Factory: unknown value where integer expected");
+ } catch (NullPointerException e2) {
e2.printStackTrace();
throw new InvalidFileFormatException("starbattle Factory: could not find attribute(s)");
}
diff --git a/src/main/java/edu/rpi/legup/puzzle/starbattle/StarBattleCellType.java b/src/main/java/edu/rpi/legup/puzzle/starbattle/StarBattleCellType.java
index 565f608d7..e48e46fcb 100644
--- a/src/main/java/edu/rpi/legup/puzzle/starbattle/StarBattleCellType.java
+++ b/src/main/java/edu/rpi/legup/puzzle/starbattle/StarBattleCellType.java
@@ -1,12 +1,14 @@
-//StarBattleCellType.java
+// StarBattleCellType.java
package edu.rpi.legup.puzzle.starbattle;
public enum StarBattleCellType {
- STAR(-2), BLACK(-1), UNKNOWN(0);
+ STAR(-2),
+ BLACK(-1),
+ UNKNOWN(0);
- public int value;
+ public int value;
StarBattleCellType(int value) {
this.value = value;
}
-}
\ No newline at end of file
+}
diff --git a/src/main/java/edu/rpi/legup/puzzle/starbattle/StarBattleController.java b/src/main/java/edu/rpi/legup/puzzle/starbattle/StarBattleController.java
index 4ebeb39ba..ba19361c9 100644
--- a/src/main/java/edu/rpi/legup/puzzle/starbattle/StarBattleController.java
+++ b/src/main/java/edu/rpi/legup/puzzle/starbattle/StarBattleController.java
@@ -2,7 +2,6 @@
import edu.rpi.legup.controller.ElementController;
import edu.rpi.legup.model.gameboard.PuzzleElement;
-
import java.awt.event.MouseEvent;
public class StarBattleController extends ElementController {
@@ -11,23 +10,24 @@ public void changeCell(MouseEvent e, PuzzleElement data) {
StarBattleCell cell = (StarBattleCell) data;
if (e.getButton() == MouseEvent.BUTTON1) {
if (e.isControlDown()) {
- this.boardView.getSelectionPopupMenu().show(boardView, this.boardView.getCanvas().getX() + e.getX(), this.boardView.getCanvas().getY() + e.getY());
- }
- else {
+ this.boardView
+ .getSelectionPopupMenu()
+ .show(
+ boardView,
+ this.boardView.getCanvas().getX() + e.getX(),
+ this.boardView.getCanvas().getY() + e.getY());
+ } else {
if (cell.getData() >= 0) {
data.setData(-2);
- }
- else {
+ } else {
data.setData(cell.getData() + 1);
}
}
- }
- else {
+ } else {
if (e.getButton() == MouseEvent.BUTTON3) {
if (cell.getData() == -2) {
data.setData(0);
- }
- else {
+ } else {
data.setData(cell.getData() - 1);
}
}
diff --git a/src/main/java/edu/rpi/legup/puzzle/starbattle/StarBattleElementView.java b/src/main/java/edu/rpi/legup/puzzle/starbattle/StarBattleElementView.java
index ff5d54d1c..66d59d364 100644
--- a/src/main/java/edu/rpi/legup/puzzle/starbattle/StarBattleElementView.java
+++ b/src/main/java/edu/rpi/legup/puzzle/starbattle/StarBattleElementView.java
@@ -1,7 +1,6 @@
package edu.rpi.legup.puzzle.starbattle;
import edu.rpi.legup.ui.boardview.GridElementView;
-
import java.awt.*;
public class StarBattleElementView extends GridElementView {
@@ -22,7 +21,14 @@ public void drawElement(Graphics2D graphics2D) {
if (type == StarBattleCellType.STAR) {
graphics2D.setColor(Color.LIGHT_GRAY);
graphics2D.fillRect(location.x, location.y, size.width, size.height);
- graphics2D.drawImage(StarBattleView.STAR, location.x, location.y, size.width, size.height, Color.WHITE, null);
+ graphics2D.drawImage(
+ StarBattleView.STAR,
+ location.x,
+ location.y,
+ size.width,
+ size.height,
+ Color.WHITE,
+ null);
graphics2D.setColor(Color.BLACK);
graphics2D.drawRect(location.x, location.y, size.width, size.height);
} else if (type == StarBattleCellType.BLACK) {
@@ -36,6 +42,5 @@ public void drawElement(Graphics2D graphics2D) {
graphics2D.setColor(Color.BLACK);
graphics2D.drawRect(location.x, location.y, size.width, size.height);
}
-
}
}
diff --git a/src/main/java/edu/rpi/legup/puzzle/starbattle/StarBattleExporter.java b/src/main/java/edu/rpi/legup/puzzle/starbattle/StarBattleExporter.java
index 58fb41e63..f2d2c4d80 100644
--- a/src/main/java/edu/rpi/legup/puzzle/starbattle/StarBattleExporter.java
+++ b/src/main/java/edu/rpi/legup/puzzle/starbattle/StarBattleExporter.java
@@ -1,7 +1,6 @@
package edu.rpi.legup.puzzle.starbattle;
import edu.rpi.legup.model.PuzzleExporter;
-
import org.w3c.dom.Document;
public class StarBattleExporter extends PuzzleExporter {
@@ -20,14 +19,15 @@ protected org.w3c.dom.Element createBoardElement(Document newDocument) {
org.w3c.dom.Element cellsElement = newDocument.createElement("cells");
for (StarBattleCell cell : sb_region.getCells()) {
if (cell.getData() == 0) {
- org.w3c.dom.Element cellElement = puzzle.getFactory().exportCell(newDocument, cell);
+ org.w3c.dom.Element cellElement =
+ puzzle.getFactory().exportCell(newDocument, cell);
cellsElement.appendChild(cellElement);
}
regionsElement.appendChild(cellsElement);
}
boardElement.appendChild(regionsElement);
}
-
+
return boardElement;
}
}
diff --git a/src/main/java/edu/rpi/legup/puzzle/starbattle/StarBattleImporter.java b/src/main/java/edu/rpi/legup/puzzle/starbattle/StarBattleImporter.java
index fa0e065ee..2a608c893 100644
--- a/src/main/java/edu/rpi/legup/puzzle/starbattle/StarBattleImporter.java
+++ b/src/main/java/edu/rpi/legup/puzzle/starbattle/StarBattleImporter.java
@@ -2,37 +2,32 @@
import edu.rpi.legup.model.PuzzleImporter;
import edu.rpi.legup.save.InvalidFileFormatException;
+import java.awt.Point;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
-import java.awt.Point;
+public class StarBattleImporter extends PuzzleImporter {
-public class StarBattleImporter extends PuzzleImporter{
-
-
public StarBattleImporter(StarBattle starbattle) {
super(starbattle);
}
- /**
- * Puzzle setting to support row and column inputs
- */
+ /** Puzzle setting to support row and column inputs */
@Override
public boolean acceptsRowsAndColumnsInput() {
return true;
}
- /**
- * Puzzle setting to disable support for text input
- */
+ /** Puzzle setting to disable support for text input */
@Override
public boolean acceptsTextInput() {
return false;
}
- /**
+ /**
* Constructs empty StarBattle gameboard as per the provided dimensions
+ *
* @param rows number of rows and columns for the gameboard
*/
@Override
@@ -44,6 +39,7 @@ public void initializeBoard(int rows, int columns) {
/**
* Constructs StarBattle gameboard
+ *
* @param node xml document node
* @throws InvalidFileFormatException if file is invalid
*/
@@ -54,10 +50,13 @@ public void initializeBoard(Node node) throws InvalidFileFormatException {
NodeList regionNodes = puzzleElement.getElementsByTagName("region");
int size = Integer.parseInt(puzzleElement.getAttribute("size"));
if (regionNodes.getLength() != size) {
- throw new InvalidFileFormatException("Not the current amount of regions in the puzzle.");
+ throw new InvalidFileFormatException(
+ "Not the current amount of regions in the puzzle.");
}
- StarBattleBoard StarBattleBoard = new StarBattleBoard(size, puzzle_num); // Initialize the board with width and height from XML
+ StarBattleBoard StarBattleBoard =
+ new StarBattleBoard(
+ size, puzzle_num); // Initialize the board with width and height from XML
for (int i = 0; i < regionNodes.getLength(); i++) {
Element regionElement = (Element) regionNodes.item(i);
@@ -87,10 +86,9 @@ public void initializeBoard(Node node) throws InvalidFileFormatException {
puzzle.setCurrentBoard(StarBattleBoard);
}
-
-
/**
* Initialize board via string of statements.
+ *
* @throws UnsupportedOperationException since StarBattle does not support text input
*/
@Override
@@ -98,6 +96,3 @@ public void initializeBoard(String[] statements) throws UnsupportedOperationExce
throw new UnsupportedOperationException("Star Battle does not accept text input");
}
}
-
-
-
diff --git a/src/main/java/edu/rpi/legup/puzzle/starbattle/StarBattleRegion.java b/src/main/java/edu/rpi/legup/puzzle/starbattle/StarBattleRegion.java
index 730f9291f..b35d80655 100644
--- a/src/main/java/edu/rpi/legup/puzzle/starbattle/StarBattleRegion.java
+++ b/src/main/java/edu/rpi/legup/puzzle/starbattle/StarBattleRegion.java
@@ -2,14 +2,14 @@
import edu.rpi.legup.model.gameboard.GridRegion;
-public class StarBattleRegion extends GridRegion{
+public class StarBattleRegion extends GridRegion {
public StarBattleRegion() {
super();
}
public StarBattleRegion copy() {
StarBattleRegion copy = new StarBattleRegion();
- for (StarBattleCell c: regionCells) {
+ for (StarBattleCell c : regionCells) {
copy.addCell(c.copy());
}
return copy;
@@ -17,7 +17,7 @@ public StarBattleRegion copy() {
public int numStars() {
int stars = 0;
- for (StarBattleCell c: regionCells) {
+ for (StarBattleCell c : regionCells) {
if (c.getType() == StarBattleCellType.STAR) {
++stars;
}
diff --git a/src/main/java/edu/rpi/legup/puzzle/starbattle/StarBattleView.java b/src/main/java/edu/rpi/legup/puzzle/starbattle/StarBattleView.java
index ceb0eec19..550b5495d 100644
--- a/src/main/java/edu/rpi/legup/puzzle/starbattle/StarBattleView.java
+++ b/src/main/java/edu/rpi/legup/puzzle/starbattle/StarBattleView.java
@@ -1,26 +1,22 @@
package edu.rpi.legup.puzzle.starbattle;
-import java.io.IOException;
-
-import javax.imageio.ImageIO;
-
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-import edu.rpi.legup.puzzle.starbattle.StarBattleView;
-import edu.rpi.legup.ui.boardview.GridBoardView;
-
import edu.rpi.legup.controller.BoardController;
import edu.rpi.legup.model.gameboard.PuzzleElement;
+import edu.rpi.legup.ui.boardview.GridBoardView;
import java.awt.*;
+import java.io.IOException;
+import javax.imageio.ImageIO;
public class StarBattleView extends GridBoardView {
static Image STAR;
static {
try {
- STAR = ImageIO.read(ClassLoader.getSystemClassLoader().getResource("edu/rpi/legup/images/starbattle/star.gif"));
- }
- catch (IOException e) {
+ STAR =
+ ImageIO.read(
+ ClassLoader.getSystemClassLoader()
+ .getResource("edu/rpi/legup/images/starbattle/star.gif"));
+ } catch (IOException e) {
// pass
}
}
@@ -34,10 +30,9 @@ public StarBattleView(StarBattleBoard board) {
StarBattleElementView elementView = new StarBattleElementView(cell);
elementView.setIndex(cell.getIndex());
elementView.setSize(elementSize);
- elementView.setLocation(new Point(loc.x * elementSize.width, loc.y * elementSize.height));
+ elementView.setLocation(
+ new Point(loc.x * elementSize.width, loc.y * elementSize.height));
elementViews.add(elementView);
}
}
-
-
}
diff --git a/src/main/java/edu/rpi/legup/puzzle/starbattle/elements/BlackTile.java b/src/main/java/edu/rpi/legup/puzzle/starbattle/elements/BlackTile.java
index 2601bd351..99f42886e 100644
--- a/src/main/java/edu/rpi/legup/puzzle/starbattle/elements/BlackTile.java
+++ b/src/main/java/edu/rpi/legup/puzzle/starbattle/elements/BlackTile.java
@@ -4,6 +4,10 @@
public class BlackTile extends NonPlaceableElement {
public BlackTile() {
- super("STBL-PLAC-0002", "Black Tile", "The black tile that shows where you cannot place a star", "edu/rpi/legup/images/lightup/black.gif");
+ super(
+ "STBL-PLAC-0002",
+ "Black Tile",
+ "The black tile that shows where you cannot place a star",
+ "edu/rpi/legup/images/lightup/black.gif");
}
}
diff --git a/src/main/java/edu/rpi/legup/puzzle/starbattle/elements/StarTile.java b/src/main/java/edu/rpi/legup/puzzle/starbattle/elements/StarTile.java
index d42cc0010..13ada3f4d 100644
--- a/src/main/java/edu/rpi/legup/puzzle/starbattle/elements/StarTile.java
+++ b/src/main/java/edu/rpi/legup/puzzle/starbattle/elements/StarTile.java
@@ -4,6 +4,10 @@
public class StarTile extends NonPlaceableElement {
public StarTile() {
- super("STBL-PLAC-0001", "Star Tile", "The star tile, the token of the game.", "edu/rpi/legup/images/starbattle/star.gif");
+ super(
+ "STBL-PLAC-0001",
+ "Star Tile",
+ "The star tile, the token of the game.",
+ "edu/rpi/legup/images/starbattle/star.gif");
}
}
diff --git a/src/main/java/edu/rpi/legup/puzzle/starbattle/elements/UnknownTile.java b/src/main/java/edu/rpi/legup/puzzle/starbattle/elements/UnknownTile.java
index c2459f642..425fb5d5e 100644
--- a/src/main/java/edu/rpi/legup/puzzle/starbattle/elements/UnknownTile.java
+++ b/src/main/java/edu/rpi/legup/puzzle/starbattle/elements/UnknownTile.java
@@ -4,6 +4,10 @@
public class UnknownTile extends NonPlaceableElement {
public UnknownTile() {
- super("STBL-UNPL-0001", "Unknown Tile", "An empty tile", "edu/rpi/legup/images/starbattle/star.gif");
+ super(
+ "STBL-UNPL-0001",
+ "Unknown Tile",
+ "An empty tile",
+ "edu/rpi/legup/images/starbattle/star.gif");
}
}
diff --git a/src/main/java/edu/rpi/legup/puzzle/starbattle/elements/WhiteTile.java b/src/main/java/edu/rpi/legup/puzzle/starbattle/elements/WhiteTile.java
index a064c1fad..2227eb37a 100644
--- a/src/main/java/edu/rpi/legup/puzzle/starbattle/elements/WhiteTile.java
+++ b/src/main/java/edu/rpi/legup/puzzle/starbattle/elements/WhiteTile.java
@@ -4,7 +4,10 @@
public class WhiteTile extends PlaceableElement {
public WhiteTile() {
- super("STBL-PLAC-0001", "White Tile", "The white tile", "edu/rpi/legup/images/starbattle/white.gif");
+ super(
+ "STBL-PLAC-0001",
+ "White Tile",
+ "The white tile",
+ "edu/rpi/legup/images/starbattle/white.gif");
}
}
-
diff --git a/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/BlackoutDirectRule.java b/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/BlackoutDirectRule.java
index 75fbaadb6..2ab66cf93 100644
--- a/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/BlackoutDirectRule.java
+++ b/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/BlackoutDirectRule.java
@@ -13,20 +13,21 @@
public class BlackoutDirectRule extends DirectRule {
public BlackoutDirectRule() {
- super("STBL-BASC-0001",
+ super(
+ "STBL-BASC-0001",
"Blackout",
"If a row, column, or region has enough stars, its unknown spaces are black.",
"edu/rpi/legup/images/starbattle/rules/BlackOutDirectRule.png");
}
/**
- * Checks whether the child node logically follows from the parent node
- * at the specific puzzleElement index using this rule
+ * Checks whether the child node logically follows from the parent node at the specific
+ * puzzleElement index using this rule
*
- * @param transition transition to check
+ * @param transition transition to check
* @param puzzleElement equivalent puzzleElement
- * @return null if the child node logically follow from the parent node at the specified puzzleElement,
- * otherwise error message
+ * @return null if the child node logically follow from the parent node at the specified
+ * puzzleElement, otherwise error message
*/
@Override
public String checkRuleRawAt(TreeTransition transition, PuzzleElement puzzleElement) {
@@ -50,7 +51,8 @@ public String checkRuleRawAt(TreeTransition transition, PuzzleElement puzzleElem
}
/**
- * Creates a transition {@link Board} that has this rule applied to it using the {@link TreeNode}.
+ * Creates a transition {@link Board} that has this rule applied to it using the {@link
+ * TreeNode}.
*
* @param node tree node used to create default transition board
* @return default board or null if this rule cannot be applied to this tree node
@@ -60,5 +62,3 @@ public Board getDefaultBoard(TreeNode node) {
return null;
}
}
-
-
diff --git a/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/ClashingOrbitContradictionRule.java b/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/ClashingOrbitContradictionRule.java
index 0ca27ab4a..88f0072e5 100644
--- a/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/ClashingOrbitContradictionRule.java
+++ b/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/ClashingOrbitContradictionRule.java
@@ -3,30 +3,29 @@
import edu.rpi.legup.model.gameboard.Board;
import edu.rpi.legup.model.gameboard.PuzzleElement;
import edu.rpi.legup.model.rules.ContradictionRule;
-import edu.rpi.legup.model.tree.TreeNode;
-import edu.rpi.legup.model.tree.TreeTransition;
import edu.rpi.legup.puzzle.starbattle.StarBattleBoard;
import edu.rpi.legup.puzzle.starbattle.StarBattleCell;
import edu.rpi.legup.puzzle.starbattle.StarBattleCellType;
-
import java.awt.*;
public class ClashingOrbitContradictionRule extends ContradictionRule {
public ClashingOrbitContradictionRule() {
- super("STBL-CONT-0003",
+ super(
+ "STBL-CONT-0003",
"Clashing Orbit",
"No two stars can be adjacent to each other.",
"edu/rpi/legup/images/starbattle/contradictions/ClashingOrbitContradictionRule.png");
}
/**
- * Checks whether the transition has a contradiction at the specific puzzleElement index using this rule
+ * Checks whether the transition has a contradiction at the specific puzzleElement index using
+ * this rule
*
- * @param board board to check contradiction
+ * @param board board to check contradiction
* @param puzzleElement equivalent puzzleElement
* @return null if the transition contains a contradiction at the specified puzzleElement,
- * otherwise error message
+ * otherwise error message
*/
@Override
public String checkContradictionAt(Board board, PuzzleElement puzzleElement) {
@@ -41,15 +40,15 @@ public String checkContradictionAt(Board board, PuzzleElement puzzleElement) {
// check neighboring cells for a star
Point location = cell.getLocation();
- int rowStart = Math.max( location.x - 1, 0 );
- int rowEnd = Math.min( location.x + 1, starbattleBoard.getSize() - 1 );
- int colStart = Math.max( location.y - 1, 0 );
- int colEnd = Math.min( location.y + 1, starbattleBoard.getSize() - 1 );
+ int rowStart = Math.max(location.x - 1, 0);
+ int rowEnd = Math.min(location.x + 1, starbattleBoard.getSize() - 1);
+ int colStart = Math.max(location.y - 1, 0);
+ int colEnd = Math.min(location.y + 1, starbattleBoard.getSize() - 1);
for (int row = rowStart; row <= rowEnd; row++) {
for (int col = colStart; col <= colEnd; col++) {
if (starbattleBoard.getCell(row, col).getType() == StarBattleCellType.STAR
- && (row != location.x || col != location.y)) {
+ && (row != location.x || col != location.y)) {
return null;
}
}
@@ -57,4 +56,4 @@ public String checkContradictionAt(Board board, PuzzleElement puzzleElement) {
return super.getNoContradictionMessage();
}
-}
\ No newline at end of file
+}
diff --git a/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/ColumnsWithinRegionsDirectRule.java b/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/ColumnsWithinRegionsDirectRule.java
index b42bfd1c0..433567460 100644
--- a/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/ColumnsWithinRegionsDirectRule.java
+++ b/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/ColumnsWithinRegionsDirectRule.java
@@ -1,7 +1,6 @@
package edu.rpi.legup.puzzle.starbattle.rules;
import edu.rpi.legup.model.gameboard.Board;
-import edu.rpi.legup.model.gameboard.GridRegion;
import edu.rpi.legup.model.gameboard.PuzzleElement;
import edu.rpi.legup.model.rules.DirectRule;
import edu.rpi.legup.model.tree.TreeNode;
@@ -9,41 +8,41 @@
import edu.rpi.legup.puzzle.starbattle.StarBattleBoard;
import edu.rpi.legup.puzzle.starbattle.StarBattleCell;
import edu.rpi.legup.puzzle.starbattle.StarBattleCellType;
-
import java.util.HashSet;
import java.util.Set;
public class ColumnsWithinRegionsDirectRule extends DirectRule {
public ColumnsWithinRegionsDirectRule() {
- super("STBL-BASC-0002",
+ super(
+ "STBL-BASC-0002",
"Columns Within Regions",
"If a number of columns is fully contained by a number of regions with an equal number of missing stars, spaces of other columns in those regions must be black.",
"edu/rpi/legup/images/starbattle/rules/ColumnsWithinRegionsDirectRule.png");
}
/**
- * Checks whether the child node logically follows from the parent node
- * at the specific puzzleElement index using this rule
+ * Checks whether the child node logically follows from the parent node at the specific
+ * puzzleElement index using this rule
*
- * @param transition transition to check
+ * @param transition transition to check
* @param puzzleElement equivalent puzzleElement
- * @return null if the child node logically follow from the parent node at the specified puzzleElement,
- * otherwise error message
+ * @return null if the child node logically follow from the parent node at the specified
+ * puzzleElement, otherwise error message
*/
@Override
public String checkRuleRawAt(TreeTransition transition, PuzzleElement puzzleElement) {
- //assumption: the rule has been applied to its fullest extent and the rows and regions
- //are now mutually encompassing
+ // assumption: the rule has been applied to its fullest extent and the rows and regions
+ // are now mutually encompassing
StarBattleBoard board = (StarBattleBoard) transition.getBoard();
StarBattleCell cell = (StarBattleCell) board.getPuzzleElement(puzzleElement);
if (cell.getType() != StarBattleCellType.BLACK) {
return "Only black cells are allowed for this rule!";
}
- //the columns that are contained
+ // the columns that are contained
Set columns = new HashSet();
- //the regions that contain them
+ // the regions that contain them
Set regions = new HashSet();
- //columns and regions to process
+ // columns and regions to process
Set columnsToCheck = new HashSet();
Set regionsToCheck = new HashSet();
int columnStars = 0;
@@ -52,9 +51,9 @@ public String checkRuleRawAt(TreeTransition transition, PuzzleElement puzzleElem
regionsToCheck.add(cell.getGroupIndex());
while (!columnsToCheck.isEmpty() || !regionsToCheck.isEmpty()) {
- for (int r: regionsToCheck) {
+ for (int r : regionsToCheck) {
regionStars += board.getRegion(r).numStars();
- for (PuzzleElement c: board.getRegion(r).getCells()) {
+ for (PuzzleElement c : board.getRegion(r).getCells()) {
int column = ((StarBattleCell) c).getLocation().x;
if (columns.add(column)) {
columnsToCheck.add(column);
@@ -62,10 +61,10 @@ public String checkRuleRawAt(TreeTransition transition, PuzzleElement puzzleElem
}
regionsToCheck.remove(r);
}
- for (int c: columnsToCheck) {
+ for (int c : columnsToCheck) {
columnStars += board.columnStars(c);
for (int i = 0; i < board.getSize(); ++i) {
- int region = board.getCell(c,i).getGroupIndex();
+ int region = board.getCell(c, i).getGroupIndex();
if (regions.add(region)) {
regionsToCheck.add(region);
}
@@ -74,14 +73,16 @@ public String checkRuleRawAt(TreeTransition transition, PuzzleElement puzzleElem
}
}
// are the columns and regions missing an equal amount of stars
- if (board.getPuzzleNumber() * columns.size() - columnStars != board.getPuzzleNumber() * regions.size() - regionStars) {
+ if (board.getPuzzleNumber() * columns.size() - columnStars
+ != board.getPuzzleNumber() * regions.size() - regionStars) {
return "The number of missing stars in the columns and regions must be equal and every extraneous cell must be black!";
}
return null;
}
/**
- * Creates a transition {@link Board} that has this rule applied to it using the {@link TreeNode}.
+ * Creates a transition {@link Board} that has this rule applied to it using the {@link
+ * TreeNode}.
*
* @param node tree node used to create default transition board
* @return default board or null if this rule cannot be applied to this tree node
diff --git a/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/ColumnsWithinRowsDirectRule.java b/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/ColumnsWithinRowsDirectRule.java
index 0a78c8868..5d108a0cd 100644
--- a/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/ColumnsWithinRowsDirectRule.java
+++ b/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/ColumnsWithinRowsDirectRule.java
@@ -8,44 +8,44 @@
import edu.rpi.legup.puzzle.starbattle.StarBattleBoard;
import edu.rpi.legup.puzzle.starbattle.StarBattleCell;
import edu.rpi.legup.puzzle.starbattle.StarBattleCellType;
-
import java.util.HashSet;
import java.util.Set;
public class ColumnsWithinRowsDirectRule extends DirectRule {
public ColumnsWithinRowsDirectRule() {
- super("STBL-BASC-0003",
+ super(
+ "STBL-BASC-0003",
"Columns Within Rows",
"If a number of columns is fully contained by a number of rows with an equal number of missing stars, spaces of other columns in those rows must be black.",
"edu/rpi/legup/images/starbattle/rules/ColumnsWithinRowsDirectRule.png");
}
/**
- * Checks whether the child node logically follows from the parent node
- * at the specific puzzleElement index using this rule
+ * Checks whether the child node logically follows from the parent node at the specific
+ * puzzleElement index using this rule
*
- * @param transition transition to check
+ * @param transition transition to check
* @param puzzleElement equivalent puzzleElement
- * @return null if the child node logically follow from the parent node at the specified puzzleElement,
- * otherwise error message
+ * @return null if the child node logically follow from the parent node at the specified
+ * puzzleElement, otherwise error message
*/
@Override
public String checkRuleRawAt(TreeTransition transition, PuzzleElement puzzleElement) {
- //assumption: the rule has been applied to its fullest extent and the rows and columns
- //are now mutually encompassing
+ // assumption: the rule has been applied to its fullest extent and the rows and columns
+ // are now mutually encompassing
StarBattleBoard board = (StarBattleBoard) transition.getBoard();
StarBattleCell cell = (StarBattleCell) board.getPuzzleElement(puzzleElement);
if (cell.getType() != StarBattleCellType.BLACK) {
return "Only black cells are allowed for this rule!";
}
- //the columns that are contained
+ // the columns that are contained
Set columns = new HashSet();
- //the rows that contain them
+ // the rows that contain them
Set rows = new HashSet();
- //columns and rows to process
+ // columns and rows to process
Set columnsToCheck = new HashSet();
Set rowsToCheck = new HashSet();
int columnStars = 0;
@@ -55,9 +55,9 @@ public String checkRuleRawAt(TreeTransition transition, PuzzleElement puzzleElem
rowsToCheck.add(firstRow);
while (!columnsToCheck.isEmpty() || !rowsToCheck.isEmpty()) {
- for (int r: rowsToCheck) {
+ for (int r : rowsToCheck) {
rowStars += board.rowStars(r);
- for (PuzzleElement c: board.getRow(r)) {
+ for (PuzzleElement c : board.getRow(r)) {
int column = ((StarBattleCell) c).getLocation().x;
if (columns.add(column)) {
columnsToCheck.add(column);
@@ -65,9 +65,9 @@ public String checkRuleRawAt(TreeTransition transition, PuzzleElement puzzleElem
}
rowsToCheck.remove(r);
}
- for (int c: columnsToCheck) {
+ for (int c : columnsToCheck) {
columnStars += board.columnStars(c);
- for (PuzzleElement r: board.getCol(c)) {
+ for (PuzzleElement r : board.getCol(c)) {
int row = ((StarBattleCell) r).getLocation().y;
if (rows.add(row)) {
rowsToCheck.add(row);
@@ -77,14 +77,16 @@ public String checkRuleRawAt(TreeTransition transition, PuzzleElement puzzleElem
}
}
// are the columns and regions missing an equal amount of stars
- if (board.getPuzzleNumber() * columns.size() - columnStars != board.getPuzzleNumber() * rows.size() - rowStars) {
+ if (board.getPuzzleNumber() * columns.size() - columnStars
+ != board.getPuzzleNumber() * rows.size() - rowStars) {
return "The number of missing stars in the columns and rows must be equal and every extraneous cell must be black!";
}
return null;
}
/**
- * Creates a transition {@link Board} that has this rule applied to it using the {@link TreeNode}.
+ * Creates a transition {@link Board} that has this rule applied to it using the {@link
+ * TreeNode}.
*
* @param node tree node used to create default transition board
* @return default board or null if this rule cannot be applied to this tree node
diff --git a/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/FinishWithStarsDirectRule.java b/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/FinishWithStarsDirectRule.java
index 36e691e74..80ae9a4c8 100644
--- a/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/FinishWithStarsDirectRule.java
+++ b/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/FinishWithStarsDirectRule.java
@@ -13,20 +13,21 @@
public class FinishWithStarsDirectRule extends DirectRule {
public FinishWithStarsDirectRule() {
- super("STBL-BASC-0004",
+ super(
+ "STBL-BASC-0004",
"Finish With Stars",
"Unknown spaces must be stars if there are just enough in a row, column, or region to satisfy the puzzle number.",
"edu/rpi/legup/images/starbattle/rules/FinishWithStarDirectRule.png");
}
/**
- * Checks whether the child node logically follows from the parent node
- * at the specific puzzleElement index using this rule
+ * Checks whether the child node logically follows from the parent node at the specific
+ * puzzleElement index using this rule
*
- * @param transition transition to check
+ * @param transition transition to check
* @param puzzleElement equivalent puzzleElement
- * @return null if the child node logically follow from the parent node at the specified puzzleElement,
- * otherwise error message
+ * @return null if the child node logically follow from the parent node at the specified
+ * puzzleElement, otherwise error message
*/
@Override
public String checkRuleRawAt(TreeTransition transition, PuzzleElement puzzleElement) {
@@ -50,7 +51,8 @@ public String checkRuleRawAt(TreeTransition transition, PuzzleElement puzzleElem
}
/**
- * Creates a transition {@link Board} that has this rule applied to it using the {@link TreeNode}.
+ * Creates a transition {@link Board} that has this rule applied to it using the {@link
+ * TreeNode}.
*
* @param node tree node used to create default transition board
* @return default board or null if this rule cannot be applied to this tree node
diff --git a/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/RegionsWithinColumnsDirectRule.java b/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/RegionsWithinColumnsDirectRule.java
index 16951fb2a..7022a06ac 100644
--- a/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/RegionsWithinColumnsDirectRule.java
+++ b/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/RegionsWithinColumnsDirectRule.java
@@ -8,20 +8,21 @@
public class RegionsWithinColumnsDirectRule extends DirectRule {
public RegionsWithinColumnsDirectRule() {
- super("STBL-BASC-0005",
+ super(
+ "STBL-BASC-0005",
"Regions Within Columns",
"If a number of regions is fully contained by a number of columns with an equal number of missing stars, spaces of other regions in those columns must be black.",
"edu/rpi/legup/images/starbattle/rules/RegionsWithinColumnsDirectRule.png");
}
/**
- * Checks whether the child node logically follows from the parent node
- * at the specific puzzleElement index using this rule
+ * Checks whether the child node logically follows from the parent node at the specific
+ * puzzleElement index using this rule
*
- * @param transition transition to check
+ * @param transition transition to check
* @param puzzleElement equivalent puzzleElement
- * @return null if the child node logically follow from the parent node at the specified puzzleElement,
- * otherwise error message
+ * @return null if the child node logically follow from the parent node at the specified
+ * puzzleElement, otherwise error message
*/
@Override
public String checkRuleRawAt(TreeTransition transition, PuzzleElement puzzleElement) {
@@ -30,7 +31,8 @@ public String checkRuleRawAt(TreeTransition transition, PuzzleElement puzzleElem
}
/**
- * Creates a transition {@link Board} that has this rule applied to it using the {@link TreeNode}.
+ * Creates a transition {@link Board} that has this rule applied to it using the {@link
+ * TreeNode}.
*
* @param node tree node used to create default transition board
* @return default board or null if this rule cannot be applied to this tree node
diff --git a/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/RegionsWithinRowsDirectRule.java b/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/RegionsWithinRowsDirectRule.java
index 27dc001a0..7ab50d42b 100644
--- a/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/RegionsWithinRowsDirectRule.java
+++ b/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/RegionsWithinRowsDirectRule.java
@@ -8,20 +8,21 @@
public class RegionsWithinRowsDirectRule extends DirectRule {
public RegionsWithinRowsDirectRule() {
- super("STBL-BASC-0006",
+ super(
+ "STBL-BASC-0006",
"Regions Within Rows",
"If a number of regions is fully contained by a number of rows with an equal number of missing stars, spaces of other regions in those rows must be black.",
"edu/rpi/legup/images/starbattle/rules/RegionsWithinRowsDirectRule.png");
}
/**
- * Checks whether the child node logically follows from the parent node
- * at the specific puzzleElement index using this rule
+ * Checks whether the child node logically follows from the parent node at the specific
+ * puzzleElement index using this rule
*
- * @param transition transition to check
+ * @param transition transition to check
* @param puzzleElement equivalent puzzleElement
- * @return null if the child node logically follow from the parent node at the specified puzzleElement,
- * otherwise error message
+ * @return null if the child node logically follow from the parent node at the specified
+ * puzzleElement, otherwise error message
*/
@Override
public String checkRuleRawAt(TreeTransition transition, PuzzleElement puzzleElement) {
@@ -31,7 +32,8 @@ public String checkRuleRawAt(TreeTransition transition, PuzzleElement puzzleElem
}
/**
- * Creates a transition {@link Board} that has this rule applied to it using the {@link TreeNode}.
+ * Creates a transition {@link Board} that has this rule applied to it using the {@link
+ * TreeNode}.
*
* @param node tree node used to create default transition board
* @return default board or null if this rule cannot be applied to this tree node
diff --git a/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/RowsWithinColumnsDirectRule.java b/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/RowsWithinColumnsDirectRule.java
index 4054ec017..2df20e464 100644
--- a/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/RowsWithinColumnsDirectRule.java
+++ b/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/RowsWithinColumnsDirectRule.java
@@ -5,30 +5,25 @@
import edu.rpi.legup.model.rules.DirectRule;
import edu.rpi.legup.model.tree.TreeNode;
import edu.rpi.legup.model.tree.TreeTransition;
-import edu.rpi.legup.puzzle.starbattle.StarBattleBoard;
-import edu.rpi.legup.puzzle.starbattle.StarBattleCell;
-import edu.rpi.legup.puzzle.starbattle.StarBattleCellType;
-
-import java.util.HashSet;
-import java.util.Set;
public class RowsWithinColumnsDirectRule extends DirectRule {
public RowsWithinColumnsDirectRule() {
- super("STBL-BASC-0007",
+ super(
+ "STBL-BASC-0007",
"Rows Withing Columns",
"If a number of rows is fully contained by a number of columns with an equal number of missing stars, spaces of other rows in those columns must be black.",
"edu/rpi/legup/images/starbattle/rules/RowsWithinColumnsDirectRule.png");
}
/**
- * Checks whether the child node logically follows from the parent node
- * at the specific puzzleElement index using this rule
+ * Checks whether the child node logically follows from the parent node at the specific
+ * puzzleElement index using this rule
*
- * @param transition transition to check
+ * @param transition transition to check
* @param puzzleElement equivalent puzzleElement
- * @return null if the child node logically follow from the parent node at the specified puzzleElement,
- * otherwise error message
+ * @return null if the child node logically follow from the parent node at the specified
+ * puzzleElement, otherwise error message
*/
@Override
public String checkRuleRawAt(TreeTransition transition, PuzzleElement puzzleElement) {
@@ -38,7 +33,8 @@ public String checkRuleRawAt(TreeTransition transition, PuzzleElement puzzleElem
}
/**
- * Creates a transition {@link Board} that has this rule applied to it using the {@link TreeNode}.
+ * Creates a transition {@link Board} that has this rule applied to it using the {@link
+ * TreeNode}.
*
* @param node tree node used to create default transition board
* @return default board or null if this rule cannot be applied to this tree node
diff --git a/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/RowsWithinRegionsDirectRule.java b/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/RowsWithinRegionsDirectRule.java
index 7af2c79ed..78f8f00e7 100644
--- a/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/RowsWithinRegionsDirectRule.java
+++ b/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/RowsWithinRegionsDirectRule.java
@@ -8,42 +8,42 @@
import edu.rpi.legup.puzzle.starbattle.StarBattleBoard;
import edu.rpi.legup.puzzle.starbattle.StarBattleCell;
import edu.rpi.legup.puzzle.starbattle.StarBattleCellType;
-
import java.util.HashSet;
import java.util.Set;
public class RowsWithinRegionsDirectRule extends DirectRule {
public RowsWithinRegionsDirectRule() {
- super("STBL-BASC-0008",
+ super(
+ "STBL-BASC-0008",
"Rows Within Regions",
"If a number of rows is fully contained by a number of regions with an equal number of missing stars, spaces of other rows in those regions must be black.",
"edu/rpi/legup/images/starbattle/rules/RowsWithinRegionsDirectRule.png");
}
/**
- * Checks whether the child node logically follows from the parent node
- * at the specific puzzleElement index using this rule
+ * Checks whether the child node logically follows from the parent node at the specific
+ * puzzleElement index using this rule
*
- * @param transition transition to check
+ * @param transition transition to check
* @param puzzleElement equivalent puzzleElement
- * @return null if the child node logically follow from the parent node at the specified puzzleElement,
- * otherwise error message
+ * @return null if the child node logically follow from the parent node at the specified
+ * puzzleElement, otherwise error message
*/
@Override
public String checkRuleRawAt(TreeTransition transition, PuzzleElement puzzleElement) {
- //assumption: the rule has been applied to its fullest extent and the rows and regions
- //are now mutually encompassing
+ // assumption: the rule has been applied to its fullest extent and the rows and regions
+ // are now mutually encompassing
StarBattleBoard board = (StarBattleBoard) transition.getBoard();
StarBattleCell cell = (StarBattleCell) board.getPuzzleElement(puzzleElement);
if (cell.getType() != StarBattleCellType.BLACK) {
return "Only black cells are allowed for this rule!";
}
- //the rows that are contained
+ // the rows that are contained
Set rows = new HashSet();
- //the regions that contain them
+ // the regions that contain them
Set regions = new HashSet();
- //rows and regions to process
+ // rows and regions to process
Set rowsToCheck = new HashSet();
Set regionsToCheck = new HashSet();
int rowStars = 0;
@@ -52,9 +52,9 @@ public String checkRuleRawAt(TreeTransition transition, PuzzleElement puzzleElem
regionsToCheck.add(cell.getGroupIndex());
while (!rowsToCheck.isEmpty() || !regionsToCheck.isEmpty()) {
- for (int r: regionsToCheck) {
+ for (int r : regionsToCheck) {
regionStars += board.getRegion(r).numStars();
- for (PuzzleElement ro: board.getRegion(r).getCells()) {
+ for (PuzzleElement ro : board.getRegion(r).getCells()) {
int row = ((StarBattleCell) ro).getLocation().y;
if (rows.add(row)) {
rowsToCheck.add(row);
@@ -62,10 +62,10 @@ public String checkRuleRawAt(TreeTransition transition, PuzzleElement puzzleElem
}
regionsToCheck.remove(r);
}
- for (int r: rowsToCheck) {
+ for (int r : rowsToCheck) {
rowStars += board.rowStars(r);
for (int i = 0; i < board.getSize(); ++i) {
- int region = board.getCell(i,r).getGroupIndex();
+ int region = board.getCell(i, r).getGroupIndex();
if (regions.add(region)) {
regionsToCheck.add(region);
}
@@ -74,14 +74,16 @@ public String checkRuleRawAt(TreeTransition transition, PuzzleElement puzzleElem
}
}
// are the columns and regions missing an equal amount of stars
- if (board.getPuzzleNumber() * rows.size() - rowStars != board.getPuzzleNumber() * regions.size() - regionStars) {
+ if (board.getPuzzleNumber() * rows.size() - rowStars
+ != board.getPuzzleNumber() * regions.size() - regionStars) {
return "The number of missing stars in the rows and regions must be equal and every extraneous cell must be black!";
}
return null;
}
/**
- * Creates a transition {@link Board} that has this rule applied to it using the {@link TreeNode}.
+ * Creates a transition {@link Board} that has this rule applied to it using the {@link
+ * TreeNode}.
*
* @param node tree node used to create default transition board
* @return default board or null if this rule cannot be applied to this tree node
diff --git a/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/StarOrEmptyCaseRule.java b/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/StarOrEmptyCaseRule.java
index 0aa147c6f..df900dcd5 100644
--- a/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/StarOrEmptyCaseRule.java
+++ b/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/StarOrEmptyCaseRule.java
@@ -1,31 +1,29 @@
package edu.rpi.legup.puzzle.starbattle.rules;
-import edu.rpi.legup.model.rules.CaseRule;
import edu.rpi.legup.model.gameboard.Board;
import edu.rpi.legup.model.gameboard.CaseBoard;
import edu.rpi.legup.model.gameboard.PuzzleElement;
+import edu.rpi.legup.model.rules.CaseRule;
import edu.rpi.legup.model.tree.TreeTransition;
-import edu.rpi.legup.puzzle.nurikabe.NurikabeCell;
-import edu.rpi.legup.puzzle.nurikabe.NurikabeType;
import edu.rpi.legup.puzzle.starbattle.StarBattleBoard;
import edu.rpi.legup.puzzle.starbattle.StarBattleCell;
import edu.rpi.legup.puzzle.starbattle.StarBattleCellType;
-
import java.util.ArrayList;
import java.util.List;
public class StarOrEmptyCaseRule extends CaseRule {
public StarOrEmptyCaseRule() {
- super("STBL-CASE-0002",
+ super(
+ "STBL-CASE-0002",
"Star or Empty",
"Each unknown space is either a star or empty.",
"edu/rpi/legup/images/starbattle/cases/StarOrEmptyCaseRule.png");
}
/**
- * Checks whether the {@link TreeTransition} logically follows from the parent node using this rule. This method is
- * the one that should overridden in child classes.
+ * Checks whether the {@link TreeTransition} logically follows from the parent node using this
+ * rule. This method is the one that should overridden in child classes.
*
* @param transition transition to check
* @return null if the child node logically follow from the parent node, otherwise error message
@@ -39,20 +37,25 @@ public String checkRuleRaw(TreeTransition transition) {
TreeTransition case1 = childTransitions.get(0);
TreeTransition case2 = childTransitions.get(1);
- if (case1.getBoard().getModifiedData().size() != 1 ||
- case2.getBoard().getModifiedData().size() != 1) {
- return super.getInvalidUseOfRuleMessage() + ": This case rule must have 1 modified cell for each case.";
+ if (case1.getBoard().getModifiedData().size() != 1
+ || case2.getBoard().getModifiedData().size() != 1) {
+ return super.getInvalidUseOfRuleMessage()
+ + ": This case rule must have 1 modified cell for each case.";
}
StarBattleCell mod1 = (StarBattleCell) case1.getBoard().getModifiedData().iterator().next();
StarBattleCell mod2 = (StarBattleCell) case2.getBoard().getModifiedData().iterator().next();
if (!mod1.getLocation().equals(mod2.getLocation())) {
- return super.getInvalidUseOfRuleMessage() + ": This case rule must modify the same cell for each case.";
+ return super.getInvalidUseOfRuleMessage()
+ + ": This case rule must modify the same cell for each case.";
}
- if (!((mod1.getType() == StarBattleCellType.STAR && mod2.getType() == StarBattleCellType.BLACK) ||
- (mod2.getType() == StarBattleCellType.STAR && mod1.getType() == StarBattleCellType.BLACK))) {
- return super.getInvalidUseOfRuleMessage() + ": This case rule must create a star cell and a black cell.";
+ if (!((mod1.getType() == StarBattleCellType.STAR
+ && mod2.getType() == StarBattleCellType.BLACK)
+ || (mod2.getType() == StarBattleCellType.STAR
+ && mod1.getType() == StarBattleCellType.BLACK))) {
+ return super.getInvalidUseOfRuleMessage()
+ + ": This case rule must create a star cell and a black cell.";
}
return null;
@@ -74,7 +77,7 @@ public CaseBoard getCaseBoard(Board board) {
/**
* Gets the possible cases at a specific location based on this case rule
*
- * @param board the current board state
+ * @param board the current board state
* @param puzzleElement equivalent puzzleElement
* @return a list of elements the specified could be
*/
diff --git a/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/SurroundStarDirectRule.java b/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/SurroundStarDirectRule.java
index e1c6f3084..89857875d 100644
--- a/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/SurroundStarDirectRule.java
+++ b/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/SurroundStarDirectRule.java
@@ -13,20 +13,21 @@
public class SurroundStarDirectRule extends DirectRule {
public SurroundStarDirectRule() {
- super("STBL-BASC-0009",
+ super(
+ "STBL-BASC-0009",
"Surround Star",
"Any space adjacent to a star must be black.",
"edu/rpi/legup/images/starbattle/rules/SurroundStar.png");
}
/**
- * Checks whether the child node logically follows from the parent node
- * at the specific puzzleElement index using this rule
+ * Checks whether the child node logically follows from the parent node at the specific
+ * puzzleElement index using this rule
*
- * @param transition transition to check
+ * @param transition transition to check
* @param puzzleElement equivalent puzzleElement
- * @return null if the child node logically follow from the parent node at the specified puzzleElement,
- * otherwise error message
+ * @return null if the child node logically follow from the parent node at the specified
+ * puzzleElement, otherwise error message
*/
@Override
public String checkRuleRawAt(TreeTransition transition, PuzzleElement puzzleElement) {
@@ -49,7 +50,8 @@ public String checkRuleRawAt(TreeTransition transition, PuzzleElement puzzleElem
}
/**
- * Creates a transition {@link Board} that has this rule applied to it using the {@link TreeNode}.
+ * Creates a transition {@link Board} that has this rule applied to it using the {@link
+ * TreeNode}.
*
* @param node tree node used to create default transition board
* @return default board or null if this rule cannot be applied to this tree node
@@ -60,4 +62,3 @@ public Board getDefaultBoard(TreeNode node) {
return null;
}
}
-
diff --git a/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/TooFewStarsContradictionRule.java b/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/TooFewStarsContradictionRule.java
index d1ed62107..e88b7c6b9 100644
--- a/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/TooFewStarsContradictionRule.java
+++ b/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/TooFewStarsContradictionRule.java
@@ -3,31 +3,30 @@
import edu.rpi.legup.model.gameboard.Board;
import edu.rpi.legup.model.gameboard.PuzzleElement;
import edu.rpi.legup.model.rules.ContradictionRule;
-import edu.rpi.legup.model.tree.TreeNode;
-import edu.rpi.legup.model.tree.TreeTransition;
import edu.rpi.legup.puzzle.starbattle.StarBattleBoard;
import edu.rpi.legup.puzzle.starbattle.StarBattleCell;
import edu.rpi.legup.puzzle.starbattle.StarBattleCellType;
import edu.rpi.legup.puzzle.starbattle.StarBattleRegion;
-
import java.awt.*;
public class TooFewStarsContradictionRule extends ContradictionRule {
public TooFewStarsContradictionRule() {
- super("STBL-CONT-0002",
+ super(
+ "STBL-CONT-0002",
"Too Few Stars",
"There are too few stars in this region/row/column and there are not enough places to put the remaining stars.",
"edu/rpi/legup/images/starbattle/contradictions/TooFewStarsContradictionRule.png");
}
/**
- * Checks whether the transition has a contradiction at the specific puzzleElement index using this rule
+ * Checks whether the transition has a contradiction at the specific puzzleElement index using
+ * this rule
*
- * @param board board to check contradiction
+ * @param board board to check contradiction
* @param puzzleElement equivalent puzzleElement
* @return null if the transition contains a contradiction at the specified puzzleElement,
- * otherwise error message
+ * otherwise error message
*/
@Override
public String checkContradictionAt(Board board, PuzzleElement puzzleElement) {
@@ -51,7 +50,7 @@ public String checkContradictionAt(Board board, PuzzleElement puzzleElement) {
}
StarBattleRegion region = sbBoard.getRegion(cell);
int regionCount = 0;
- for (StarBattleCell c: region.getCells()) {
+ for (StarBattleCell c : region.getCells()) {
if (c.getType() != StarBattleCellType.BLACK) {
++regionCount;
}
@@ -61,4 +60,4 @@ public String checkContradictionAt(Board board, PuzzleElement puzzleElement) {
}
return super.getNoContradictionMessage();
}
-}
\ No newline at end of file
+}
diff --git a/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/TooManyStarsContradictionRule.java b/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/TooManyStarsContradictionRule.java
index 2ae424d45..12603a6ba 100644
--- a/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/TooManyStarsContradictionRule.java
+++ b/src/main/java/edu/rpi/legup/puzzle/starbattle/rules/TooManyStarsContradictionRule.java
@@ -3,34 +3,33 @@
import edu.rpi.legup.model.gameboard.Board;
import edu.rpi.legup.model.gameboard.PuzzleElement;
import edu.rpi.legup.model.rules.ContradictionRule;
-import edu.rpi.legup.model.tree.TreeNode;
-import edu.rpi.legup.model.tree.TreeTransition;
-import edu.rpi.legup.puzzle.lightup.LightUpCell;
import edu.rpi.legup.puzzle.starbattle.StarBattleBoard;
import edu.rpi.legup.puzzle.starbattle.StarBattleCell;
import edu.rpi.legup.puzzle.starbattle.StarBattleCellType;
import edu.rpi.legup.puzzle.starbattle.StarBattleRegion;
-
import java.awt.*;
import java.util.List;
public class TooManyStarsContradictionRule extends ContradictionRule {
- private final String INVALID_USE_MESSAGE = "Contradiction must be applied to a cell containing a star.";
+ private final String INVALID_USE_MESSAGE =
+ "Contradiction must be applied to a cell containing a star.";
public TooManyStarsContradictionRule() {
- super("STBL-CONT-0001",
+ super(
+ "STBL-CONT-0001",
"Too Many Stars",
"There are too many stars in this region/row/column.",
"edu/rpi/legup/images/starbattle/contradictions/TooManyStarsContradictionRule.png");
}
/**
- * Checks whether the transition has a contradiction at the specific puzzleElement index using this rule
+ * Checks whether the transition has a contradiction at the specific puzzleElement index using
+ * this rule
*
- * @param board board to check contradiction
+ * @param board board to check contradiction
* @param puzzleElement equivalent puzzleElement
* @return null if the transition contains a contradiction at the specified puzzleElement,
- * otherwise error message
+ * otherwise error message
*/
@Override
public String checkContradictionAt(Board board, PuzzleElement puzzleElement) {
@@ -111,4 +110,4 @@ public String checkContradictionAt(Board board, PuzzleElement puzzleElement) {
}
return null;
}
-}
\ No newline at end of file
+}
diff --git a/src/main/java/edu/rpi/legup/utility/LegupUtils.java b/src/main/java/edu/rpi/legup/utility/LegupUtils.java
index 770ccc6a2..ce21a8d9a 100644
--- a/src/main/java/edu/rpi/legup/utility/LegupUtils.java
+++ b/src/main/java/edu/rpi/legup/utility/LegupUtils.java
@@ -98,8 +98,7 @@ private static List findClassesZip(String path, String packageName)
try {
Class> c = Class.forName(substr);
classes.add(c);
- }
- catch (LinkageError | ClassNotFoundException e) {
+ } catch (LinkageError | ClassNotFoundException e) {
System.out.println("Failed on " + substr);
}
}
diff --git a/src/main/resources/edu/rpi/legup/images/binary/rules/CompleteRowColumnDirectRule.png b/src/main/resources/edu/rpi/legup/images/binary/rules/CompleteRowColumnDirectRule.png
new file mode 100644
index 000000000..a74654d43
Binary files /dev/null and b/src/main/resources/edu/rpi/legup/images/binary/rules/CompleteRowColumnDirectRule.png differ
diff --git a/src/main/resources/edu/rpi/legup/images/binary/rules/DuplicateRowOrColumnContradictionRule.png b/src/main/resources/edu/rpi/legup/images/binary/rules/DuplicateRowOrColumnContradictionRule.png
new file mode 100644
index 000000000..214aa5348
Binary files /dev/null and b/src/main/resources/edu/rpi/legup/images/binary/rules/DuplicateRowOrColumnContradictionRule.png differ
diff --git a/src/main/resources/edu/rpi/legup/images/binary/rules/OneOrZeroCaseRule.png b/src/main/resources/edu/rpi/legup/images/binary/rules/OneOrZeroCaseRule.png
new file mode 100644
index 000000000..73072f2ce
Binary files /dev/null and b/src/main/resources/edu/rpi/legup/images/binary/rules/OneOrZeroCaseRule.png differ
diff --git a/src/main/resources/edu/rpi/legup/images/binary/rules/OneTileGapDirectRule.png b/src/main/resources/edu/rpi/legup/images/binary/rules/OneTileGapDirectRule.png
new file mode 100644
index 000000000..b68f67e44
Binary files /dev/null and b/src/main/resources/edu/rpi/legup/images/binary/rules/OneTileGapDirectRule.png differ
diff --git a/src/main/resources/edu/rpi/legup/images/binary/rules/SurroundPairDirectRule.png b/src/main/resources/edu/rpi/legup/images/binary/rules/SurroundPairDirectRule.png
new file mode 100644
index 000000000..67a4e47f3
Binary files /dev/null and b/src/main/resources/edu/rpi/legup/images/binary/rules/SurroundPairDirectRule.png differ
diff --git a/src/main/resources/edu/rpi/legup/images/binary/rules/ThreeAdjacentContradictionRule.png b/src/main/resources/edu/rpi/legup/images/binary/rules/ThreeAdjacentContradictionRule.png
new file mode 100644
index 000000000..862408b63
Binary files /dev/null and b/src/main/resources/edu/rpi/legup/images/binary/rules/ThreeAdjacentContradictionRule.png differ
diff --git a/src/main/resources/edu/rpi/legup/images/binary/rules/UnbalancedRowColumnContradictionRule.png b/src/main/resources/edu/rpi/legup/images/binary/rules/UnbalancedRowColumnContradictionRule.png
new file mode 100644
index 000000000..029bd12ac
Binary files /dev/null and b/src/main/resources/edu/rpi/legup/images/binary/rules/UnbalancedRowColumnContradictionRule.png differ
diff --git a/src/main/resources/edu/rpi/legup/legup/config b/src/main/resources/edu/rpi/legup/legup/config
index 4aef6de60..07b0b0586 100644
--- a/src/main/resources/edu/rpi/legup/legup/config
+++ b/src/main/resources/edu/rpi/legup/legup/config
@@ -4,6 +4,10 @@
qualifiedClassName="edu.rpi.legup.puzzle.battleship.Battleship"
fileType=".xml"
fileCreationDisabled="true"/>
+