Final Project

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "java.debug.settings.onBuildFailureProceed": true
+}

Castle.java

@@ -0,0 +1,81 @@
+/**
+ * Castle class represents a special location (castle) in the Candy Land game.
+ * Players can enter or exit castles if they are accessible.
+ */
+public class Castle {
+    protected static String name;           
+    protected static boolean isAccessible;  
+    protected static boolean isInTheCastle; 
+
+    /**
+     * Constructor for Castle.
+     * @param name The name of the castle.
+     */
+    public Castle(String name) {
+        this.name = name;
+        this.isAccessible = true;
+        this.isInTheCastle = false;
+    }
+
+    /**
+     * Gets the name of the castle.
+     * @return The name of the castle.
+     */
+    public String getName() {
+        return name;
+    }
+
+    /**
+     * Checks if the castle is accessible.
+     * @return True if accessible, false otherwise.
+     */
+    public static boolean isAccessible() {
+        return isAccessible;
+    }
+
+    /**
+     * Sets whether the castle is accessible.
+     * @param accessible True to make accessible, false to block access.
+     */
+    public static void setAccessible(Boolean accessible) {
+        FrostedPalace.isAccessible = accessible;
+    }
+
+    /**
+     * Checks if the player is currently inside the castle.
+     * @return True if inside, false otherwise.
+     */
+    public boolean isInTheCastle() {
+        return isInTheCastle;
+    }
+
+
+    /**
+     * Handles the logic for entering the castle.
+     * Player can only enter if the castle is accessible and they are not already inside.
+     */
+    public static void enter() {
+        if (isAccessible && !isInTheCastle) {
+            isInTheCastle = true;
+            System.out.println("You have entered the " + name + ".");
+
+        } else if (isInTheCastle) {
+            System.out.println("You are already in the " + name + ".");
+        } else {
+            System.out.println("The " + name + " is not accessible right now.");
+        }
+    }
+
+    /**
+     * Handles the logic for exiting the castle.
+     * Player can only exit if they are currently inside.
+     */
+    public void exit() {
+        if (isInTheCastle) {
+            isInTheCastle = false;
+            System.out.println("You have exited the " + name + ".");
+        } else {
+            System.out.println("You are not in the " + name + " to exit.");
+        }
+    }
+}

Design Justification.md

@@ -0,0 +1,11 @@
+# Design Justification
+For this project, we designed a text-based adventure game inspired by Candy Land, where players journey through a series of themed challenges — Lollipop Castle, Frosted Palace, Nana’s Nuthouse, and finally, King Kandy’s Castle.
+
+ Each location is implemented as a class extending from a common superclass (Castle or Paths), allowing us to structure the game using inheritance and encapsulation.
+
+We broke our code into separate classes so it was easier to manage and fix, and so each person could work on their part without getting in each other’s way. Each castle or location had its own challenge logic (e.g., a jumping challenge in Lollipop Castle, a number guessing game in Frosted Palace), which helped isolate bugs and made testing individual components easier. We also made sure the main method acted more as a narrative controller rather than duplicating logic.
+
+# Alternative Considered
+One design alternative we discussed was using cards instead of a spinning wheel — or even incorporating both — to determine player movement. While the spinning wheel was simpler to implement programmatically using random numbers, incorporating cards could have added an element of memory or strategy but it was more time consuming to configure. If we had more time, we might have explored a hybrid mechanic that combines randomness with player choice.
+
+

FullSpinner.java

