CS2113-W12-3 Game

README.md

@@ -1,4 +1,4 @@
-# Duke project template
+# Game
 
 This is a project template for a greenfield Java project. It's named after the Java mascot _Duke_. Given below are instructions on how to use it.
 

build.gradle

@@ -29,11 +29,11 @@ test {
 }
 
 application {
-    mainClass.set("seedu.duke.Duke")
+    mainClass.set("main.CalculaChroniclesOfTheAlgorithmicKingdom")
 }
 
 shadowJar {
-    archiveBaseName.set("duke")
+    archiveBaseName.set("Demo1")
     archiveClassifier.set("")
 }
 
@@ -42,5 +42,7 @@ checkstyle {
 }
 
 run{
+    enableAssertions = true
     standardInput = System.in
+    enableAssertions = true
 }

docs/AboutUs.md

@@ -1,9 +1,12 @@
 # About us
 
-Display | Name | Github Profile | Portfolio 
---------|:----:|:--------------:|:---------:
-![](https://via.placeholder.com/100.png?text=Photo) | John Doe | [Github](https://github.com/) | [Portfolio](docs/team/johndoe.md)
-![](https://via.placeholder.com/100.png?text=Photo) | Don Joe | [Github](https://github.com/) | [Portfolio](docs/team/johndoe.md)
-![](https://via.placeholder.com/100.png?text=Photo) | Ron John | [Github](https://github.com/) | [Portfolio](docs/team/johndoe.md)
-![](https://via.placeholder.com/100.png?text=Photo) | John Roe | [Github](https://github.com/) | [Portfolio](docs/team/johndoe.md)
-![](https://via.placeholder.com/100.png?text=Photo) | Don Roe | [Github](https://github.com/) | [Portfolio](docs/team/johndoe.md)
+Display |    Name    | Github Profile | Portfolio 
+--------|:----------:|:--------------:|:---------:
+![](https://via.placeholder.com/100.png?text=Photo) | Aarav Rawal | [Github](https://github.com/) | [Portfolio](docs/team/johndoe.md)
+![](https://via.placeholder.com/100.png?text=Photo) | Tanner Lie | [Github](https://github.com/) | [Portfolio](docs/team/johndoe.md)
+![](https://via.placeholder.com/100.png?text=Photo) | Fang Sihan | [Github](https://github.com/) | [Portfolio](docs/team/johndoe.md)
+![](https://via.placeholder.com/100.png?text=Photo) |  Samuel  | [Github](https://github.com/) | [Portfolio](docs/team/johndoe.md)
+![](https://via.placeholder.com/100.png?text=Photo) |  Don Joe   | [Github](https://github.com/) | [Portfolio](docs/team/johndoe.md)
+![](https://via.placeholder.com/100.png?text=Photo) |  Ron John  | [Github](https://github.com/) | [Portfolio](docs/team/johndoe.md)
+![](https://via.placeholder.com/100.png?text=Photo) |  John Roe  | [Github](https://github.com/) | [Portfolio](docs/team/johndoe.md)
+

docs/DeveloperGuide.md

@@ -6,8 +6,70 @@
 
 ## Design & implementation
 
+### Architecture
+
+### UI Component
+
+# UserCommand feature
+
+User can type command to do things on the Map. 
+
+If the user type the command, `parseCommand` function will be called. After that, the original input will be
+analyzed by `analyseCommand` function to see if it matches a kind of `CommandType`. Then, we will return new
+Command back to the main based on the command type. The Final step is to call the `execute` function. If the command
+is the type of `fightCommand`, we will call the execute function with one parameter `Scanner`. For all other
+conditions, we will call the execute function with no parameter.
+
+![dummy test](/picture/Command.svg)
+
+### Map Component
+
+The API of this component is defined in BaseMap.java.
+
+Each map instance consists of a `currentMap` which stores a 2-dimensional array of characters which represents the 
+printed map for the player. All maps will come with a given `height` and `width`, all of these attributes are inherited
+from the AMap abstract class. Currently, the `FirstMap` and `BattleInterface` classes
+extend AMap. `FirstMap` is the first map displayed upon entering the game and it displays the position of the player. 
+The `BattleInterface` is the map displayed when the player interacts with an `interactable`. 
+
+
 {Describe the design and implementation of the product. Use UML diagrams and short code snippets where applicable.}
 
+### Interacting with Environment Component
+
+The API of this component is defined in InteractingCommand.java
+
+![Interaction UML](../picture/Interaction.png)
+
+This component happens when the user chooses to key the interact command. <br>
+Here is how it works:
+1.  When the command is passed by the user, the ```CalculaChroniclesOfTheAlgorithmicKingdom``` object calls the ```Parser``` object
+    to parse the command to call the respective commands. Here, the ```InteractingCommand``` object is created.
+2. The ```CalculaChroniclesOfTheAlgorithmicKingdom``` component then calls the execute() method in ```InteractingCommand```.
+3. It executes the method and creates other objects like ```Enemy``` and ```ShopKeaper``` components which are responsible for the 
+entity classes in the game and also ```BattleInterface``` and ```ShopMap``` which are responsible for displaying these entities among other things.
+4. The ```BattleInterface``` or ```ShopKeeper``` will then read from a .txt file to store their displays by creating the ```FileReader``` object and 
+running their respective methods.
+5. These displays, textboxes and player status will then be subsequently printed by the ```CalculaChroniclesOfTheAlgorithmicKingdom``` object.
+
+### Battling Component
+
+The API of this component is defined in FightCommand.java.
+
+![BattleInterface UML](../picture/BattleInterface.png)
+
+This component happens when the user chooses to fight an enemy. <br>
+Here is how it works:
+1.  When the user chooses to fight, the ```CalculaChroniclesOfTheAlgorithmicKingdom``` object calls the ```Parser``` object
+    to parse the command to call the respective commands. Here, the ```FightCommand``` object is created.
+2. The ```CalculaChroniclesOfTheAlgorithmicKingdom``` object then calls the execute() method in ```FightCommand``` and enables the fighting.
+3. The ```MathPool``` object is created, which is responsible for the math questions to answer and another ```Ui``` object is created to interact with the user.
+4. In the enebleFight() method, it has a loop which asks the user math questions to answer until the player or enemy dies. The player takes damage for 
+every wrong answer and deals damage to the enemy for every correct answer.
+5. In this loop, there is another loop to parse the answer given by the user, and displays an error message  and the same math question
+until the user gives an answer which is a valid integer.
+6. Once either the player or enemy dies, it then exits and runs the relevant checks to eventually print the output to be shown to 
+the user after battle, handled by ```CalculaChroniclesOfTheAlgorithmicKingdom```.
 
 ## Product scope
 ### Target user profile
@@ -20,10 +82,10 @@
 
 ## User Stories
 
-|Version| As a ... | I want to ... | So that I can ...|
-|--------|----------|---------------|------------------|
-|v1.0|new user|see usage instructions|refer to them when I forget how to use the application|
-|v2.0|user|find a to-do item by name|locate a to-do without having to go through the entire list|
+| Version | As a ... | I want to ...             | So that I can ...                                           |
+|---------|----------|---------------------------|-------------------------------------------------------------|
+| v1.0    | new user | see usage instructions    | refer to them when I forget how to use the application      |
+| v2.0    | user     | find a to-do item by name | locate a to-do without having to go through the entire list |
 
 ## Non-Functional Requirements
 

docs/UserGuide.md

@@ -2,32 +2,76 @@
 
 ## Introduction
 
-{Give a product intro}
+Welcome to Calcula: Chronicles of the Algorithmic Kingdom. This is a simple text based
+game. Your goal in this game is to defeat the enemies within and claim victory for yourself as a 
+math wizard.
 
 ## Quick Start
 
-{Give steps to get started quickly}
 
 1. Ensure that you have Java 11 or above installed.
-1. Down the latest version of `Duke` from [here](http://link.to/duke).
+1. Down the latest version of `CalculaChroniclesOfTheAlgorithmicKingdom` from [here](http://link.to/duke).
 
 ## Features 
 
-{Give detailed description of each feature}
+### The Map
+This game displays the character's position on a 2D grid, the player is denoted by a `P` 
+and the other interactable entities are denoted by other symbols.
 
-### Adding a todo: `todo`
-Adds a new item to the list of todo items.
+### Movement
+Traversing the map is similar to many common computer games. We use the "WASD" system such that
+entering `w` to the program shifts the player up by 1 space, entering `a` shifts the player to the left,
+entering `s` shifts the player down 1 space and lastly, entering `d` shifts the player to the right by 1 space.
+This movement can only take place when the 2D grid map is visible.
 
-Format: `todo n/TODO_NAME d/DEADLINE`
 
-* The `DEADLINE` can be in a natural language format.
-* The `TODO_NAME` cannot contain punctuation.  
+### Interacting 
+
+To interact with any entity in the game the player first has to move towards the symbol and be within close proximity
+to the symbol. We define close as the player needing to be directly above, below, to the left or to the right of an
+entity symbol, in other words, there can be no gap in between the player and the entity and interactions cannot occur
+diagonally. 
+
+To interact the player enters `e`. 
+
+This action will bring up a new interface called the battle interface. For now there will only be battles using this 
+interface but we plan to implement shops and other entities using this interface. For now, this interface will display 
+the enemy the symbol represents and gives you 2 options, to `run` or to `fight`.
+
+### Run 
+
+Should the player, in the battle interface, determine that the enemy is too strong, the player may choose to type `run` 
+to back out of the fight and return to the main map to continue moving around.
+
+### Fight
+
+Should the player, in the battle interface, wish to fight the enemy. Entering `fight` in the battle interface will 
+start a fight. A series of math questions will appear based on the strength of the enemy. Generally, stronger enemies
+will come with harder math questions. 
+
+The player will then enter the correct answer. The answer is guaranteed to be an integer. Getting the question correct
+will cause the player to attack the enemy and getting it wrong will cause the enemy to attack the player. Getting the 
+questions wrong repeatedly will deplete the player's health and once the player's health reaches 0, the player dies and 
+the game is over. However, depleting the enemy's health to 0 will result in a victory and the player is rewarded with 
+some gold and exp before returning the player to the main map. 
+
+### Hints
+
+Sometimes, hints are scattered throughout the map such that some text will display just below the map to help the player,
+hints are entirely passive and no user input is required for the hints to trigger.
+
+### Quit
+
+Enter `q`to quit the game.
+
+
+### Help
+
+If you need a refresher on the controls, entering either `h` or `help` will bring up a set of instructions.
+
 
-Example of usage: 
 
-`todo n/Write the rest of the User Guide d/next week`
 
-`todo n/Refactor the User Guide to remove passive voice d/13/04/2020`
 
 ## FAQ
 
@@ -37,6 +81,10 @@ Example of usage:
 
 ## Command Summary
 
-{Give a 'cheat sheet' of commands here}
-
-* Add todo `todo n/TODO_NAME d/DEADLINE`
+`w` `a` `s` `d` to move around
+`e` to interact
+`q` to quit
+`h` to print help menu
+`run` to escape the battle interface
+`fight` to commence a fight
+ all math questions have integer answers.

graph/BattleInterface.puml

@@ -0,0 +1,137 @@
+@startuml
+
+box Battle Component
+participant "CalculaChroniclesOfTheAlgorithmicKingdom" as main
+participant ":UI" as ui
+participant ":Parser" as parser
+participant ":TextBox" as text
+participant ":FightCommand" as f
+participant ":PlayerStatus" as player
+participant ":Enemy" as e
+participant ":BattleInterface" as bi
+participant ":FileReader" as fileReader
+participant ":Map" as map
+participant ":MathPool" as mathpool
+
+activate main
+main -> parser : parseCommand(userCommandText)
+activate parser
+create f
+parser -> f
+activate f
+f --> parser
+deactivate f
+parser --> main : command class
+deactivate parser
+main -> main : executeCommand()
+activate main
+main -> f : execute()
+activate f
+f -> bi : enableFight()
+activate bi
+create mathpool
+bi -> mathpool
+activate mathpool
+mathpool --> bi
+deactivate mathpool
+bi -> mathpool : init()
+activate mathpool
+mathpool --> bi
+deactivate
+create ":UI" as UI
+bi -> UI
+activate UI
+UI --> bi
+deactivate UI
+loop player and enemy is alive
+    bi -> player : getPlayerHealth()
+    activate player
+    player --> bi : player health
+    deactivate player
+    bi -> e : getHealth()
+    activate e
+    e --> bi : enemy health
+    deactivate e
+    bi -> UI : printPlayerStatus(currentPlayer)
+    activate UI
+    UI --> bi
+    deactivate UI
+    bi -> UI : printMap(mapData, currentEntity)
+    activate UI
+    UI --> bi
+    deactivate UI
+    bi -> mathpool : getQuestionByDifficulty(difficulty);
+    activate mathpool
+    mathpool --> bi : question
+    deactivate mathpool
+    bi -> UI : printQuestion(question)
+    activate UI
+    UI --> bi
+    deactivate UI
+    loop command is not an integer
+    bi -> text : setNextError(error)
+    activate text
+    text --> bi
+    deactivate text
+    bi -> text : setNextInstruction(question)
+    activate text
+    text --> bi
+    deactivate text
+    bi -> UI : printTextBox()
+    activate UI
+    UI --> bi
+    deactivate UI
+    end
+    alt correct answer
+    bi -> bi : playerHitEnemy()
+    else wrong answer
+    bi -> bi : enemyHitPlayer()
+    end
+end
+bi --> f
+deactivate bi
+alt enemy died
+    f -> map : getInteractX()
+    activate map
+    map --> f : x coordinate
+    deactivate map
+    f -> map : getInteractY()
+    activate map
+    map --> f : y coordinate
+    deactivate map
+    f -> map : clearSpot(x coordinate, y coordinate)
+    activate map
+    map --> f
+    deactivate map
+    f -> map : handleLootingByPlayer()
+    activate map
+    map --> f
+    deactivate map
+else player died
+    f -> map : handleDeath();
+    activate map
+    map --> f
+    deactivate map
+end
+f --> main
+deactivate f
+deactivate main
+main -> main : printMessageUnderMap(userCommand, ui, playerStatus, textBox)
+activate main
+alt not calling help menu or quitting game
+    alt show battle interface
+        main -> ui : printEnemy(currentMap)
+        activate ui
+        ui --> main
+        deactivate ui
+    else
+        main -> ui : printMap(currentMap)
+        activate ui
+        ui --> main
+        deactivate ui
+    end
+end
+
+end box
+
+@enduml

graph/Command.puml

@@ -0,0 +1,9 @@
+@startuml
+'https://plantuml.com/sequence-diagram
+
+Alice -> Bob: Authentication Request
+Bob --> Alice: Authentication Response
+
+Alice -> Bob: Another authentication Request
+Alice <-- Bob: another authentication Response
+@enduml

graph/Graphs.puml

@@ -0,0 +1,6 @@
+## AMap Class Diagram
+
+
+
+
+## AMap Sequence Diagram