refactor cleaning up constructin and recursion

5 files changed, 176 insertions, 216 deletions

diff --git a/domain/src/main/java/mancala/domain/Bowl.java b/domain/src/main/java/mancala/domain/Bowl.java
index b96cbfa..a131163 100644
--- a/domain/src/main/java/mancala/domain/Bowl.java
+++ b/domain/src/main/java/mancala/domain/Bowl.java
@@ -8,11 +8,5 @@ interface Bowl {
 
     Player getPlayerThatOwnsMe();
 
-    static int calculateBoardPosition(int startPosition, int addedBowlsCount) {
-        if ((startPosition + addedBowlsCount) > 14) {
-            return ((addedBowlsCount + startPosition) - 14);
-        }
-        return startPosition + addedBowlsCount;
-    }
-
+    Bowl distribute(int remainingRocks);
 }
diff --git a/domain/src/main/java/mancala/domain/Kalaha.java b/domain/src/main/java/mancala/domain/Kalaha.java
index b324849..c1ef3cb 100644
--- a/domain/src/main/java/mancala/domain/Kalaha.java
+++ b/domain/src/main/java/mancala/domain/Kalaha.java
@@ -6,23 +6,21 @@ class Kalaha implements Bowl {
     private final Bowl nextBowl;
 
     public Kalaha() {
+        // constructs board by recursively calling either kalaha or smallbowl constructors
         this.myRocks = 0;
         this.playerThatOwnsMe = new Player();
-        this.nextBowl = new SmallBowl(14, 1, this, this.playerThatOwnsMe.getOpponent());
+        int boardSize = 14;
+
+        this.nextBowl = new SmallBowl(boardSize, --boardSize, this, this.getPlayerThatOwnsMe().getOpponent());
     }
 
-    Kalaha(int startPosition, int addedBowlsCount, Bowl startBowl, Player playerOwningThisSide) {
+    Kalaha(int boardSize, int remainingBowls, Bowl startBowl, Player playerOwningThisSide) {
         this.myRocks = 0;
         this.playerThatOwnsMe = playerOwningThisSide;
-
-        int boardPosition = Bowl.calculateBoardPosition(startPosition, addedBowlsCount);
-
-        if (!(boardPosition == 7 || boardPosition == 14)) {
-            this.nextBowl = null;
-        } else if (addedBowlsCount == 13)
+        if (remainingBowls == 1) {
             this.nextBowl = startBowl;
-        else {
-            this.nextBowl = new SmallBowl(startPosition, ++addedBowlsCount, startBowl, playerOwningThisSide.getOpponent());
+        } else {
+            this.nextBowl = new SmallBowl(boardSize, --remainingBowls, startBowl, playerOwningThisSide.getOpponent());
         }
     }
 
@@ -41,31 +39,21 @@ class Kalaha implements Bowl {
         return this.playerThatOwnsMe;
     }
 
-    private Bowl takeOneAndContinue(int remainingRocks) {
+    @Override
+    public Bowl distribute(int remainingRocks) {
         this.myRocks++;
-        if (remainingRocks == 1)
-            return new Recursive().flipFlopDistributeRock(--remainingRocks, this);
-        else {
-            SmallBowl smallBowl = (SmallBowl) this.getNextBowl();
-            return smallBowl.new Recursive().flipFlopDistributeRock(--remainingRocks, smallBowl);
-        }
-    }
-
-    class Recursive {
-        Bowl flipFlopDistributeRock(int remainingRocks, Kalaha currentBowl) {
-            if (remainingRocks == 0)
-                return currentBowl;
-            else if (!(Kalaha.this.getPlayerThatOwnsMe().hasTheTurn())) {
-                SmallBowl smallBowl = (SmallBowl) currentBowl.getNextBowl();
-                return smallBowl.new Recursive().flipFlopDistributeRock(remainingRocks, smallBowl);
-            } else {
-                return takeOneAndContinue(remainingRocks);
-            }
-
-        }
+        // Skip?
+        if (!getPlayerThatOwnsMe().hasTheTurn()) {
+            this.myRocks--;
+            return getNextBowl().distribute(remainingRocks);
+        } // last ?
+        else if (remainingRocks == 1)
+            return this;
+        else
+            return getNextBowl().distribute(--remainingRocks);
     }
 
     void acceptBooty(int booty) {
-        this.myRocks = this.myRocks + booty;
+        myRocks = myRocks + booty;
     }
 }
diff --git a/domain/src/main/java/mancala/domain/Player.java b/domain/src/main/java/mancala/domain/Player.java
index 9c01cdc..5fd79b3 100644
--- a/domain/src/main/java/mancala/domain/Player.java
+++ b/domain/src/main/java/mancala/domain/Player.java
@@ -44,4 +44,10 @@ public class Player {
     public boolean won() {
         return this.isTheWinner;
     }
+
+    void gotADraw() {
+        this.isTheWinner = true;
+        this.opponent.isTheWinner = true;
+    }
+
 }
diff --git a/domain/src/main/java/mancala/domain/SmallBowl.java b/domain/src/main/java/mancala/domain/SmallBowl.java
index 14a0f71..e6079b8 100644
--- a/domain/src/main/java/mancala/domain/SmallBowl.java
+++ b/domain/src/main/java/mancala/domain/SmallBowl.java
@@ -9,60 +9,30 @@ public class SmallBowl implements Bowl {
     private final Bowl nextBowl;
 
     public SmallBowl() {
-        this(1);
-    }
-
-    public SmallBowl(int position) {
-        // constructs board by recursively calling either kalaha or smallbowl constructors
         this.myRocks = 4;
-        this.playerThatOwnsMe = new Player();
-        if ((0 < position&&position < 6) || (7 < position && position < 13))
-            this.nextBowl = new SmallBowl(position, 1, this, this.playerThatOwnsMe);
-        else if (position == 6 || position == 13)
-            this.nextBowl = new Kalaha(position, 1, this, this.playerThatOwnsMe);
-        // Special cases where smallbowl is on "wrong position"
-        else if (position == 7) {
-            this.nextBowl = new SmallBowl(1, 1, this, this.playerThatOwnsMe);
-        } else if (position == 14) {
-            this.nextBowl = new SmallBowl(8, 1, this, this.playerThatOwnsMe);
-        } else {
-            this.nextBowl = null;
-        }
-    }
 
-    public void play() {
-        if ((!this.playerThatOwnsMe.hasTheTurn()) || (this.myRocks == 0));
-        else {
-
-            Bowl playEndedInThisBowl = new Recursive().flipFlopDistributeRock(this.myRocks, this.getNextBowl());
-            this.myRocks = 0;
+        this.playerThatOwnsMe = new Player();
+        int boardSize = 14;
 
-            if (!(playEndedInThisBowl.getClass() == Kalaha.class)) {
-                this.playerThatOwnsMe.switchTurn();
-            }
+        this.nextBowl = new SmallBowl(boardSize, --boardSize, this, this.getPlayerThatOwnsMe());
+    }
 
-            stealTheBooty(playEndedInThisBowl);
+    SmallBowl(int boardSize, int remainingBowls, Bowl startBowl, Player playerOwningThisSide) {
+        this.myRocks = 4;
+        this.playerThatOwnsMe = playerOwningThisSide;
 
-            endTheGame();
-        }
-    }
+        boolean startingFromKalaha = startBowl.getClass() == Kalaha.class;
+        int startingFromKalahAdjustment = 0;
+        if (startingFromKalaha)
+            startingFromKalahAdjustment = -1;
 
-    public SmallBowl getOpposite() {
-        Bowl kalaha = this.getNextBowl();
-        Recursive recursive = new Recursive();
-        int i = 0;
-        while (kalaha.getClass() != Kalaha.class) {
-            i++;
-            kalaha = kalaha.getNextBowl();
+        if (remainingBowls == 1) {
+            this.nextBowl = startBowl;
+        } else if (remainingBowls == boardSize / 2 + 2 + startingFromKalahAdjustment || (remainingBowls == 2 && !startingFromKalaha)) {
+            this.nextBowl = new Kalaha(boardSize, --remainingBowls, startBowl, playerOwningThisSide);
+        } else {
+            this.nextBowl = new SmallBowl(boardSize, --remainingBowls, startBowl, playerOwningThisSide);
         }
-        return (SmallBowl) recursive.getNextSmallBowl(i, (SmallBowl) kalaha.getNextBowl());
-    }
-
-    public Kalaha getKalaha() {
-        Bowl kalaha = this.getNextBowl();
-        while (kalaha.getClass() != Kalaha.class)
-            kalaha = kalaha.getNextBowl();
-        return (Kalaha) kalaha;
     }
 
     @Override
@@ -75,71 +45,65 @@ public class SmallBowl implements Bowl {
         return nextBowl;
     }
 
-    public SmallBowl getNextSmallBowlRepeat(int i) {
-        Recursive recursive = new Recursive();
-        return recursive.getNextSmallBowl(i, this);
-    }
-
     @Override
     public Player getPlayerThatOwnsMe() {
         return playerThatOwnsMe;
     }
 
-    // Recurses through board positions until connected again to startBowl
-    SmallBowl(int startPosition, int addedBowlsCount, Bowl startBowl, Player playerOwningThisSide) {
-        this.myRocks = 4;
-        this.playerThatOwnsMe = playerOwningThisSide;
+    @Override
+    public Bowl distribute(int remainingRocks) {
+        this.myRocks++;
+        // last?
+        if (remainingRocks == 1)
+            return this;
+        else
+            return this.getNextBowl().distribute(--remainingRocks);
+    }
+
+    public void play() {
+        if ((!this.playerThatOwnsMe.hasTheTurn()) || (this.myRocks == 0));
+        else {
 
-        int boardPosition = Bowl.calculateBoardPosition(startPosition, addedBowlsCount);
+            Bowl lastToReceiveRock = getNextBowl().distribute(myRocks);
+            myRocks = 0;
 
-        if (addedBowlsCount == 13)
-            this.nextBowl = startBowl;
+            if (lastToReceiveRock.getClass() == SmallBowl.class && lastToReceiveRock.getPlayerThatOwnsMe().equals(getPlayerThatOwnsMe())) {
+                stealTheBooty(lastToReceiveRock);
+            }
 
-        else if ((0 < boardPosition && boardPosition < 6) || (7 < boardPosition && boardPosition < 13))
-            this.nextBowl = new SmallBowl(startPosition, ++addedBowlsCount, startBowl, playerOwningThisSide);
+            if (!(lastToReceiveRock.getClass() == Kalaha.class)) {
+                this.playerThatOwnsMe.switchTurn();
+            }
 
-        else if (boardPosition == 6 || boardPosition == 13)
-            this.nextBowl = new Kalaha(startPosition, ++addedBowlsCount, startBowl, playerOwningThisSide);
+            endTheGame();
 
-        else
-            this.nextBowl = null;
+        }
     }
 
-    class Recursive {
-        Bowl flipFlopDistributeRock(int remainingRocks, Bowl currentBowl) {
-            if (remainingRocks == 0)
-                return currentBowl;
-            else if (currentBowl.getClass() == Kalaha.class) {
-                Kalaha tmpKalaha = (Kalaha) currentBowl;
-                return tmpKalaha.new Recursive().flipFlopDistributeRock(remainingRocks, tmpKalaha);
-            } else {
-                SmallBowl tmpSmallBowl = (SmallBowl) currentBowl;
-                return tmpSmallBowl.takeOneAndContinue(remainingRocks);
-            }
-        }
+    SmallBowl getOpposite() {
+        SmallBowl opponentFirst = (SmallBowl) getKalaha().getNextBowl();
+        return opponentFirst.getNextSmallBowlTimes(countSmallBowlsUntilKalahaFromHere());
+    }
 
-        SmallBowl getNextSmallBowl(int remainingNexts, Bowl currentBowl) {
-            if (remainingNexts > 0)
-                return getNextSmallBowl(--remainingNexts, currentBowl.getNextBowl());
-            else if (currentBowl.getClass() == Kalaha.class)
-                return getNextSmallBowl(remainingNexts, currentBowl.getNextBowl());
-            else
-                return (SmallBowl) currentBowl;
 
-        }
+    Kalaha getKalaha() {
+        if (!(getNextBowl().getClass() == Kalaha.class)) {
+            SmallBowl notKalaha = (SmallBowl) getNextBowl();
+            return notKalaha.getKalaha();
+        } else
+            return (Kalaha) getNextBowl();
     }
 
-    private Bowl takeOneAndContinue(int remainingRocks) {
-        this.myRocks++;
-        if (remainingRocks == 1)
-            return new Recursive().flipFlopDistributeRock(--remainingRocks, this);
-        else
-            return new Recursive().flipFlopDistributeRock(--remainingRocks, this.getNextBowl());
+    public SmallBowl getNextSmallBowlTimes(int remainingNexts) {
+        if (remainingNexts == 0)
+            return this;
+        else {
+            SmallBowl next = getNextSmallBowl();
+            return next.getNextSmallBowlTimes(--remainingNexts);
+        }
     }
 
     private void stealTheBooty(Bowl playEndedInThisBowl) {
-        if (playEndedInThisBowl.getClass() == SmallBowl.class&&playEndedInThisBowl.getPlayerThatOwnsMe().equals(this.getPlayerThatOwnsMe())) {
-
             SmallBowl playEndSmallBowl = (SmallBowl) playEndedInThisBowl;
             SmallBowl opposite = playEndSmallBowl.getOpposite();
             int booty;
@@ -148,39 +112,48 @@ public class SmallBowl implements Bowl {
                 booty++;
                 playEndSmallBowl.myRocks = 0;
                 opposite.myRocks = 0;
-                this.getKalaha().acceptBooty(booty);
+                getKalaha().acceptBooty(booty);
             }
-        }
     }
 
     private void endTheGame() {
-        int playerRocks = 0;
-        int opponentRocks = 0;
-        int playerKalaha = 0;
-        int opponentKalaha = 0;
-        Bowl current = this;
-        for (int i = 0; i < 14; i++) {
-            if (current.getPlayerThatOwnsMe().equals(this.getPlayerThatOwnsMe())) {
-                if (current.getClass() == Kalaha.class)
-                    playerKalaha = playerKalaha + current.getMyRocks();
-                else
-                    playerRocks = playerRocks + current.getMyRocks();
-            } else {
-                if (current.getClass() == Kalaha.class)
-                    opponentKalaha = opponentKalaha + current.getMyRocks();
-                else
-                    opponentRocks = opponentRocks + current.getMyRocks();
-            }
-            current = current.getNextBowl();
-        }
+        SmallBowl firstBowlPlayer = (SmallBowl) getOpposite().getKalaha().getNextBowl();
+        int playerRocks = firstBowlPlayer.countRocksTillDifferentPlayer();
+
+        SmallBowl firstBowlOpponent = (SmallBowl) getKalaha().getNextBowl();
+        int opponentRocks = firstBowlOpponent.countRocksTillDifferentPlayer();
 
+        int playerKalaha = getKalaha().getMyRocks();
+        int opponentKalaha = getOpposite().getKalaha().getMyRocks();
 
         if (playerRocks == 0) {
-            System.out.println("Final score:\n\t ending player: " + (playerRocks + playerKalaha) + "\n\t his opponent: " + (opponentRocks + opponentKalaha));
-            if ((playerRocks + playerKalaha) > (opponentRocks + opponentKalaha)) {
-                this.getPlayerThatOwnsMe().isTheWinner();
-            } else
-                this.getPlayerThatOwnsMe().getOpponent().isTheWinner();
+            if ((playerRocks + playerKalaha) == (opponentRocks + opponentKalaha))
+                getPlayerThatOwnsMe().gotADraw();
+            else if ((playerRocks + playerKalaha) > (opponentRocks + opponentKalaha))
+                getPlayerThatOwnsMe().isTheWinner();
+            else
+                getPlayerThatOwnsMe().getOpponent().isTheWinner();
         }
     }
+
+    private int countRocksTillDifferentPlayer() {
+        if (getNextSmallBowl().getPlayerThatOwnsMe().equals(getPlayerThatOwnsMe()))
+            return this.myRocks + getNextSmallBowl().countRocksTillDifferentPlayer();
+        else
+            return this.myRocks;
+    }
+
+    private SmallBowl getNextSmallBowl() {
+        if (getNextBowl().getClass() == Kalaha.class)
+            return (SmallBowl) getNextBowl().getNextBowl();
+        else
+            return (SmallBowl) getNextBowl();
+    }
+
+    private int countSmallBowlsUntilKalahaFromHere() {
+        if (getNextBowl().getClass() == Kalaha.class)
+            return 0;
+        else
+            return 1 + getNextSmallBowl().countSmallBowlsUntilKalahaFromHere();
+    }
 }
\ No newline at end of file
diff --git a/domain/src/test/java/mancala/domain/BowlTest.java b/domain/src/test/java/mancala/domain/BowlTest.java
index 162b08d..aa40640 100644
--- a/domain/src/test/java/mancala/domain/BowlTest.java
+++ b/domain/src/test/java/mancala/domain/BowlTest.java
@@ -10,8 +10,6 @@ package mancala.domain;
 // and a set of assertions.
 
 import org.junit.jupiter.api.*;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.ValueSource;
 
 import static org.junit.jupiter.api.Assertions.*;
 
@@ -26,7 +24,6 @@ class BowlTest {
         int traversedCount = 0;
         int currentPosition = 0;
         for (int i = 0; i < 14; i++) {
-
             if ((position + traversedCount) > 14) {
                 // if looping around the board, position = ((start+traversed) - total)
                 // in other words the amount of bowls that the absolute position is greater than the board's total bowls
@@ -58,14 +55,15 @@ class BowlTest {
         @BeforeEach
         public void makeASmallBowlInMancala() {
             firstSmallBowlPlayer = new SmallBowl();
+            traverseAndCheckBoard(firstSmallBowlPlayer, 1);
         }
 
-        @ParameterizedTest
-        @ValueSource(ints = {1,2,3,4,5,6,8,9,10,11,12,13})
-        public void GIVEN_always_WHEN_created_THEN_it_exists_in_a_mancala_board(int position) {
-            traverseAndCheckBoard(new SmallBowl(position), position);
-            traverseAndCheckBoard(new SmallBowl(), 1);
-        }
+        // @ParameterizedTest
+        // @ValueSource(ints = {1,2,3,4,5,6,8,9,10,11,12,13})
+        // public void GIVEN_always_WHEN_created_THEN_it_exists_in_a_mancala_board(int position) {
+        //     traverseAndCheckBoard(new SmallBowl(position), position);
+        //     traverseAndCheckBoard(new SmallBowl(), 1);
+        // }
 
         @Nested
         class GIVEN_its_the_start_of_the_game {
@@ -110,9 +108,9 @@ class BowlTest {
             @Test
             public void play_can_reach_opponents_kalaha_WHEN_played_by_the_player_THEN_opponents_kalaha_is_skipped() {
                 SmallBowl playWillSkipFromThisBowl = goToSkippableState();
-                int opponentKalahaRocksBefore = firstSmallBowlPlayer.getNextSmallBowlRepeat(6).getKalaha().getMyRocks();
+                int opponentKalahaRocksBefore = firstSmallBowlPlayer.getNextSmallBowlTimes(6).getKalaha().getMyRocks();
                 playWillSkipFromThisBowl.play();
-                int opponentKalahaRocksAfter = firstSmallBowlPlayer.getNextSmallBowlRepeat(6).getKalaha().getMyRocks();
+                int opponentKalahaRocksAfter = firstSmallBowlPlayer.getNextSmallBowlTimes(6).getKalaha().getMyRocks();
                 assertEquals(opponentKalahaRocksBefore, opponentKalahaRocksAfter);
             }
 
@@ -129,7 +127,7 @@ class BowlTest {
             @Test
             public void all_small_bowls_of_the_player_are_empty_WHEN_a_play_ends_THEN_tell_players_who_won() {
                 Player player = firstSmallBowlPlayer.getPlayerThatOwnsMe();
-                Player opponent = firstSmallBowlPlayer.getNextSmallBowlRepeat(6).getPlayerThatOwnsMe();
+                Player opponent = firstSmallBowlPlayer.getNextSmallBowlTimes(6).getPlayerThatOwnsMe();
                 assertFalse(player.won());
                 assertFalse(opponent.won());
                 goToEndOfSillyGame();
@@ -141,56 +139,57 @@ class BowlTest {
             @Test
             public void all_small_bowls_of_the_player_are_empty_WHEN_a_play_ends_THEN_tell_players_who_wonOPPONENTVARIATION() {
                 Player player = firstSmallBowlPlayer.getPlayerThatOwnsMe();
-                Player opponent = firstSmallBowlPlayer.getNextSmallBowlRepeat(6).getPlayerThatOwnsMe();
+                Player opponent = firstSmallBowlPlayer.getNextSmallBowlTimes(6).getPlayerThatOwnsMe();
                 goToEndOfGameWhereOpponentWins();
                 assertFalse(player.won());
                 assertTrue(opponent.won());
             }
 
             private void goToEndOfGameWhereOpponentWins() {
-                SmallBowl firstSmallBowlOpponent = firstSmallBowlPlayer.getNextSmallBowlRepeat(6);
-                firstSmallBowlPlayer.getNextSmallBowlRepeat(1).play();
-                firstSmallBowlOpponent.getNextSmallBowlRepeat(2).play();
-                firstSmallBowlOpponent.getNextSmallBowlRepeat(5).play();
-                firstSmallBowlPlayer.getNextSmallBowlRepeat(1).play();
-                firstSmallBowlOpponent.getNextSmallBowlRepeat(1).play();
-                firstSmallBowlPlayer.getNextSmallBowlRepeat(2).play();
+                SmallBowl firstSmallBowlOpponent = firstSmallBowlPlayer.getNextSmallBowlTimes(6);
+                firstSmallBowlPlayer.getNextSmallBowlTimes(1).play();
+                firstSmallBowlOpponent.getNextSmallBowlTimes(2).play();
+                firstSmallBowlOpponent.getNextSmallBowlTimes(5).play();
+                firstSmallBowlPlayer.getNextSmallBowlTimes(1).play();
+                firstSmallBowlOpponent.getNextSmallBowlTimes(1).play();
+                firstSmallBowlPlayer.getNextSmallBowlTimes(2).play();
                 firstSmallBowlOpponent.play();
-                firstSmallBowlPlayer.getNextSmallBowlRepeat(3).play();
-                firstSmallBowlOpponent.getNextSmallBowlRepeat(1).play();
-                firstSmallBowlPlayer.getNextSmallBowlRepeat(4).play();
+                firstSmallBowlPlayer.getNextSmallBowlTimes(3).play();
+                firstSmallBowlOpponent.getNextSmallBowlTimes(1).play();
+                firstSmallBowlPlayer.getNextSmallBowlTimes(4).play();
                 firstSmallBowlOpponent.play();
                 // Cheating here, let player go again >:), i'm too dumb too make a loop/skip and steal play happen in fair game
                 firstSmallBowlOpponent.getPlayerThatOwnsMe().switchTurn();
                 // Should skip and steal
                 // this bowls rocks
-                assertEquals(10, firstSmallBowlOpponent.getNextSmallBowlRepeat(3).getMyRocks());
+                assertEquals(10, firstSmallBowlOpponent.getNextSmallBowlTimes(3).getMyRocks());
                 // End up here by looping around the board, thus skipping
                 assertEquals(0, firstSmallBowlOpponent.getMyRocks());
                 // Thus steal from last bowl on players side
-                assertEquals(8, firstSmallBowlPlayer.getNextSmallBowlRepeat(5).getMyRocks());
+                assertEquals(8, firstSmallBowlPlayer.getNextSmallBowlTimes(5).getMyRocks());
                 // Result is big kalaha booty
                 assertEquals(8, firstSmallBowlOpponent.getKalaha().getMyRocks());
-                firstSmallBowlOpponent.getNextSmallBowlRepeat(3).play();
+                assertEquals(3, firstSmallBowlPlayer.getKalaha().getMyRocks());
+                firstSmallBowlOpponent.getNextSmallBowlTimes(3).play();
                 assertEquals(19, firstSmallBowlOpponent.getKalaha().getMyRocks());
-                firstSmallBowlPlayer.getNextSmallBowlRepeat(1).play();
-                firstSmallBowlOpponent.getNextSmallBowlRepeat(1).play();
+                firstSmallBowlPlayer.getNextSmallBowlTimes(1).play();
+                firstSmallBowlOpponent.getNextSmallBowlTimes(1).play();
                 firstSmallBowlPlayer.play();
                 firstSmallBowlPlayer.getPlayerThatOwnsMe().switchTurn();
-                firstSmallBowlPlayer.getNextSmallBowlRepeat(3).play();
+                firstSmallBowlPlayer.getNextSmallBowlTimes(3).play();
                 firstSmallBowlPlayer.getPlayerThatOwnsMe().switchTurn();
-                firstSmallBowlPlayer.getNextSmallBowlRepeat(4).play();
-                firstSmallBowlPlayer.getNextSmallBowlRepeat(5).play();
+                firstSmallBowlPlayer.getNextSmallBowlTimes(4).play();
+                firstSmallBowlPlayer.getNextSmallBowlTimes(5).play();
             }
 
             private void goToEndOfSillyGame() {
-                SmallBowl firstSmallBowlOpponent = firstSmallBowlPlayer.getNextSmallBowlRepeat(6);
+                SmallBowl firstSmallBowlOpponent = firstSmallBowlPlayer.getNextSmallBowlTimes(6);
 
                 // player
                 // Best opening
-                firstSmallBowlPlayer.getNextSmallBowlRepeat(2).play();
+                firstSmallBowlPlayer.getNextSmallBowlTimes(2).play();
                 // Set up for steal move
-                firstSmallBowlPlayer.getNextSmallBowlRepeat(4).play();
+                firstSmallBowlPlayer.getNextSmallBowlTimes(4).play();
                 assertEquals(2, firstSmallBowlPlayer.getKalaha().getMyRocks());
 
                 // opponent
@@ -201,21 +200,21 @@ class BowlTest {
                 firstSmallBowlPlayer.play();
                 // Check if i did it properly on paper
                 assertEquals(9, firstSmallBowlPlayer.getKalaha().getMyRocks());
-                assertEquals(0, firstSmallBowlPlayer.getNextSmallBowlRepeat(4).getMyRocks());
-                assertEquals(0, firstSmallBowlPlayer.getNextSmallBowlRepeat(4).getOpposite().getMyRocks());
+                assertEquals(0, firstSmallBowlPlayer.getNextSmallBowlTimes(4).getMyRocks());
+                assertEquals(0, firstSmallBowlPlayer.getNextSmallBowlTimes(4).getOpposite().getMyRocks());
 
                 // opponent
-                firstSmallBowlOpponent.getNextSmallBowlRepeat(3).play();
+                firstSmallBowlOpponent.getNextSmallBowlTimes(3).play();
 
                 //Player
-                firstSmallBowlPlayer.getNextSmallBowlRepeat(3).play();
+                firstSmallBowlPlayer.getNextSmallBowlTimes(3).play();
                 assertEquals(10, firstSmallBowlPlayer.getKalaha().getMyRocks());
 
                 // opponent makes stupid move again
-                firstSmallBowlOpponent.getNextSmallBowlRepeat(1).play();
+                firstSmallBowlOpponent.getNextSmallBowlTimes(1).play();
 
                 // player makes big steal
-                firstSmallBowlPlayer.getNextSmallBowlRepeat(2).play();
+                firstSmallBowlPlayer.getNextSmallBowlTimes(2).play();
                 assertEquals(19, firstSmallBowlPlayer.getKalaha().getMyRocks());
 
                 // opponent steals tiny booty
@@ -226,36 +225,36 @@ class BowlTest {
                 firstSmallBowlPlayer.play();
 
                 // opponent is heading for disaster
-                firstSmallBowlOpponent.getNextSmallBowlRepeat(5).play();
+                firstSmallBowlOpponent.getNextSmallBowlTimes(5).play();
                 firstSmallBowlPlayer.play();
-                firstSmallBowlOpponent.getNextSmallBowlRepeat(4).play();
+                firstSmallBowlOpponent.getNextSmallBowlTimes(4).play();
                 firstSmallBowlPlayer.play();
-                firstSmallBowlOpponent.getNextSmallBowlRepeat(5).play();
+                firstSmallBowlOpponent.getNextSmallBowlTimes(5).play();
                 // everything empty!
                 for (int i = 0; i < 6; i++) {
-                    assertEquals(0, firstSmallBowlOpponent.getNextSmallBowlRepeat(i).getMyRocks());
+                    assertEquals(0, firstSmallBowlOpponent.getNextSmallBowlTimes(i).getMyRocks());
                 }
 
             }
 
             private SmallBowl goToSkippableState() {
-                SmallBowl firstSmallBowlOpponent = firstSmallBowlPlayer.getNextSmallBowlRepeat(6);
+                SmallBowl firstSmallBowlOpponent = firstSmallBowlPlayer.getNextSmallBowlTimes(6);
 
-                firstSmallBowlPlayer.getNextSmallBowlRepeat(2).play();
-                firstSmallBowlPlayer.getNextSmallBowlRepeat(3).play();
+                firstSmallBowlPlayer.getNextSmallBowlTimes(2).play();
+                firstSmallBowlPlayer.getNextSmallBowlTimes(3).play();
 
-                firstSmallBowlOpponent.getNextSmallBowlRepeat(2).play();
-                firstSmallBowlOpponent.getNextSmallBowlRepeat(3).play();
+                firstSmallBowlOpponent.getNextSmallBowlTimes(2).play();
+                firstSmallBowlOpponent.getNextSmallBowlTimes(3).play();
 
                 firstSmallBowlPlayer.play();
                 firstSmallBowlOpponent.play();
 
-                firstSmallBowlPlayer.getNextSmallBowlRepeat(4).play();
-                firstSmallBowlOpponent.getNextSmallBowlRepeat(4).play();
+                firstSmallBowlPlayer.getNextSmallBowlTimes(4).play();
+                firstSmallBowlOpponent.getNextSmallBowlTimes(4).play();
 
                 // Playing this bowl should give a skip!
-                assertTrue(firstSmallBowlPlayer.getNextSmallBowlRepeat(5).getMyRocks() >= 8);
-                return firstSmallBowlPlayer.getNextSmallBowlRepeat(5);
+                assertTrue(firstSmallBowlPlayer.getNextSmallBowlTimes(5).getMyRocks() >= 8);
+                return firstSmallBowlPlayer.getNextSmallBowlTimes(5);
             }
         }
 
@@ -264,7 +263,7 @@ class BowlTest {
 
             @Test
             public void in_own_kalaha_WHEN_play_ends_THEN_turn_is_not_switched() {
-                firstSmallBowlPlayer.getNextSmallBowlRepeat(2).play();
+                firstSmallBowlPlayer.getNextSmallBowlTimes(2).play();
                 assertTrue(firstSmallBowlPlayer.getPlayerThatOwnsMe().hasTheTurn());
             }
 
@@ -276,15 +275,15 @@ class BowlTest {
 
             @Test
             public void in_opponents_small_bowl_WHEN_player_plays_this_bowl_THEN_turn_is_switched() {
-                firstSmallBowlPlayer.getNextSmallBowlRepeat(5).play();
+                firstSmallBowlPlayer.getNextSmallBowlTimes(5).play();
                 assertFalse(firstSmallBowlPlayer.getPlayerThatOwnsMe().hasTheTurn());
             }
 
             @Test
             public void in_own_empty_small_bowl_and_opposite_has_rocks_WHEN_play_ends_THEN_rocks_of_opposite_plus_last_rock_of_play_are_added_to_kalaha() {
-                firstSmallBowlPlayer.getNextSmallBowlRepeat(5).play();
-                SmallBowl firstSmallBowlOpponent = firstSmallBowlPlayer.getNextSmallBowlRepeat(6);
-                firstSmallBowlOpponent.getNextSmallBowlRepeat(5).play();
+                firstSmallBowlPlayer.getNextSmallBowlTimes(5).play();
+                SmallBowl firstSmallBowlOpponent = firstSmallBowlPlayer.getNextSmallBowlTimes(6);
+                firstSmallBowlOpponent.getNextSmallBowlTimes(5).play();
                 firstSmallBowlPlayer.play();
                 assertEquals(7, firstSmallBowlPlayer.getKalaha().getMyRocks());
             }