@@ -0,0 +1,95 @@
+import java.util.ArrayList;
+import java.util.Random;
+
+/**
+ * The FullSpinner class simulates a spinner used in a board game.
+ * It randomly selects a color or candy tile from a predefined list.
+ * Special tiles (candies) can be removed once visited to prevent replay.
+ * 
+ * This class supports adding spinner parts, removing special tiles,
+ * spinning for a random outcome, and displaying the result.
+ */
+public class FullSpinner {
+    private ArrayList<SpinnerPart> parts;
+    private String part;
+    private Random random;
+
+    /**
+     * Constructs a FullSpinner with an empty list of spinner parts
+     * and initializes the random number generator.
+     */
+    public FullSpinner() {
+        this.parts = new ArrayList<>();
+        this.random = new Random();
+    }
+
+    /**
+     * Populates the spinner with basic color tiles and special candy tiles.
+     * This method should be called before any spinning is performed.
+     */
+    public void addParts() {
+        parts.add(new SpinnerPart("Red"));
+        parts.add(new SpinnerPart("Purple"));
+        parts.add(new SpinnerPart("Yellow"));
+        parts.add(new SpinnerPart("Blue"));    
+        parts.add(new SpinnerPart("Orange"));
+        parts.add(new SpinnerPart("Green"));
+        parts.add(new SpinnerPart("Red"));
+        parts.add(new SpinnerPart("Purple"));
+        parts.add(new SpinnerPart("Yellow"));
+        parts.add(new SpinnerPart("Blue"));    
+        parts.add(new SpinnerPart("Orange"));
+        parts.add(new SpinnerPart("Green"));
+        parts.add(new SpinnerPart("Red"));
+        parts.add(new SpinnerPart("Purple"));
+        parts.add(new SpinnerPart("Yellow"));
+        parts.add(new SpinnerPart("Blue"));    
+        parts.add(new SpinnerPart("Orange"));
+        parts.add(new SpinnerPart("Green"));
+
+        // Adding special candy tiles
+        parts.add(new SpinnerPart("Peppermint")); 
+        parts.add(new SpinnerPart("Icecream"));
+        parts.add(new SpinnerPart("Licorice")); 
+        parts.add(new SpinnerPart("Lollipop")); 
+        parts.add(new SpinnerPart("Peanut")); 
+    }
+
+    /**
+     * Removes a special tile (e.g., candy) that has already been visited
+     * so it won't appear again in future spins.
+     * 
+     * @param partName the name of the tile to remove from the spinner
+     */
+    public void removeVisitedCandies(String partName) {
+        parts.removeIf(p -> p.getColor().equals(partName));
+    }
+
+    /**
+     * Spins the spinner and returns a randomly selected SpinnerPart.
+     * 
+     * @return the randomly selected SpinnerPart
+     * @throws IllegalStateException if the spinner parts list is empty
+     */
+    public SpinnerPart spin() {
+        if (parts.isEmpty()) {
+            throw new IllegalStateException("The spinner parts list is empty! Please add parts before spinning.");
+        }
+
+        int index = random.nextInt(parts.size());
+        SpinnerPart SpinnerOutput = parts.get(index);
+
+        this.part = SpinnerOutput.getColor();
+        return SpinnerOutput;
+    }
+
+    /**
+     * Returns a string representation of the spin result.
+     * 
+     * @return message indicating the tile the player spun
+     */
+    @Override
+    public String toString() {
+        return "Congratulations! You have spun a " + this.part + ". You can now advance ahead to the " + this.part + " tile.";
+    }
+}

KingKandyCastle.java

@@ -0,0 +1,41 @@
+import java.util.Scanner;
+
+/**
+ * Represents King Kandy's Castle, the final destination in Candy Land.
+ * Players can only enter if they have the required key from Frosted Palace.
+ */
+public class KingKandyCastle extends Castle {
+    private boolean hasKeyToKingKandy; 
+
+    /**
+     * Constructor.
+     */
+    public KingKandyCastle() {
+        super("King Kandy's Castle");
+        this.hasKeyToKingKandy = false; 
+    }
+
+    /**
+     * Sets whether the player has the key to King Kandy's Castle.
+     * @param hasKey true if the player has the key, false otherwise.
+     */
+    public void setHasKeyToKingKandy(boolean hasKey) {
+        this.hasKeyToKingKandy = hasKey;
+    }
+
+    /**
+     * Attempts to enter King Kandy's Castle.
+     * Only allows entry if the player has the King Kandy key.
+     */
+    public void attemptEntry() {
+        if (hasKeyToKingKandy) {  // <<< use the local boolean here
+            Scanner scanner = new Scanner(System.in);
+            System.out.println("\n You have reached King Kandy's Castle!");
+            System.out.print("Press Enter to step inside and claim your victory...");
+            scanner.nextLine();
+            System.out.println("\n Congratulations! You have WON the game!");
+        } else {
+            System.out.println("\n You cannot enter King Kandy's Castle yet! You need the final key!");
+        }
+    }
+}

