===== Homework 4. Five in a row AI =====

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.

==== 4.1. Board analysis (0.2p) ====

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.

<code scala>
def sequences(p: Player)(b: Board): Map[Int,Int] = ???
</code>

==== 4.2. Functionality (0.35p) ==== 

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**.

==== 4.3. Game AI (0.45p) ==== 

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.
<code scala>
def play(p: Player, b: Board): Board = ???
</code> 

**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 [[https://en.wikipedia.org/wiki/Minimax|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**

==== 4.4. Bonus (0.2p) ====

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)**.