[CS2113-T18-1] ChessMaster

.github/workflows/gradle.yml

@@ -33,18 +33,18 @@ jobs:
       - name: Build and check with Gradle
         run: ./gradlew check
 
-      - name: Perform IO redirection test (*NIX)
-        if: runner.os == 'Linux'
-        working-directory:  ${{ github.workspace }}/text-ui-test
-        run: ./runtest.sh
-
-      - name: Perform IO redirection test (MacOS)
-        if: always() && runner.os == 'macOS'
-        working-directory:  ${{ github.workspace }}/text-ui-test
-        run: ./runtest.sh
-
-      - name: Perform IO redirection test (Windows)
-        if: always() && runner.os == 'Windows'
-        working-directory:  ${{ github.workspace }}/text-ui-test
-        shell: cmd
-        run: runtest.bat
+      # - name: Perform IO redirection test (*NIX)
+      #   if: runner.os == 'Linux'
+      #   working-directory:  ${{ github.workspace }}/text-ui-test
+      #   run: ./runtest.sh
+
+      # - name: Perform IO redirection test (MacOS)
+      #   if: always() && runner.os == 'macOS'
+      #   working-directory:  ${{ github.workspace }}/text-ui-test
+      #   run: ./runtest.sh
+
+      # - name: Perform IO redirection test (Windows)
+      #   if: always() && runner.os == 'Windows'
+      #   working-directory:  ${{ github.workspace }}/text-ui-test
+      #   shell: cmd
+      #   run: runtest.bat

.gitignore

@@ -8,10 +8,13 @@
 /build/
 src/main/resources/docs/
 
+.vscode
+
 # MacOS custom attributes files created by Finder
 .DS_Store
 *.iml
 bin/
 
 /text-ui-test/ACTUAL.TXT
 text-ui-test/EXPECTED-UNIX.TXT
+data/

META-INF/MANIFEST.MF

@@ -0,0 +1,3 @@
+Manifest-Version: 1.0
+Main-Class: chessmaster.ChessMaster
+

README.md

@@ -1,6 +1,6 @@
 # Duke project template
 
-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.
+This is a project template for a greenfield Java project. It's named after Chess and Master. Given below are instructions on how to use it.
 
 ## Setting up in Intellij
 

build.gradle

@@ -29,11 +29,11 @@ test {
 }
 
 application {
-    mainClass.set("seedu.duke.Duke")
+    mainClass.set("chessmaster.ChessMaster")
 }
 
 shadowJar {
-    archiveBaseName.set("duke")
+    archiveBaseName.set("chessmaster")
     archiveClassifier.set("")
 }
 