LicoriceLagoon.java

@@ -0,0 +1,88 @@
+import java.util.Scanner;
+
+/**
+ * Represents the Licorice Lagoon, a special location in the game where players
+ * must guess the number of licorice pieces to proceed and earn the key to Lollipop Castle.
+ */
+public class LicoriceLagoon extends PathPlaces {
+    private static boolean hasKeyToLollipop = false;
+
+    /**
+     * Constructs a new Licorice Lagoon with the specified name and player input.
+     * 
+     * @param name the name of this location
+     * @param playerInput the initial player input value
+     */
+    public LicoriceLagoon(String name, int playerInput) {
+        super(name, playerInput);
+    }
+
+    /**
+     * Displays the welcome message and challenge description for the Licorice Lagoon.
+     */
+    public void printPathName() {
+        System.out.println("You have entered the Licorice Lagoon! You are ready to begin your next challenge. " +
+                          "From 2000 - 5000, how many licorice make up the Lagoon?");
+    }
+
+    /*
+    * When you land in the lagoon you will need to guess a number.
+    * If you guess it incorectly, you will get a random trivia question.
+    * ArrayList of the trivia questions.
+    */
+
+    /**
+     * Starts the licorice counting challenge.
+     * Players must guess a number between 2000 and 5000.
+     * Odd numbers allow direct progression, while even numbers require answering a trivia question.
+     * 
+     * @return true if the player has earned the key to Lollipop Castle
+     */
+    public Boolean startChallenge() {
+        Scanner scanner = new Scanner(System.in);
+        int playerInput = scanner.nextInt();
+        String question = triviaQuestions.get(this.random.nextInt(triviaQuestions.size()));
+
+        hasKeyToLollipop = true;
+        if (playerInput >= 2000 && playerInput <= 5000) {
+            if (playerInput % 2 != 0) {
+                System.out.println("Aha! I see you have done your research! " + playerInput + 
+                                 " licorice make up the Lagoon. You can advance to the next tile.");
+            } else {
+                System.out.println("Oh no! " + playerInput + 
+                                 " is not the correct number of licorice that make up the Lagoon. " +
+                                 "You must complete the following trivia question to move to the next tile. " + 
+                                 question);
+                scanner.nextLine();
+                String response = scanner.nextLine();
+                System.out.println("Well done! You have completed the challenge and may progress to the next tile.");
+            }
+        } else {
+            System.out.println("Please enter a number between 2000 and 5000.");
+        }
+        System.out.println("Yay! You also just acquired the key to Lollipop Castle. Keeping it in your inventory for now."); 
+        return hasKeyToLollipop;
+    }
+
+    /**
+     * Displays a success message when the player completes the challenge.
+     */
+    public void finalSentiment() {
+        System.out.println("That's right! You have completed the challenge and may progress to the next tile.");
+    }
+
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+
+        LicoriceLagoon llTest = new LicoriceLagoon("Licorice Lagoon", 2003);
+        llTest.printPathName();
+
+
+        try {
+            Boolean result = llTest.startChallenge();
+            System.out.println("Result: " + result);
+        } catch (IllegalArgumentException e) {
+            System.err.println("Error: " + e.getMessage());
+        }
+    }
+}