update(MancalaImpl) <- playPit returns stateArray

7 files changed, 125 insertions, 10 deletions

diff --git a/domain/src/main/java/mancala/domain/Bowl.java b/domain/src/main/java/mancala/domain/Bowl.java
index a36c621..07859f7 100644
--- a/domain/src/main/java/mancala/domain/Bowl.java
+++ b/domain/src/main/java/mancala/domain/Bowl.java
@@ -62,4 +62,6 @@ abstract class Bowl {
 
 
     protected abstract String makeString(String playerBowls, String opponentBowls, String kalahas);
+
+    protected abstract int[] toStateArray(int[] stateArray, int index);
 }
diff --git a/domain/src/main/java/mancala/domain/Kalaha.java b/domain/src/main/java/mancala/domain/Kalaha.java
index c85af4a..411a86d 100644
--- a/domain/src/main/java/mancala/domain/Kalaha.java
+++ b/domain/src/main/java/mancala/domain/Kalaha.java
@@ -73,4 +73,16 @@ class Kalaha extends Bowl {
     void claimStolenBooty(int booty) {
         myStones = myStones + booty;
     }
+
+    @Override
+    protected int[] toStateArray(int[] stateArray, int index) {
+        stateArray[index] = getMyStones();
+        if (index == stateArray.length - 2) {
+            stateArray[stateArray.length - 1] = (getMyOwner().hasTheTurn() ? Mancala.PLAYER_TWO : Mancala.PLAYER_ONE);
+            return stateArray;
+        } else {
+            return getNextBowl().toStateArray(stateArray, ++index);
+        }
+    }
+
 }
