Caseboard functionality merged into Board class.

src/main/java/edu/rpi/legup/controller/ElementController.java

@@ -13,7 +13,6 @@
 import edu.rpi.legup.model.elements.Element;
 import edu.rpi.legup.model.elements.PlaceableElement;
 import edu.rpi.legup.model.gameboard.Board;
-import edu.rpi.legup.model.gameboard.CaseBoard;
 import edu.rpi.legup.model.gameboard.GridBoard;
 import edu.rpi.legup.model.gameboard.GridCell;
 import edu.rpi.legup.model.gameboard.PuzzleElement;
@@ -163,11 +162,10 @@ public void mouseReleased(MouseEvent e) {
         }
         // funny
         if (elementView != null) {
-            if (board instanceof CaseBoard) {
-                CaseBoard caseBoard = (CaseBoard) board;
+            if (board.getCaseRule() != null) {
                 AutoCaseRuleCommand autoCaseRuleCommand =
                         new AutoCaseRuleCommand(
-                                elementView, selection, caseBoard.getCaseRule(), caseBoard, e);
+                                elementView, selection, board.getCaseRule(), board, e);
                 if (autoCaseRuleCommand.canExecute()) {
                     autoCaseRuleCommand.execute();
                     getInstance().getHistory().pushChange(autoCaseRuleCommand);
@@ -498,10 +496,9 @@ public void keyReleased(KeyEvent e) {
             boardView = getInstance().getLegupUI().getEditorBoardView();
         }
         Board board = boardView.getBoard();
-        if (board instanceof CaseBoard) {
-            CaseBoard caseBoard = (CaseBoard) board;
+        if (board.getCaseRule() != null) {
             if (e.getKeyCode() == KeyEvent.VK_ESCAPE) {
-                puzzle.notifyBoardListeners(listener -> listener.onCaseBoardAdded(caseBoard));
+                puzzle.notifyBoardListeners(listener -> listener.onCaseBoardAdded(board));
             }
         }
     }

src/main/java/edu/rpi/legup/controller/RuleController.java

@@ -6,7 +6,7 @@
 import edu.rpi.legup.app.LegupPreferences;
 import edu.rpi.legup.history.*;
 import edu.rpi.legup.model.Puzzle;
-import edu.rpi.legup.model.gameboard.CaseBoard;
+import edu.rpi.legup.model.gameboard.Board;
 import edu.rpi.legup.model.rules.*;
 import edu.rpi.legup.model.tree.TreeElement;
 import edu.rpi.legup.model.tree.TreeElementType;
@@ -70,19 +70,19 @@ public void buttonPressed(Rule rule) {
                             updateErrorString =
                                     "Cases cannot be generated from a node with children.";
                         } else {
-                            try { // added try catch for scenarios where rules are cancelled by user
-                                // ie.
+                            try { // added try catch for scenarios where rules are canceled by user
+                                // i.e.
                                 // Skyscraper cellForNumber
-                                CaseBoard caseBoard =
+                                Board caseBoard =
                                         caseRule.getApplicableLocationsBoard(element.getBoard());
-                                if (caseBoard != null && caseBoard.getCount() > 0) {
+                                if (caseBoard != null && caseBoard.getCasePickableCount() > 0) {
                                     puzzle.notifyBoardListeners(
                                             listener -> listener.onCaseBoardAdded(caseBoard));
                                 } else {
                                     updateErrorString =
                                             "This board cannot be applied with this case rule.";
                                 }
-                            } // catch rule was cancelled exception
+                            } // catch rule was canceled exception
                             catch (Exception e) {
                                 updateErrorString = e.getMessage();
                             }

src/main/java/edu/rpi/legup/history/AutoCaseRuleCommand.java

@@ -5,7 +5,6 @@
 import edu.rpi.legup.app.GameBoardFacade;
 import edu.rpi.legup.model.Puzzle;
 import edu.rpi.legup.model.gameboard.Board;
-import edu.rpi.legup.model.gameboard.CaseBoard;
 import edu.rpi.legup.model.rules.CaseRule;
 import edu.rpi.legup.model.tree.*;
 import edu.rpi.legup.ui.boardview.ElementView;
@@ -23,7 +22,7 @@ public class AutoCaseRuleCommand extends PuzzleCommand {
     private ElementView elementView;
     private TreeViewSelection selection;
     private CaseRule caseRule;
-    private CaseBoard caseBoard;
+    private Board board;
     private MouseEvent mouseEvent;
 
     private List<TreeTransition> caseTrans;
@@ -37,23 +36,23 @@ public class AutoCaseRuleCommand extends PuzzleCommand {
      * @param elementView currently selected puzzle puzzleElement view that is being edited
      * @param selection currently selected tree puzzleElement views that is being edited
      * @param caseRule currently selected caseRule puzzleElement view that is being edited
-     * @param caseBoard currently selected caseBoard puzzleElement view that is being edited
+     * @param board currently selected board puzzleElement view that is being edited
      * @param mouseEvent currently selected mouseEvent puzzleElement view that is being edited
      */
     public AutoCaseRuleCommand(
             ElementView elementView,
             TreeViewSelection selection,
             CaseRule caseRule,
-            CaseBoard caseBoard,
+            Board board,
             MouseEvent mouseEvent) {
         this.elementView = elementView;
         this.selection = selection.copy();
         this.caseRule = caseRule;
-        this.caseBoard = caseBoard;
+        this.board = board;
         this.mouseEvent = mouseEvent;
         this.caseTrans = new ArrayList<>();
         this.cases =
-                caseRule.getCasesFrom(caseBoard.getBaseBoard(), elementView.getPuzzleElement());
+                caseRule.getCasesFrom(board, elementView.getPuzzleElement());
         this.numberOfCaseRules = cases.size();
     }
 
@@ -72,7 +71,7 @@ public void executeCommand() {
 
         if (caseTrans.isEmpty()) {
             List<Board> cases =
-                    caseRule.getCasesFrom(caseBoard.getBaseBoard(), elementView.getPuzzleElement());
+                    caseRule.getCasesFrom(board, elementView.getPuzzleElement());
             for (Board board : cases) {
                 final TreeTransition transition = (TreeTransition) tree.addTreeElement(node);
                 // board.setModifiable(false);
@@ -122,17 +121,17 @@ public String getErrorString() {
             return CommandError.NO_CHILDREN.toString();
         }
 
-        if (!caseBoard.isPickable(elementView.getPuzzleElement(), mouseEvent)) {
+        if (!board.isPickable(elementView.getPuzzleElement(), mouseEvent)) {
             return "The selected data element is not pickable with this case rule.";
         }
 
-        if (caseRule.getCasesFrom(caseBoard.getBaseBoard(), elementView.getPuzzleElement()).size()
+        if (caseRule.getCasesFrom(board, elementView.getPuzzleElement()).size()
                 == 0) {
             return "The selection must produce at least one case";
         }
 
         int numberOfCaseRules =
-                caseRule.getCasesFrom(caseBoard.getBaseBoard(), elementView.getPuzzleElement())
+                caseRule.getCasesFrom(board, elementView.getPuzzleElement())
                         .size();
         System.out.println("Number of cases:" + numberOfCaseRules);
         if (numberOfCaseRules > caseRule.MAX_CASES) {

src/main/java/edu/rpi/legup/model/gameboard/Board.java

@@ -1,6 +1,9 @@
 package edu.rpi.legup.model.gameboard;
 
 import edu.rpi.legup.model.Goal;
+import edu.rpi.legup.model.rules.CaseRule;
+
+import java.awt.event.MouseEvent;
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.List;
@@ -17,12 +20,18 @@ public abstract class Board {
     protected Goal goal;
     protected boolean isModifiable;
 
+    protected CaseRule caseRule;
+    protected Set<PuzzleElement> casePickableElements;
+
     /** Board Constructor creates an empty board. */
     public Board() {
         this.puzzleElements = new ArrayList<>();
         this.modifiedData = new HashSet<>();
         this.isModifiable = true;
         this.goal = null;
+
+        this.caseRule = null;
+        this.casePickableElements = new HashSet<>();
     }
 
     /**
@@ -90,6 +99,76 @@ public void setPuzzleElements(List<PuzzleElement> puzzleElements) {
         this.puzzleElements = puzzleElements;
     }
 
+    /**
+     * Retrieves the case rule for this board.
+     *
+     * @return the case rule
+     */
+    public CaseRule getCaseRule() {
+        return caseRule;
+    }
+
+    /**
+     * Sets the case rule for this board.
+     *
+     * @param caseRule the new case rule
+     */
+    public void setCaseRule(CaseRule caseRule) {
+        this.caseRule = caseRule;
+    }
+
+    /**
+     * Retrieves the pickable puzzle elements for this board
+     *
+     * @return the pickable puzzle elements
+     */
+    public Set<PuzzleElement> getCasePickableElements() { return casePickableElements; }
+
+    /**
+     * Sets the pickable puzzle elements for this board.
+     *
+     * @param casePickableElements the new pickable puzzle elements
+     */
+    public void setCasePickableElements(Set<PuzzleElement> casePickableElements) { this.casePickableElements = casePickableElements; }
+
+    /**
+     * Adds a puzzle element to the set of pickable elements.
+     *
+     * @param puzzleElement the puzzle element to add
+     */
+    public void addCasePickableElement(PuzzleElement puzzleElement) {
+        casePickableElements.add(puzzleElement);
+    }
+
+    /**
+     * Removes a puzzle element from the set of pickable elements.
+     *
+     * @param puzzleElement the puzzle element to remove
+     */
+    public void removeCasePickableElement(PuzzleElement puzzleElement) {
+        casePickableElements.remove(puzzleElement);
+    }
+
+    /**
+     * Gets the count of pickable puzzle elements.
+     *
+     * @return the number of pickable elements
+     */
+    public int getCasePickableCount() {
+        return casePickableElements.size();
+    }
+
+    /**
+     * Checks if a puzzle element is pickable based on the mouse event.
+     *
+     * @param puzzleElement the puzzle element to check
+     * @param e the mouse event
+     * @return true if the puzzle element is pickable, false otherwise
+     */
+    public boolean isPickable(PuzzleElement puzzleElement, MouseEvent e) {
+        return casePickableElements.contains(getPuzzleElement(puzzleElement));
+    }
+
     /**
      * Gets the modifiable attribute for the board.
      *
@@ -218,6 +297,7 @@ public boolean equalsBoard(Board board) {
 
     /**
      * Performs a deep copy of this board.
+     * Note: This method does not copy caseRule and pickablePuzzleElements.
      *
      * @return a new copy of the board that is independent of this one
      */

src/main/java/edu/rpi/legup/model/observer/IBoardListener.java

@@ -1,6 +1,6 @@
 package edu.rpi.legup.model.observer;
 
-import edu.rpi.legup.model.gameboard.CaseBoard;
+import edu.rpi.legup.model.gameboard.Board;
 import edu.rpi.legup.model.gameboard.PuzzleElement;
 import edu.rpi.legup.model.tree.TreeElement;
 
@@ -21,7 +21,7 @@ public interface IBoardListener {
      *
      * @param caseBoard case board to be added
      */
-    void onCaseBoardAdded(CaseBoard caseBoard);
+    void onCaseBoardAdded(Board caseBoard);
 
     /**
      * Called when a {@link PuzzleElement}'s data on the board has changed.