diff --git a/AlternativeMapDesign/Illustration.jpg b/AlternativeMapDesign/Illustration.jpg
new file mode 100644
index 00000000..cf01b865
Binary files /dev/null and b/AlternativeMapDesign/Illustration.jpg differ
diff --git a/AlternativeMapDesign/alternativedesignmap.jpg b/AlternativeMapDesign/alternativedesignmap.jpg
new file mode 100644
index 00000000..d1b85f6d
Binary files /dev/null and b/AlternativeMapDesign/alternativedesignmap.jpg differ
diff --git a/Cat.java b/Cat.java
new file mode 100644
index 00000000..0b22bbd1
--- /dev/null
+++ b/Cat.java
@@ -0,0 +1,93 @@
+import java.util.Random;
+/**
+
+The Cat class represents a cat in the game.
+*/
+public class Cat {
+ public String name;
+ private int dexterity; //dex is the number you add on to a long range attack, which is a random attack number from 0-20, specifically for kick
+ private int strength; //strength is the number you add onto a attack, specifically for bite
+ private int iq; //iq is intelligence and the ability to escape, it adds onto a random 0-20 number
+ /**
+ * Constructor for the Cat class.
+ * @param name The name of the cat.
+ * @param dexterity The dexterity of the cat.
+ * @param strength The strength of the cat.
+ * @param iq The intelligence of the cat.
+ * @param hp The hit points of the cat.
+ * @param gameplay The gameplay object that the cat interacts with.
+ */
+ public Cat(String name, int dexterity, int strength, int iq) {
+ this.name = name;
+ this.dexterity = dexterity;
+ this.strength = strength;
+ this.iq = iq;
+
+ }
+ /**
+ * The cat kicks
+ * @return The total damage dealt by the cat's kick.
+ */
+ public int kick() {
+ Random random = new Random();
+ int randomNumber = random.nextInt(dexterity);
+ int ttl_dmg = randomNumber + this.dexterity;
+ return ttl_dmg;
+ }
+ /**
+ * The cat bites.
+ * @return The total damage dealt by the cat's bite.
+ */
+ public int bite() {
+ Random random = new Random();
+ int randomNumber = random.nextInt(strength);
+ int ttl_dmg = randomNumber + this.strength;
+ return ttl_dmg;
+ }
+ /**
+ * The cat tries to escape.
+ * @return The total IQ of the cat and a random number from 0-20.
+ */
+ public int escape() {
+ Random random = new Random();
+ int randomNumber = random.nextInt(iq);
+ int ttl_IQ = randomNumber + this.iq;
+ return ttl_IQ;
+ }
+ /**
+ * Hides the player from the monster's view.
+ */
+ public void hide() {
+ System.out.println("The monster can't see you now");
+ }
+ /**
+ * the cat meows
+ */
+ public void meow() {
+ System.out.println("meow! meow! meow!");
+ }
+ /**
+ * Gets the name of the cat.
+ * @return The name of the cat.
+ */
+ public String getName() {
+ return name;
+ }
+ /**
+ * Gets the dexterity of the cat.
+ * @return The dexterity of the cat.
+ */
+ public int getDexterity() {
+ return this.dexterity;
+ }
+ public int getStrength() {
+ return this.strength;
+ }
+ public int getIQ() {
+ return this.iq;
+ }
+
+ public String toString() {
+ return this.name;
+ }
+}
\ No newline at end of file
diff --git a/Cheatsheet.jpg b/Cheatsheet.jpg
new file mode 100644
index 00000000..5d261035
Binary files /dev/null and b/Cheatsheet.jpg differ
diff --git a/Gameplay.java b/Gameplay.java
new file mode 100644
index 00000000..5da31f23
--- /dev/null
+++ b/Gameplay.java
@@ -0,0 +1,402 @@
+import java.util.Scanner;
+import java.util.Random;
+import java.util.Stack;
+import javax.management.RuntimeErrorException;
+
+/**
+ * The Gameplay class represents the game mechanics and logic for playing the game.It includes methods for battling the monster,
+ * keeping track of the player's lives and score, and managing the game flow.
+ */
+
+public class Gameplay {
+
+ private static Stack < String > previousActions = new Stack < > ();
+ private static int playerLives = 9;
+ private static int playerScore = 0;
+ public static Monster monster = new Monster("monster", 5, 5, 5);
+ private static Cat cat;
+
+ public int getPlayerlives() {
+ return playerLives;
+ }
+
+ /**
+ * Returns the player's current score
+ * @return an interger representing the player's current score
+ */
+
+ public int getPlayerScore() {
+ return playerScore;
+ }
+
+ /**
+ * Simulates a battle between a cat and a monster based on their respective strength attributes.
+ * @return an integer value of the outcome based on the winner of the battle:
+ *
+ * - 1 if the cat's bite strength is greater than the monster's tear strength
+ * - 2 if the monster's tear strength is greater than the cat's bite strength
+ *
+ */
+
+ public static int strengthBattle() {
+ if (cat.bite() > monster.tear()) {
+ return 1;
+ } else {
+ return 2;
+ }
+ }
+
+ /**
+ * Simulates a battle between a cat and a monster based on their respective dexterity attributes.
+ * @return an integer value of the outcome based on the winner of the battle:
+ *
+ * - 1 if the cat's kick dexterity is greater than the monster's grab and throw dexterity
+ * - 2 if the monster's grab and throw dexterity is greater than the cat's kick dexterity/li>
+ *
+ */
+
+ public static int dexBattle() {
+ if (cat.kick() > monster.grabAndThrow()) {
+ return 1;
+ } else {
+ return 2;
+ }
+ }
+ /**
+ * Simulates a battle between a cat and a monster based on their respective IQ attributes.
+ * @return an integer value of the outcome based on the winner of the battle:
+ *
+ * - 1 if the cat's escape IQ is greater than the monster's block IQ
+ * - 2 if the monster's block IQ and throw dexterity is greater than the cat's kick dexterity/li>
+ *
+ */
+
+ public static int iqBattle() {
+ if (cat.escape() > monster.blockEscape()) {
+ return 1;
+ } else {
+ return 2;
+ }
+ }
+
+ /**
+ * Determines the winner of a battle between a cat and a monster based on their respective dexterity attributes,
+ * and outputs the result to the console.
+ *
+ * If the cat wins, the method prints "Your attack was stronger than the monster. Cat wins!"
+ * If the monster wins, the method prints "The monster was stronger than you. Monster wins!" and decrements the player's life count.
+ */
+
+ public static boolean winLoseDex() {
+ if (dexBattle() == 1) {
+ System.out.println("Your attack was stronger than the monster.");
+ System.out.println("Cat wins!");
+ return true;
+ } else {
+ System.out.println("The monster was stronger than you.");
+ System.out.println("Monster wins!");
+ playerLives--;
+ return false;
+ }
+ }
+
+ /**
+ * Determines the winner of a battle between a cat and a monster based on their respective strength attributes,
+ * and outputs the result to the console.
+ *
+ * If the cat wins, the method prints "You are strong enough to win. Cat wins!"
+ * If the monster wins, the method prints "You are not strong enough to win. Monster wins!" and decrements the player's life count.
+ */
+
+ public static boolean winLoseStrength() {
+ if (strengthBattle() == 1) {
+ System.out.println("You are strong enough to win.");
+ System.out.println("Cat wins!");
+ return true;
+ } else {
+ System.out.println("You are not strong enough to win.");
+ System.out.println("Monster wins!");
+ playerLives-=3;
+ return false;
+
+ }
+ }
+
+ /**
+ * Determines the winner of a battle between a cat and a monster based on their respective IQ attributes,
+ * and outputs the result to the console.
+ *
+ * If the cat wins, the method prints "You are smart enough to escape. Cat wins!"
+ * If the monster wins, the method prints "You are not smart enough to escape. Monster wins!" and decrements the player's life count.
+ *
+ * @return The current count of the player's remaining lives after the battle.
+ */
+
+ public static boolean winLoseIq() {
+ if (iqBattle() == 1) {
+ System.out.println("you are smart enough to escape");
+ System.out.println("Cat wins!");
+ return true;
+ } else {
+ System.out.println("you are not smart enough to escape");
+ System.out.println("Monster wins!");
+ playerLives-=2;
+ return false;
+ }
+ }
+
+ /**
+ * Simulates a battle encounter between a player's cat and a monster, where the player chooses an action to perform against the monster.
+ * The method checks the validity of the player's chosen action and calls the appropriate winLose method based on the action chosen.
+ * If the player enters an invalid action, the method prints an error message and does not perform any action.
+ *
+ * @param action1 The player's chosen action to perform against the monster.
+ */
+
+ public static boolean monsterencounter(String action1) {
+ if (action1.equalsIgnoreCase("kick")) {
+ return winLoseDex();
+ } else if (action1.equalsIgnoreCase("escape")) {
+ return winLoseIq();
+ } else if (action1.equalsIgnoreCase("bite")) {
+ return winLoseStrength();
+ } else {
+ //*Player enters an invalid action
+ System.out.println("I don't understand what you want to do. Please try again.");
+ return false;
+
+ }
+
+ /**
+ * Simulates a battle encounter between a player's cat and a monster. The method prompts the player to choose an action to perform against the monster,
+ * checks the validity of the player's chosen action, and calls the appropriate winLose method based on the action chosen.
+ * The method also allows the player to undo their previous action by entering "undo", and keeps track of the player's previous actions using a Stack.
+ *
+ */
+
+ }
+ public static void battle() {
+ System.out.println("A monster has appeared! It's time to battle!");
+ if (playerLives >= 5) {
+ boolean pass1 = true;
+ while (pass1 == true) {
+ System.out.println("What do you want to do?");
+ System.out.println("Kick");
+ System.out.println("Escape");
+ System.out.println("Bite");
+ Scanner battleInput = new Scanner(System.in);
+ String action5 = battleInput.next();
+ // monsterencounter(action5);
+ previousActions.push(action5);
+ if (monsterencounter(action5) == false) {
+ boolean pass = true;
+ while (pass == true) {
+ System.out.println("do you want to undo");
+ String action6 = battleInput.next();
+ if (action6.equalsIgnoreCase("undo") || (action6.equalsIgnoreCase("yes"))) {
+ if (!previousActions.isEmpty()) {
+ String lastAction = previousActions.pop();
+ playerLives++;
+ pass = false;
+ //* Revert the game state to what it was before the last action was taken*/
+ System.out.println("Undoing action: " + lastAction);
+ //* Implement the necessary logic to revert the game state*/
+ } else {
+ System.out.println("No actions to undo.");
+ pass = true;
+ }
+ pass1 = true;
+ } else if (action6.equalsIgnoreCase("No")) {
+ pass = false;
+ pass1 = false;
+ }
+ }
+ } else {
+ playerScore += 10;
+ pass1 = false;
+ }
+ }
+ } else {
+ System.out.println("You have less than 5 lives, you can't attack right now");
+ System.out.println("look for a first aid kit to gain a life");
+ System.out.println("Monster wins!");
+ playerLives--;
+ }
+
+ }
+
+
+
+ public static void main(String[] args) {
+ Scanner input = new Scanner(System.in);
+ Random random = new Random();
+ Scanner input3 = new Scanner(System.in);
+
+ System.out.println("Welcome to CATaclysm!");
+
+ System.out.println("What cat do you want to be?");
+ System.out.println("1. Sunny - low iq. high strength");
+ System.out.println("2. Yuki - high dexterity, low strength");
+ System.out.println("3. Babka - high iq, low dexterity");
+
+ //* prompts user enter the number of the cat that they wanr to be */
+ System.out.print("Enter the NUMBER of the cat you want to be: ");
+
+ // reads user's choice
+ int choice = input.nextInt();
+ input.nextLine();
+
+ //* Assign a new Cat object to 'cat' based on the user's choice */
+ if (choice == 1) {
+ //* Create a new Cat object with the name "Sunny" and the attributes (5, 7, 3)*/
+ cat = new Cat("Sunny", 5, 7, 3);
+ // Print out a cat ascii art
+ System.out.println(" |\\---/|");
+ System.out.println(" | o_o |");
+ System.out.println(" \\_^_/");
+
+ } else if (choice == 2) {
+ // Create a new Cat object with the name "Yuki" and the attributes (7, 5, 5)
+ cat = new Cat("Yuki", 7, 5, 5);
+ // Print out a cat ascii art
+ System.out.println(" /\\_/\\");
+ System.out.println("( o.o )");
+ System.out.println(" > ^ <");
+
+ } else if (choice == 3) {
+ // Create a new Cat object with the name "Babka" and the attributes (5, 5, 7)
+ cat = new Cat("Babka", 5, 5, 7);
+ // Print out a cat ascii art
+ System.out.println(" /\\_/\\");
+ System.out.println("( o o )");
+ System.out.println("==_Y_==");
+ System.out.println(" `-'");
+
+ } else {
+ //* Print an error message if the user enters anything else */
+ throw new RuntimeException("Unknown input. Please enter a valid number (1, 2, or 3).");
+
+ }
+
+ // Prints a welcome message to the user, addressing the chosen cat by its name.
+ System.out.println("Hi " + cat.toString() + ", you are a member of the colony of magical cats who live underground.(tap to continue)");
+
+ // Reads the user's input without using it, effectively waiting for the user to press Enter.
+ input.nextLine();
+ // Asks the user if they are ready to start the game.
+ System.out.println("You've been chosen to explore the surface and start a new life. Are you ready?");
+
+ //* The game loop continues as long as the player has lives left.*/
+ while (playerLives > 0 && playerScore<50) {
+
+ // Display the player's current lives and score.
+ System.out.println("You have " + playerLives + " lives left.");
+ System.out.println("Your score is " + playerScore);
+
+ // Prompt for player's next action
+ System.out.print("What do you want to do next? (explore or rest)");
+ String action = input.nextLine();
+
+ // Process player's action
+ if (action.equalsIgnoreCase("explore")) {
+ // Player chooses to explore the ruins
+ System.out.println("You venture out of the underground and explore the ruins of the post-apocalyptic world.");
+ // Generate a random number between 1 and 100
+ int randomNumber = random.nextInt(100) + 1;
+
+ if (randomNumber <= 10) {
+ System.out.println("You are lost in the woods. You hear a howling in the distance. The leaves are rustling as wind picks up.");
+
+ }
+ // Determine which event occurs based on the random number
+ if (randomNumber <= 25) {
+ // 25% chance of finding a treasure
+ System.out.println("You stumble upon a hidden treasure and gain 10 points.");
+ playerScore += 10;
+ } else if (randomNumber <= 50) {
+ // 25% chance of encountering a monster
+ //here we can throw in the batter mode and call methods from cat and monster class?
+ //we are going to have to build cat and monster objects
+ //also we could add a way to keep score through battle wins
+ //we could do random again for type of battle/see what method above to call?
+ //we could make a battle mode class?
+
+ battle();
+
+
+ } else if (randomNumber <= 75) {
+ // 25% chance of finding nothing
+ System.out.println("You find nothing of interest.");
+ // Asks the user if they want to meow and read their response
+ System.out.println("do you want to meow?(Yes,No)");
+ Scanner input2 = new Scanner(System.in);
+ String answer1 = input2.next();
+
+ // If the user wants to meow, perform some actions
+ if (answer1.equalsIgnoreCase("Yes") || (answer1.equalsIgnoreCase("yes"))) {
+ // Invoke the "meow" method of the Cat object
+ cat.meow();
+ // Inform the user that a monster is approaching
+ System.out.println("A monster heard you and approached you quickly");
+ //Asks the user if they want to hide or attack, and read their response
+ System.out.println("Do you want to hide or attack?");
+ String answer4 = input3.next();
+
+ // If the user wants to hide, the cat hides
+ if (answer4.equalsIgnoreCase("hide")) {
+ cat.hide();
+ }
+ // If the user wants to attack, initiate a battle and prompt for further action
+ else if (answer4.equalsIgnoreCase("attack")) {
+ battle();
+
+ } else {
+ // Player enters an invalid action
+ System.out.print("I don't understand you!");
+ }
+
+ } else {
+ // 25% chance of finding a first aid kit
+ System.out.println("You find a first aid kit and gain a life.");
+ //If the player's life count is less than 9, they gain an additional life.
+ if (playerLives < 9) {
+ playerLives += 1;
+
+ } else {
+ //If their llfe count is at the max of 9, their health is full.
+ System.out.println("You're fully healthy!");
+ }
+
+ }
+ }
+ // Process player's action
+ } else if (action.equalsIgnoreCase("rest")) {
+ if (playerLives < 9) {
+ playerLives++;
+ System.out.println("You take a break and rest for a while. You feel refreshed and gain a life.");
+ } else {
+ System.out.println("You already are fully rested.");
+ }
+ } else {
+ // Player enters an invalid action
+ System.out.println("I don't understand what you want to do. Please try again .");
+ }
+
+
+ }
+ // Check if the player has run out of lives.
+ if (playerLives == 0) {
+ System.out.println("You have no lives left. Game over!");
+ System.out.println("Your final score is"+playerScore);
+
+ }
+ if (playerScore == 50) {
+ System.out.println("Yay you won the game!");
+ System.out.println("Your final score is "+ playerScore);
+
+ }
+
+
+ }
+}
+
diff --git a/Monster.java b/Monster.java
new file mode 100644
index 00000000..b2ac5940
--- /dev/null
+++ b/Monster.java
@@ -0,0 +1,114 @@
+import java.util.Random;
+/**
+
+The Monster class represents a monster in a game. Each monster has a name, strength, intelligence, health points, and dexterity.
+
+The Monster class contains methods for attacking and defending, as well as for reducing the monster's health points.
+*/
+public class Monster {
+ private String name; // The name of the monster
+ private int dexterity = 5; // The dexterity of the monster
+ private int strength = 5; // The strength of the monster; added onto attack damage
+ private int iq = 5; // The intelligence of the monster; added onto defense
+
+ /**
+
+ *Creates a new Monster object with the specified name, strength, intelligence, health points, dexterity, and gameplay object.
+ *@param name the name of the monster
+ *@param strength the strength of the monster
+ *@param iq the intelligence of the monster
+ *@param dexterity the dexterity of the monster
+ */
+ public Monster(String name, int strength, int iq, int dexterity) {
+ this.name = name;
+ this.dexterity = dexterity;
+ this.strength = strength;
+ this.iq = iq;
+
+ }
+ /**
+
+ *Calculates the damage done by a tear attack and returns it.
+ *@return the amount of damage done by the tear attack
+ */
+ public int tear() {
+ int incomingDmg = getRandomNumber() + strength;
+ return incomingDmg;
+ }
+ /**
+
+ *Calculates the damage done by a grab and throw attack and returns it.
+ *@return the amount of damage done by the grab and throw attack
+ */
+ public int grabAndThrow() {
+ int idmg = getRandomNumber() + dexterity;
+ return idmg;
+ }
+ /**
+
+ *Calculates the enemy's intelligence for blocking and escaping.
+ *@return the enemy's intelligence for blocking and escaping.
+ */
+ public int blockEscape() {
+ int enemy_IQ = getRandomNumber() + iq;
+ return enemy_IQ;
+ }
+
+ /**
+
+ *Returns a random number between 0 and 20.
+ *@return a random number between 0 and 20
+ */
+ private int getRandomNumber() {
+ Random random = new Random();
+ return random.nextInt(21);
+ }
+ /**
+
+ *Returns the name of the monster.
+ *@return the name of the monster
+ */
+ public String getName() {
+ return name;
+ }
+ /**
+
+ *Returns the strength of the monster.
+ *@return the strength of the monster
+ */
+ public int getStrength() {
+ return strength;
+ }
+ /**
+
+ *Returns the intelligence of the monster.
+ *@return the intelligence of the monster
+ */
+ public int getIntelligence() {
+ return iq;
+ }
+ /**
+
+// *Returns the health points of the monster.
+// *@return the health points of the monster
+// */
+ // public int getHealthPoints() {
+ // return hp;
+ // }
+
+ /**
+ * Returns the dexterity level of the monster.
+ *
+ * @return the dexterity level of the monster
+ */
+ public int getDexterity() {
+ return dexterity;
+ }
+ public void setDexterity(int dexterity) {
+ this.dexterity = dexterity;
+ }
+
+}
+
+
+
diff --git a/README.md b/README.md
index c1a995eb..cdbc9986 100644
--- a/README.md
+++ b/README.md
@@ -10,9 +10,23 @@
## Additional Reflection Questions
- What was your **overall approach** to tackling this project?
+ we focused on having simple methods and then we built on them to have the loop and to allow multiple paths in the game. We also focused on the storyline as we wanted it to be intertaining and engaging. We also worked on having a strong base for our game for example having the different battles with different conditions.
- What **new thing(s)** did you learn / figure out in completing this project?
+ We learned that we have to plan before starting to code. We learned how to use while loops for our advantages by switching different variables between true and false.
- Is there anything that you wish you had **implemented differently**?
+ YES!
+ We wanted to use a map to enhance the storyline in the game.
+ We wanted to add audio in the battles and make them more complex and intertaining.
+ we wanted to have more options when the player chooses to explore.
+ we wanted to have cats with more special attributes.
+ we wanted to have an inventory so the player can interact with game more.
- If you had **unlimited time**, what additional features would you implement?
+ we would implement what we mentioned before and we would have used graphics. We had the code for the map almost ready but because of the time limit we couldn't finish it and had to delete it.
- What was the most helpful **piece of feedback** you received while working on your project? Who gave it to you?
+ we are not sure who was the person, but they adviced us to mention what makes each cat special. Altough it might sound like a simple thing but actually it is very helpful in explainig the game and the point of it
- If you could go back in time and give your past self some **advice** about this project, what hints would you give?
+ To meet up more with the team to work on the game.
+ plan first!!!
+ focus on the details because they might cause an unexpected error at the same time don't ignore the big image
- _If you worked with a team:_ please comment on how your **team dynamics** influenced your experience working on this project.
+ We had very different scheduales and we were bad at managing to meet up. We did not do well with deviding the work and it was hard to balance working on the code all of us together. Since the map idea didn't work the project noe seems very simple so we think that if we work on it more in the future it will be very fun and more engaging and we plan on doing that.
diff --git a/architecturediagram.jpg b/architecturediagram.jpg
new file mode 100644
index 00000000..9cd90d5b
Binary files /dev/null and b/architecturediagram.jpg differ
diff --git a/cheatsheet.md b/cheatsheet.md
index d5dc4294..45121d6e 100644
--- a/cheatsheet.md
+++ b/cheatsheet.md
@@ -2,7 +2,29 @@ This file will contain documentation for all commands available in your game.
Note: It's a good idea to also make this list available inside the game, in response to a `HELP` command.
+In this game, the following commands are available(the available commands may depend on the current state of the game and the choices made by the player.):
+
+Kick: Initiates a battle with the monster using the cat's kick dexterity.
+Escape: Initiates a battle with the monster using the cat's escape IQ.
+Bite: Initiates a battle with the monster using the cat's bite strength.
+Undo: Undoes the previous action taken in the game and for now it is only available now when you encounter a monster but we are working on improving it .
+Meow: Allows the cat to meow and potentially trigger an event.
+Hide: Allows the cat to hide when encountering a monster after meowing.
+Attack: Initiates a battle with the monster after meowing.
+Explore:Allows the player to encounter different senarios one of them is: to explore the ruins of the post-apocalyptic world.
+Rest: Allows the player to rest and regain lives.
+Yes/No: Used to respond to prompts or questions in the game.
+
+
+
+
+
+
+
+
# SPOILER ALERT
If your game includes challenges that must be overcome to win, also list them below.
+
+the player must gain more than 5 lives in some cases to attack the monster. So the player must look for a first aid kit to be able to gain a life.
diff --git a/rubric.md b/rubric.md
index 8bb8f4c8..3787cd7c 100644
--- a/rubric.md
+++ b/rubric.md
@@ -1,48 +1,49 @@
## Front-End Design (10 pts)
-_____ 2 pts: Game has a **robust, understandable text-based interface** that allows the player to control their movement through the game. Player should be able to enter any command at any time, and if it makes sense in the current context it will be carried out.
+__2___ 2 pts: Game has a **robust, understandable text-based interface** that allows the player to control their movement through the game. Player should be able to enter any command at any time, and if it makes sense in the current context it will be carried out.
-_____ 2 pts: Submission includes a **cheat sheet** (`cheatsheet.md`) documenting all of the available commands, as well as a **description of the layout** of your game world's underlying physical layout; this can be described in words, or included as a separate image file if you prefer to sketch a map by hand. If your game includes **challenges** that must be overcome to win, also describe them here.
+___2__ 2 pts: Submission includes a **cheat sheet** (`cheatsheet.md`) documenting all of the available commands, as well as a **description of the layout** of your game world's underlying physical layout; this can be described in words, or included as a separate image file if you prefer to sketch a map by hand. If your game includes **challenges** that must be overcome to win, also describe them here.
-_____ 2 pts: Storyline driving the game is **engaging**, and individual elements of play make sense within the context of the story.
+___2__ 2 pts: Storyline driving the game is **engaging**, and individual elements of play make sense within the context of the story.
-_____ 2 pts: Game has **multiple possible paths / outcomes** (i.e. gameplay depends on player's choices and is not the same every time).
+___2__ 2 pts: Game has **multiple possible paths / outcomes** (i.e. gameplay depends on player's choices and is not the same every time).
-_____ 1 pt: Gameplay supports **reversible moves** where reasonable (e.g., if you pick up an object, you should be able to put it back down again later, possibly in a different place; if you go north then you should be able to return to the previous location by going south unless something has blocked your return path).
+__2___ 1 pt: Gameplay supports **reversible moves** where reasonable (e.g., if you pick up an object, you should be able to put it back down again later, possibly in a different place; if you go north then you should be able to return to the previous location by going south unless something has blocked your return path).
-_____ 1 pt: Some paths through the game have **restricted access** until the player has completed a task or acquired a specific item (i.e. a key to open a door, etc.).
+___1__ 1 pt: Some paths through the game have **restricted access** until the player has completed a task or acquired a specific item (i.e. a key to open a door, etc.).
## Back-End Design (10 pts)
-_____ 2 pts: Selected classes(s) are **effective, efficient** at supporting the desired operations and program behavior.
+__2___ 2 pts: Selected classes(s) are **effective, efficient** at supporting the desired operations and program behavior.
-_____ 2 pts: Design justification includes a discussion of at least one (reasonable) **alternative design** that could have been used, and the reasons why you decided against this alternative.
+___2__ 2 pts: Design justification includes a discussion of at least one (reasonable) **alternative design** that could have been used, and the reasons why you decided against this alternative.
+ our alternative design would be to have a map with different coordinates and nodes and differnet dialog will play out different coordinates and different ending to the game and story based on where you go.
-_____ 2 pts: The project makes effective use of **Java built-in classes** whenever they are appropriate.
+___2__ 2 pts: The project makes effective use of **Java built-in classes** whenever they are appropriate.
-_____ 2 pts: The project's design is **extensible** (i.e. someone else could pick up where you left off, adding on or modifying the game without requiring a total rewrite).
+___2__ 2 pts: The project's design is **extensible** (i.e. someone else could pick up where you left off, adding on or modifying the game without requiring a total rewrite).
-_____ 2 pts: Submission includes an **architecture diagram** describing the relationships between all classes.
+___2__ 2 pts: Submission includes an **architecture diagram** describing the relationships between all classes.
## General Items (10 pts):
-_____ 4 pts: Program compiles without errors or warnings.
+___4__ 4 pts: Program compiles without errors or warnings.
-_____ 2 pts: Executes fully & consistently without crashing (exception/freeze).
+___2__ 2 pts: Executes fully & consistently without crashing (exception/freeze).
-_____ 2 pt: Complies with style guidelines (missing items 1 pt each):
+___2__ 2 pt: Complies with style guidelines (missing items 1 pt each):
- _____ Classes & class members all have Javadoc header comments.
+ ___1__ Classes & class members all have Javadoc header comments.
- _____ Clear and consistent indentation of bracketed sections.
+ __1___ Clear and consistent indentation of bracketed sections.
- _____ Adheres to Java conventions on naming & capitalization.
+ ___1__ Adheres to Java conventions on naming & capitalization.
- _____ Methods & variables all have clear and accurate names.
+ ___1__ Methods & variables all have clear and accurate names.
- _____ Methods avoid confusing side effects.
+ __1___ Methods avoid confusing side effects.
-_____ 1 pt: All required files included with submission (including completed checklist file).
+____1_ 1 pt: All required files included with submission (including completed checklist file).
-_____ 1 pt: `readme.md` contains your reflection on the project and responses to all prompts .
+___1__ 1 pt: `readme.md` contains your reflection on the project and responses to all prompts .