diff --git a/domain/src/main/java/mancala/domain/Mancala.java b/domain/src/main/java/mancala/domain/Mancala.java
index f8a2621..d80e9e5 100644
--- a/domain/src/main/java/mancala/domain/Mancala.java
+++ b/domain/src/main/java/mancala/domain/Mancala.java
@@ -24,7 +24,7 @@ public interface Mancala {
 	 * @param index Index of the recess to be played.
 	 * @return 15 item long Array with the current state of the game. The 15th item indicates which player has the next turn (possible values are 1 or 2).
 	 */
-	void playPit(int index) throws MancalaException;
+	int[] playPit(int index) throws MancalaException;
 	
 	/**
 	 * Method for returning the amount of stones in de specified pit. Index is as specified below:
diff --git a/domain/src/main/java/mancala/domain/MancalaImpl.java b/domain/src/main/java/mancala/domain/MancalaImpl.java
index a8e6691..0090f2d 100644
--- a/domain/src/main/java/mancala/domain/MancalaImpl.java
+++ b/domain/src/main/java/mancala/domain/MancalaImpl.java
@@ -1,5 +1,6 @@
 package mancala.domain;
 
+import java.util.Arrays;
 import java.util.HashSet;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
@@ -27,6 +28,19 @@ public class MancalaImpl implements Mancala {
         domainOpponent = domainPlayer.getOpponent();
     }
 
+    public MancalaImpl(int[] stonesArray) {
+        try {
+            domainReference = new SmallBowl(
+                    Arrays.stream(stonesArray)
+                    .boxed().collect(Collectors.toList())
+            );
+        } catch (DomainSmallBowlException e) {
+            e.printStackTrace();
+        }
+        domainPlayer = domainReference.getMyOwner();
+        domainOpponent = domainPlayer.getOpponent();
+    }
+
     @Override
     public boolean isPlayersTurn(int player) {
         switch (player) {
@@ -40,7 +54,7 @@ public class MancalaImpl implements Mancala {
     }
 
     @Override
-	public void playPit(int index) throws MancalaException {
+	public int[] playPit(int index) throws MancalaException {
         if (isPlayersTurn(Mancala.PLAYER_ONE) && MancalaImpl.PLAYER_TWO_PITS.contains(index)) {
             throw new MancalaException("Player one cannot play player two's pits.");
         }
@@ -61,6 +75,7 @@ public class MancalaImpl implements Mancala {
             domainReference.getNextSmallBowlTimes(skipKalahaIndex).play();
         }
 
+        return domainReference.toStateArray(new int[15], 0);
     }
 	
 	@Override
@@ -93,9 +108,9 @@ public class MancalaImpl implements Mancala {
 	public int getWinner() {
         if (!isEndOfGame()) return Mancala.NO_PLAYERS;
 
-        if (domainPlayer.won()) return Mancala.PLAYER_ONE;
+        if (domainPlayer.won() && domainOpponent.won()) return Mancala.BOTH_PLAYERS;
+        else if (domainPlayer.won()) return Mancala.PLAYER_ONE;
         else if (domainOpponent.won()) return Mancala.PLAYER_TWO;
-        else if (domainPlayer.won() && domainOpponent.won()) return Mancala.BOTH_PLAYERS;
         else return Mancala.NO_PLAYERS;
     }
 
diff --git a/domain/src/main/java/mancala/domain/SmallBowl.java b/domain/src/main/java/mancala/domain/SmallBowl.java
index 216e2ad..b750f61 100644
--- a/domain/src/main/java/mancala/domain/SmallBowl.java
+++ b/domain/src/main/java/mancala/domain/SmallBowl.java
@@ -17,6 +17,9 @@ public class SmallBowl extends Bowl {
         if (stonesList.size() % 2 != 0) {
             throw new DomainSmallBowlException("Stones List should contain even number of elements.");
         }
+        if (stonesList.size() < 4) {
+            throw new DomainSmallBowlException("Stones list should have length greater than or equal to 4.");
+        }
         this.myOwner = new Player();
 
         int boardSize = stonesList.size();
@@ -24,7 +27,9 @@ public class SmallBowl extends Bowl {
 
         this.myStones = stonesList.remove(0);
 
-        this.nextBowl = new SmallBowl(boardSize, bowlsToAdd, stonesList, this, this.getMyOwner());
+        if (boardSize == 4) this.nextBowl = new Kalaha(boardSize, bowlsToAdd, stonesList, this, this.getMyOwner());
+        else this.nextBowl = new SmallBowl(boardSize, bowlsToAdd, stonesList, this, this.getMyOwner());
+
         referencePoint = this;
     }
 
@@ -145,4 +150,13 @@ public class SmallBowl extends Bowl {
         }
     }
 
+    @Override
+    protected int[] toStateArray(int[] stateArray, int index) {
+        stateArray[index] = getMyStones();
+        if (index == stateArray.length - 2) {
+            return stateArray;
+        } else {
+            return getNextBowl().toStateArray(stateArray, ++index);
+        }
+    }
 }
diff --git a/domain/src/test/java/mancala/domain/BowlTest.java b/domain/src/test/java/mancala/domain/BowlTest.java
index 0f2ea4a..0614201 100644
--- a/domain/src/test/java/mancala/domain/BowlTest.java
+++ b/domain/src/test/java/mancala/domain/BowlTest.java
@@ -143,6 +143,24 @@ class BowlTest {
             }
         }
 
+        @Test
+        void given_a_stones_list_with_less_than_four_elements_when_instantiating_small_bowl_then_throw_DomainSmallBowlException() {
+            int[] stonesArray = new int[] {1,2};
+            List<Integer> stonesList = Arrays.stream(stonesArray).boxed().collect(Collectors.toList());
+            try {
+                referenceSmallBowl = new SmallBowl(stonesList);
+                fail("No exception when stones list is too small");
+            } catch (DomainSmallBowlException e) {
+            }
+            stonesArray = new int[] {1,2,3,4};
+            stonesList = Arrays.stream(stonesArray).boxed().collect(Collectors.toList());
+            try {
+                referenceSmallBowl = new SmallBowl(stonesList);
+            } catch (DomainSmallBowlException e) {
+                fail("Should work fine");
+            }
+        }
+
         void setupGameSituationAndFailIfInvalid(int[] stonesArray) {
             try {
                 referenceSmallBowl = new SmallBowl(
diff --git a/domain/src/test/java/mancala/domain/MancalaImplTest.java b/domain/src/test/java/mancala/domain/MancalaImplTest.java
index 6f0ce2a..61409ac 100644
--- a/domain/src/test/java/mancala/domain/MancalaImplTest.java
+++ b/domain/src/test/java/mancala/domain/MancalaImplTest.java
@@ -2,6 +2,7 @@ package mancala.domain;
 
 import org.junit.jupiter.api.*;
 
+import java.util.Arrays;
 import java.util.HashSet;
 
 import static org.junit.jupiter.api.Assertions.*;
@@ -128,8 +129,33 @@ class MancalaImplTest {
             playPitAndFailIfNoException(7, "Didn't throw exception when Pit was empty when played!");
         }
 
+        @Test
+        void given_that_pit_has_stones_and_player_has_turn_when_playPit_is_called_then_return_array_representing_state() {
+            mancala = new MancalaImpl(new int[] {1,0,0,0,0,0,0,1,0,0,0,0,0,0});
+            assumeTurn(Mancala.PLAYER_ONE);
+            int[] stateArray = playPitAndFailIfNotValid(0);
+            assertEquals(15, stateArray.length,
+                    "length of the state array should be 15.");
+            assertTrue(Arrays.equals(new int[] {0,1,0,0,0,0,0,1,0,0,0,0,0,0,2}, stateArray));
+
+            stateArray = playPitAndFailIfNotValid(7);
+            assertEquals(15, stateArray.length,
+                    "length of the state array should be 15.");
+            assertTrue(Arrays.equals(new int[] {0,1,0,0,0,0,0,0,1,0,0,0,0,0,1}, stateArray));
+        }
+
     }
 
+    /**
+     * Method for returning the amount of stones in de specified pit. Index is as specified below:
+     *
+     *    12 11 10  9  8  7
+     * 13                    6
+     *     0  1  2  3  4  5
+     *
+     * @param index Index of the pit.
+     * @return Amount of stone.
+     */
     @Nested
     class getStonesForPit {
         @Test
@@ -171,21 +197,33 @@ class MancalaImplTest {
 
     }
 
+    /**
+     * Method for retrieving whether the game has ended or not.
+     *
+     * @return True is the game has ended otherwise False.
+     */
     @Nested
     class isEndOfGame {
         @Test
-        void given_the_game_is_not_ended_when_isEndOfGame_is_called_then_return_false() {
+        void given_the_game_has_not_ended_when_isEndOfGame_is_called_then_return_false() {
             assertFalse(mancala.isEndOfGame());
         }
 
         @Test
-        void given_the_game_is_ended_when_isEndOfGame_is_called_then_return_true() {
+        void given_the_game_has_ended_when_isEndOfGame_is_called_then_return_true() {
+            mancala = new MancalaImpl(new int[] {0,0,0,0,0,1,0,0,0,0,0,0,0,0});
+            playPitAndFailIfNotValid(5);
             assertTrue(mancala.isEndOfGame());
         }
 
 
     }
 
+    /**
+     * Method for retrieving the player that has won the game.
+     *
+     * @return Integer value representing which player(s) (if any) won the game.
+     */
     @Nested
     class getWinner {
         @Test
@@ -195,12 +233,27 @@ class MancalaImplTest {
 
         @Test
         void given_PLAYER_ONE_has_won_in_the_domain_model_when_getWinner_is_called_then_return_Mancala_PLAYER_ONE() {
+            mancala = new MancalaImpl(new int[] {0,0,0,0,0,1,0,0,0,0,0,0,0,0});
+            playPitAndFailIfNotValid(5);
             assertEquals(Mancala.PLAYER_ONE, mancala.getWinner());
         }
 
         @Test
         void given_PLAYER_TWO_has_won_in_the_domain_model_when_getWinner_is_called_then_return_Mancala_PLAYER_TWO() {
-            assertEquals(Mancala.PLAYER_TWO, mancala.getWinner());
+            mancala = new MancalaImpl(new int[] {0,1,0,0,0,0,0,0,0,0,0,2,0,0});
+            playPitAndFailIfNotValid(1);
+            playPitAndFailIfNotValid(7 + 4);
+            playPitAndFailIfNotValid(7 + 5);
+            assertEquals(Mancala.PLAYER_TWO, mancala.getWinner(),
+                    "PLAYER TWO should win here.");
+        }
+
+        @Test
+        void given_BOTH_PLAYER_have_won_in_the_domain_model_when_getWinner_is_called_then_return_Mancala_BOTH_PLAYERS() {
+            mancala = new MancalaImpl(new int[] {0,0,0,0,0,1,0,0,0,0,0,0,1,0});
+            playPitAndFailIfNotValid(5);
+            assertEquals(Mancala.BOTH_PLAYERS, mancala.getWinner(),
+                    "PLAYER TWO should win here.");
         }
 
     }
@@ -215,11 +268,12 @@ class MancalaImplTest {
                 "It's PLAYER " + (player == 1 ? "ONE's" : "TWO's") + " turn!");
     }
 
-    void playPitAndFailIfNotValid(int index) {
+    int[] playPitAndFailIfNotValid(int index) {
         try {
-            mancala.playPit(index);
+            return mancala.playPit(index);
         } catch (MancalaException e) {
             fail("Invalid play.");
+            return new int[0];
         }
     }