- Mohammad Anas: A59020296
- Nimit Vasavat: A59017505
- Yatharth Vyas: A59018062
- Install Haskell and Cabal
cd chesscabal run
This project is most compatible with cabal v3.10.2.0 and GHC v9.4.7 however it should work with any recent version of cabal and GHC.
Our CSE 230 project centers around developing a command-line terminal user interface (TUI) for an interactive two-player chess game. The key elements of this game encompass:
Chess board Game pieces (both hollow and solid) Check button Input box for player movements Message window to communicate valid/invalid moves, player turns, and win status.
The chess board will aim to incorporate a visualizer to display eligible paths for the selected piece. We will enable text input for piece movements, such as inputting "Bc4" to signify the Bishop moving to the c4 square. If time allows, we will explore implementing piece movement via mouse clicks. Additionally, we plan to highlight opponent pieces in red that fall within the potential path of the selected piece.
This game operates on a turn-based system where each player takes turns inputting their moves on the same device.
To achieve this, we will utilize the brick library to construct a text-based grid representing the chessboard. We will define a Cell type for each square, which can either be empty or contain a piece. A function will be employed to display these cells, and another function will arrange them into a complete board. The application will set up visual attributes and manage events, ultimately displaying the initial state of the chessboard.
- The feature to highlight possible moves and takedowns was inspired by: https://lichess.org/practice/checkmates/piece-checkmates-i/BJy6fEDf/dW7KIuoY
- Special Moves: https://www.chess.com/terms/special-chess-moves
- Color Scheme for Chess board: https://omgchess.blogspot.com/2015/09/chess-board-color-schemes.html
- Chess ASCII Symbols: https://en.wikipedia.org/wiki/Chess_symbols_in_Unicode
- Chess Game Title ASCII Art: https://patorjk.com/software/taag/#p=display&f=Graffiti&t=Chess
- Lenses in Haskell: https://www.fpcomplete.com/haskell/tutorial/lens/
- For borders in UI: https://github.com/jtdaugherty/brick/blob/master/programs/BorderDemo.hs
- Tasty documentation (for tests): https://hackage.haskell.org/package/tasty
- Brick documentation (for UI): https://hackage.haskell.org/package/brick
- Host and Client implementation documentation (for Networked Chess): https://hackage.haskell.org/package/network-3.1.4.0/docs/Network-Socket.html
- Github Copilot was used to auto-complete some of the code for the project: https://copilot.github.com/
- ChatGPT was used in error debugging and some code completion: https://chat.openai.com/
- We took some help from TA George for implementing the GameState as a global variable (using lenses)
Types.hs: This contains the definition for all types that are used in our Project. It includes the different components of chess board such as cells, pieces which are combined into the GameState type.
Piece.hs: This contains all functions that are related to chess pieces, their movement constraints and getter/setter functions to access them on the chess board.
TestData.hs: This contains some data for initial board and some temporary GHCi style tests to verify the implementation of current functions.
Main.hs: contains the rendering code that is used to draw the chess board and handle the brick app with Gamestate.
ValidateMove.hs: This contains the parser code for reading user input and then translating that to legal moves on the chess board.
- You enter a move
- Check happens to see if it follows convention or not
- If it does, then executeMove is called
- executeMove first calls the parseMove to obtain coordinates
- executeMove then checks if those coordinates are legal using isLegalMove
- If the move is legal then executeMove calls makeMove
- makeMove makes the change to the board and returns the updated board
- executeMove returns the board it receives from makeMove
We had to implement a global variable for the GameState that would be similar to a Monad, with much debugging and some help from TA George, we were able to implement this using the lenses library in Haskell. Another challenging part was to implement the logic for the movement of the pieces. We had to implement a function that would take the current position of the piece and the new position of the piece and then check if the move is legal or not. We had to implement this for all the pieces wherein each piece has a different movement constraint. A issue we faced was to represent the pieces on the chess board. Since the pieces are either black or white, they camouflage with the chessboard and sometimes you cannot distinguish the presence of a black piece on a black chessboard cell which is why we changed the color of the chessboard to a lighter shade of brown.
We feel that we should be able to make a Chess Game with all rules incorporated before the deadline but it would be difficult to make this a networked game. We are aiming at perfecting what we have before prioritizing more ambitious goals that are good to have such as a "Networked Multiplayer Mode".
By first focusing on the more important parts of the project and splitting the work into independent segments, we will work in parallel on finishing the remaining parts for the implementation of a basic single player chess game. We might take up the Networked/Multiplayer mode incase we are left with enough time at the end of the project to build it
React
Typescript
Django
Laravel
Facebook
Microsoft
Google
Alibaba
D3
Tencent