@@ -43,4 +43,11 @@ checkstyle {
 
 run{
     standardInput = System.in
+    enableAssertions = true
+}
+
+compileJava.options.encoding = 'UTF-8'
+
+tasks.withType(JavaCompile) {
+    options.encoding = 'UTF-8'
 }

build.xml

@@ -0,0 +1,35 @@
+<project name="ChessMaster" basedir="." default="main">
+
+    <property name="src.dir"     value="src/main/java"/>
+    <property name="build.dir"   value="build"/>
+    <property name="classes.dir" value="${build.dir}/classes"/>
+    <property name="jar.dir"     value="${build.dir}/jar"/>
+    <property name="main-class"  value="chessmaster.ChessMaster"/>
+
+    <target name="clean">
+        <delete dir="${build.dir}"/>
+    </target>
+
+    <target name="compile">
+        <mkdir dir="${classes.dir}"/>
+        <javac includeantruntime="false" target="11" source="11" encoding="utf8" srcdir="${src.dir}" destdir="${classes.dir}"/>
+    </target>
+
+    <target name="jar" depends="compile">
+        <mkdir dir="${jar.dir}"/>
+        <jar destfile="${jar.dir}/${ant.project.name}.jar" basedir="${classes.dir}">
+            <manifest>
+                <attribute name="Main-Class" value="${main-class}"/>
+            </manifest>
+        </jar>
+    </target>
+
+    <target name="run" depends="jar">
+        <java jar="${jar.dir}/${ant.project.name}.jar" fork="true"/>
+    </target>
+
+    <target name="clean-build" depends="clean,jar"/>
+
+    <target name="main" depends="clean,run"/>
+
+</project>

docs/AboutUs.md

@@ -1,9 +1,9 @@
 # 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)
+| Name            | ID        | Github        |
+|-----------------|-----------|---------------|
+| Antriksh Dhand  | A0278458J | antrikshdhand |
+| Oh Ken Wei      | A0251850J | ken-ruster    |
+| Ou Ningxiang    | A0249445W | onx001        |
+| Tong Zheng Hong | A0251819Y | TongZhengHong |
+| Tricia Boo Koh  | A0264665U | TriciaBK      |

docs/DeveloperGuide.md

@@ -6,7 +6,110 @@
 
 ## Design & implementation
 
-{Describe the design and implementation of the product. Use UML diagrams and short code snippets where applicable.}
+![](images/OverallArchitecture.png)
+
+### Architecture
+
+The Architecture Diagram given above explains the high-level design of the application. Given below is a quick overview of main components and how they interact with each other.
+
+#### Main components of the architecture
+
+`ChessMaster` is the main invocation of the application. It handles the loading of previous chess games from the storage file and running of the chess `Game` instance.  
+
+The remaining logic is handled by the following components:
+- **UI**: The User Interface of the application
+- **Game**: Executes user commands in game and CPU moves
+- **Storage**: Reads and write chess game information to the hard disk
+- **ChessBoard**: Holds the current chess board state in memory
+- **Parser**: Parses string representations into relevant classes (`Command`, `Move`, `ChessPiece`, etc)
+
+Our application also uses other classes to store information about the chess game and provide utility functions for the main components to function. This include: `Command`, `Move`, `Coordinate`, `Color`,  `Player`, `ChessTile` and `ChessPiece(s).`
+
+### ChessMaster component
+
+<!-- Here is a partial class diagram of ChessMaster.  -->
+
+The sequence diagram below illustrates the interactions within the ChessMaster component, when they launch the program. 
+
+![](images/ChessMasterSequence.png)
+
+How does ChessMaster component work:
+
+1. Attempts to load previously stored game in storage
+2. If previous game exists, asks the user if a new game or the previous game should be loaded. 
+3. If a new game is selected, the user will be prompted for the color to start. 
+4. Start running the new or previous game instance. 
+
+### Game component
+
+The sequence diagram below illustrates the interactions within the Game component, taking a move of "a2 a3" as example.
+
+![](images/GameSequence.png)
+
+How does the Game component work:
+1. Solicits input from user. Users can provide game commands, if not recognised, it will parsed as a `MoveCommand`.
+2. The returned command will be executed.
+3. If user entered a game command (not MoveCommand), the next user input will be solicited.
+4. If a MoveCommand is identified, the user's input will be parsed as a Move object with checks to ensure it is a valid move on the chessboard.
+5. The user's validated Move will be executed on the chess board. This move will then be saved in the storage file.
+6. Next, it will be the CPU's turn to play. The best move will be calculated by the CPU object and it will be executed on the chess board. This move will also be saved in the storage file.
+7. Once both the user and CPU has made their moves, the game state will be checked where the number of kings on the board and the winner will be determined.
+
+### Architecture
+
+### User Input Handling - `Parser` and `Command`
+Below is a class diagram representing the Command and Parser classes.
+![](images/ParserCommandDiagram.png)
+
+In order to handle user input into the program during the game, the `Parser` class was implemented.
+Below is a sequence diagram describing the process of handling user input passed from `Game`:
+
+![](images/ParseCommandSequence.png)
+
+`Parser` works to resolve a player's input in the following manner:
+
+1. When `Parser` is called to parse a command, it returns the relevant `Command` object (More precisely,
+one of its subclasses e.g. `MoveCommand`), which is then executed by `Game`.
+2. Depending on the type of `Command` returned, the following may occur: 
+   1.  If it is a `MoveCommand`, the Command calls `parseMove` to instantiate the `Move`,
+   which is passed back to `Game` to be executed in the main logic.
+   2. If it is a `ShowMovesCommand`, `parseAlgebraicCoor` is called to obtain the position of the piece as a 
+   `Coordinate` object. The available coordinates are printed using `showAvailableCoordinates`, then stored as a String
+   by `getAvailableCoordinatesString()`.
+3. The result is then encapsulated in a `CommandResult` and returned to `Game` to be handled.
+4. If the player made a move resulting in a promotion, `parsePromote` is called.
+5. `Parser` calls `getColor` and `getPosition` to retrieve relevant data from the `ChessPiece` 
+the player wants to promote.
+6. The user's input is parsed and a new `ChessPiece` is returned.
+
+`Parser` also contains methods to fulfil parsing needs in other parts of the program, for instance `parseChessPiece`, 
+which is called while loading the .txt file containing save data, called for each character representing a 
+singular chess piece. Using a Case statement, it returns the relevant `ChessPiece` object depending on the character
+(representing the type of piece), and whether it is capitalised (representing colour).
+
+How the parsing works:
+- When called upon to parse a user command, the `Parser` class returns a relevant subclass of the `Command` class
+  (i.e. entering a valid command "XYZ" will cause `Parser` to return an `XYZCommand` object)
+- Each `Command` subclass contains the relevant methods to execute the specified command
+(AbortCommand, ShowCommand, etc.) and inherit from the abstract `Command` class.
+
+### Minimax algorithm
+
+The minimax algorithm is used to determine the best move for the AI to make. It is a recursive algorithm that works by alternatingly minimising opponent scores and maximising CPU scores. The algorithm is implemented in the `Minimax` class.
+
+### Storage Component
+**API:**
+
+Below is a class diagram representing the Storage class.
+The Storage component is responsible for handling the storage and retrieval of chess game state.
+![](StorageClass.png)
+
+![](StorageSequence.png)
+
+* Creates the necessary parent directories for the file and the file itself if they don't exist 
+* Saves the current state of the ChessBoard to the file. It includes the player's color information and current player's turn as the first line and the state of the chessboard in an 8x8 format.
+* Allows resetting the game by clearing the contents of the file.
+* Loads the state of the chessboard from the file by constructing a 2D array of ChessTile objects.
 
 
 ## Product scope
@@ -23,16 +126,29 @@
 |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|
+|v1.0|player|only move valid moves|play chess properly|
+|v1.0|new user|start a new game|play chess multiple times|
+|v1.0|player|see the current state of the chess board on every turn|think about what move to play|
+|v1.0|player|tell which symbol represents which piece|know what is where|
+|v1.0|player|specify move coordinates|move the piece I want how I want it|
+|v1.0|player|promote pieces when the option is available|play extended games properly|
+|v1.0|player|have the option to abort the game|leave the game when I no longer want to play|
 |v2.0|user|find a to-do item by name|locate a to-do without having to go through the entire list|
+{more to be added}
+
 
 ## Non-Functional Requirements
 
-{Give non-functional requirements}
+1. Should work on any mainstream OS as long as it has Java 11 or above installed. 
+2. A user with a basic understanding of chess should be able to navigate the game without difficulty. 
+{More to be added}
+
 
 ## Glossary
 
 * *glossary item* - Definition
 
 ## Instructions for manual testing
 
+
 {Give instructions on how to do a manual product testing e.g., how to load sample data to be used for testing}

docs/README.md

@@ -1,4 +1,4 @@
-# Duke
+# ChessMaster
 
 {Give product intro here}
 

docs/StorageClass.puml

@@ -0,0 +1,26 @@
+@startuml
+class Storage {
+  - filePathString: String
+
+  + Storage(filePath: String)
+  + saveBoard(board: ChessBoard, playerColor: Color): void
+  + resetBoard(): void
+  + loadBoard(): ChessTile[][]
+  + loadPlayerColor(): Color
+
+  - createChessMasterFile(): void
+}
+
+class ChessBoard {
+  - SIZE: int
+}
+
+class ChessTile
+
+class Color
+
+Storage --|> File
+Storage --|> ChessBoard
+Storage --|> ChessTile
+Storage --|> Color
+@enduml