Documentation

Given a position vector in the form (file, rank), add it to a given Position, and return the result so long as we remain in a valid Position.

Given a MovingVector Int and a starting Position, "slide" the piece to each square recursively in the direction of moving vector. Note that here we don't take into account whether or not the move is actually valid, other than ensuring that we remain on the board.

Given a list of moving vectors and a position, return a list of lists, where each inner list contains possible (unvalidated) moves in each possible direction.

Given a Board and a list of unvalidated Positions we might want to move to, validate each position and see if we can, in fact, move there. In the future, the validator will need to know the kind of Piece being moved so it can check for things like the moving side being in check.

This function lets us move up until a move becomes invalid.

The third parameter carries along a MovingVector Int which is used for validation later on. Namely, it is used for as a justification for why a particular position has been reached. This is important because we must handle pawns differently due to how they capture, although there might be a cleaner approach.

Given a Board, a list of moving vectors, and the Position that we are currently at, return a list of validated positions to which we can move.

This basically just combines all of the above machinery into an easy-to-use function that we can use in generate below.

Given a Board, an origin Position, a query Position and a list of moving vectors, determine whether or not the query Position is currently under attack.

We generate a list of valid moves, and simply determine if the query position is one of those moves. Note that this does _NOT_ yet account for pawn-takes.

This can be specialized to test for check.

Can the given move legally be made?

It checks the following things:

• We are not trying to move from an empty square.
• The moving side cannot capture/land on its own piece.
• (TODO!) The move will not place the moving side in check.
• We are not capturing a king.
• We are not moving a piece that is not ours.
• A pawn can only move diagonally if it is capturing (legally).

Given a current Position and a list of 'Moving Vector' Int, assume that the piece is NOT a sliding one and generate the list of valid Positions to which it can move.

Move generation!

Determine possible moves for the side to move.

Generate a GameTree by calling allMoves the appropriate number of times depending on the depth.