apolishch/dreamteam

A two player chess game, written in Rails and deployed to Heroku

dreamteam's Issues

Capture Logic

On the ChessPiece Model, add a check for whether the target location for movement is occupied (add a move_to! method if necessary)

If there is a piece occypying the location, and that piece has the opposite color, remove it from the game.

There are a few ways to do this:

• You could have a status on the pieces (e.g. onboard vs captured)
• you could se the x/y coordinates to nil
• You could point blank delete the piece from the database

If the piece occupying the target location shares the color of the moving piece, the move should fail.

List available games in the UI

Call valid_move? when a piece is moved, and reject the move if the move is invalid

This should actually connect movement, in full, from the UI, and only allow valid moves.

Build a valid_move? method on the King

• If the move takes the king off the board, return false
• If the move is_obstructed?, return false
• If the move is more than one in any direction, return false
• Otherwise, return true

Connect Check and add messaging

Create a barebones Rails App

• Create a static landing page
• Serve the static landing page from '/'

build valid_move? for pawn

A pawn can move two squares if it is it's first move.
A pawn can NOT capture vertically
A pawn can only capture diagonally
This story includes En passant

Build View for the Chess board

• Have an empty chess board on games#show page
  (8x8 grid bottom left is black)

Don't worry about pieces just yet

Build login and signup functionality on top of devise

Populate the board

• On game creation, assign 32 pieces to the game with correct locations etc.
• On the board, render them in their correct starting locations. E.g. render with letters...

Connect the move_to! which we built for capture to the controller updates so that pieces are actually removed from the board

The aim is that piece are actually removed from the board/game.

pull out super method valid_move? onto chess piece and call it from all of the pieces

• Check is_obstructed.
• Check target location is on the board
• Check target location not occupied by a piece of the same color
• Call this with super in all of your other valid_move?

Add icons for pieces

Build valid_move? for knight

Prevent moving yourself into check

If you are in check, no moves which do not remove check, are valid

Connect castling through UI, handle it as a possible move client side

Game creation UI

-[] On the home screen there should be a button, something like create game. The one that creates it should be assigned as the white player.

Create an available scope on game

-[] Google rails scopes
-[] Create a scope that returns all games which only has one player

Extend Castling

can_castle? should also verify if the king is in check,
if the king would be in check at the resulting position, or at any position between start and finish

Joining a game causes pieces to populate twice

Support moving pieces

• Each piece that is drawn on the board will be a link. The link should point at: GET /pieces/:id
• The pieces#show method should rerender the board, highlighting the selected piece
• Once a piece is selected, each square should be a PUT /pieces/:id, passing x and y on the params
• This should call the update action which should trigger @piece.update_attributes

Allow players to forfeit

Create a method which ends the game, and sets a winner and loser.

Create a button somewhere in the UI which connects to the forfeit method, and ends the game, with the person who pressed it being the loser.

When the other player next refreshes the page, they should be notified of their glorious victory

Setup CD

• Pick a provider (CircleCI/TravisCI/CodeShip/Jenkins......)
• Wire up said CD provider to run tests on every commit
• Wire up said CD provider to also run migrations before tests
• Wire up said CD provider to run tests on merges to master, and then push to heroku
• Wire up said CD provider, to display build status on pull requests

Example Ticket

Continue Game button doesn't work

Add En Passant to Pawn valid_move?

https://lichess.org/video/GMgIKo2GM6M

Build a valid_move? for Rook

Plan out Database model

• Try and come up with the easiest way to model a normal chessgame.
• Don't worry about things that are way in the future (e.g. ELO calculations, or stalemate tracking)
  Model movement, pieces, games, victory, positions
• Bring this one up for discussion, talk to Abe as well
• Just use Excel/Google Sheets or whatever similar tool you want

Setup Testing Environment

• Pick a testing framework (RSpec and Minitest)
• Setup FactoryGirl
• Setup Capybara
• Write a single passing test. expect(true).to be(true) is perfectly fine

Create the initial database model

Follow the model we agreed upon.
Write migrations for them.

Track moves in a Move Table

Build valid_move? for queen

Only allow to join games not against yourself

Extend the available scope to handle this

Password reset

-[] Add a link on login screen which. Send out an email which links to a page where you can enter a new password etc.

Games in progress can still be joined

Setup Single Table Inheritance for Pieces

There should probably be a ChessPiece Super class,
Pawn, Knight, Bishop, Rook, Queen, King subclasses.
This should (somehow (look at resources)) be encoded at the database level

Setup Devise

• Install Gem
• Configure to interact with users table, create migrations as necessary

is_obstructed? method on piece

• Write a method on the piece model which should accept an x/y coordinate, and return true if there is another piece between the pieces current coordinates and the target x/y

Introduce Checkmate

If the game is in Check, and no possible move exists which removes Check Game ends, person in Checkmate loses

Setup the Game Model and CRUD on it

Our GameController should respond, meaningfully to:

• :New
• :Create
• :Show

Allow joining a game

• On the list of available games, add a join button (to each game). This button should make player join as the color black.

Support Castling

If the king and the corresponding rook have no been move, castling should be possible.

Cannot castle through obstruction.

Add a method called can_castle?(rook_position) which should return a boolean.

It should verify if the king or the rook have moved, and if there are any obstructions.

Build valid_move? for Bishop

Build Turn basedlogic

• Keep track of whose turn it is currently
• After every move, if the move is(was?) valid, change the turn taker
• Only allow the person who'se turn it is to affect the board in any way.
• In the UI, indicate somewhere who'se turn it is

If you're not signed and press join a game, heroku errors

Protip: heroku logs --tail --app dreamteam-chess

Determine Check

• Add a method on the Game Model, which establishes where the current state of the game is "check"

This is explicitly NOT checkmate

Create Wireframe

Run past team, bring to discussion.
There are loads of tools you could use for this. Loads of designers I know swear by Balsamiq

Create a PaaS application using a provider of your choice

(this will probably be easisest with Heroku)

• Invite team to collaborate

Add Test coverage tracking

• Pick a tool (SimpleCov is popular)
• Integrate tool with CD pipeline
• Set bar high (90% seems fair)