Homework 4 consists in developing a complete five-in-a-row game, together with an AI and a very basic interface.

• For this stage, you will decide on the structure of your project, as well as write tests to guide your implementation.
• There are three parts of this homework, which will be evaluated independently;
• The evaluation will take into account your working code, AS WELL AS THE TESTS THAT YOU WRITE (If you write insufficient tests, an otherwise working code may not be graded).
• There will be no other partial points, other than those mentioned explicitly in the statement.

For this part, you need to implement a function sequences, that returns a map of the form: (5,a), (4,b), (3,c), (2,d) where:

• a is the number sequences of length 5 that the player has established (on lines, columns or diagonals).
• b is the number of sequences of length 4 which can be filled-out in order to achieve a 5-sequence. For example: XX XX is such a sequence for player One, however XX0XX is not, since this cannot be filled-out in order to achieve a 5-sequence.
• c (resp. d) is the number of sequences of length 3 (resp. 2) which can be filled-out in order to achieve a 5-sequence.

• Proper testing is essential for this function, as the AI will take decisions based on it. It will be harder to spot problems with sequences in a later stage of the project.
• You can replace the implementation of winner with a call to this function, to make the code more compact and avoid partial re-implementations.

def sequences(p: Player)(b: Board): Map[Int,Int] = ???

For this part, you need to implement a functional project which consists of a running loop:

• Asks for the player to supply a move (expressed as a pair (x,y) of coordinates to play, or in any other manner that you prefer).
• Plays the opponent move via the AI
• Displays the board, and repeats, until either player wins.

More details will be available during lecture.

For this particular part, tests are not necessary.

This part is at the very core of the project, and essentially consists of a function play, which implements the AIs decision of selecting a move.

def play(p: Player, b: Board): Board = ???

You may slightly change the signature of this function, to accommodate your project.

You may start with a very basic (trivial) implementation, which will allow you to move on with 4.2. and then refine it after B.2. is complete.

We offer no guidelines about how this function should be implemented, this is entirely up to you, but you may consider:

Possible strategies:

• You may implement play by simply evaluating the sequences that are available in the current play, as well as those of the opponent. This local strategy may become complicated, require a lot of code, as the game may unfold in different ways. It is also important to have a good strategy for starting the game (e.g. a play in either corner of the board is a bad way to start).

• The standard approach, is to implement a Minimax Tree which allows you to inspect the game unfolding for a few moves in advance (e.g. 3 moves). More details will be given during lecture.

• Very basic, but functional AI: 0.1p
• Intermediate AI (which may win in some cases): 0.2p
• Minimax-based AI 0.45p

During the last lecture, we will play a tournament of Five-in-a-row, in which all your AI programs will compete.

The author the best AI implementations will be awarded a bonus of 0.2p.

The winner of the tournament will receive a maximal grade of 10 for the entire lecture (no attendance to the exam will be necessary).