no more type casting, polymorphism/abstractmethods

4 files changed, 150 insertions, 168 deletions

diff --git a/domain/src/main/java/mancala/domain/Bowl.java b/domain/src/main/java/mancala/domain/Bowl.java
index b8c4ac4..ade728d 100644
--- a/domain/src/main/java/mancala/domain/Bowl.java
+++ b/domain/src/main/java/mancala/domain/Bowl.java
@@ -1,10 +1,61 @@
 package mancala.domain;
 
-interface Bowl {
+abstract class Bowl {
+    protected int myRocks;
+    protected Player myOwner;
+    protected Bowl nextBowl;
 
-    int getMyRocks();
+    public int getMyRocks() {
+        return myRocks;
+    }
 
-    Bowl getNextBowl();
+    public Bowl getNextBowl() {
+        return nextBowl;
+    }
+
+    public Player getMyOwner() {
+        return myOwner;
+    }
+
+    abstract void distribute(int remainingRocks);
+
+    abstract SmallBowl getOpposite(int i);
+
+    abstract SmallBowl getNextSmallBowlTimes(int i);
+
+    abstract Kalaha getKalaha();
+
+    abstract SmallBowl getSmallBowl();
+
+    // abstract SmallBowl getNextSmallBowl();
+
+    void endTheGame() {
+        getNextBowl().endTheGame(this, 0, 0);
+    }
+
+    abstract boolean isEmpty();
+
+    private void endTheGame(Bowl startOfLoop, int scorePlayer, int scoreOpponent) {
+        if (isEmpty() == false && myOwner.hasTheTurn()) return;
+
+        if (getMyOwner().equals(startOfLoop.getMyOwner())) {
+            scorePlayer = scorePlayer + getMyRocks();
+        } else scoreOpponent = scoreOpponent + getMyRocks();
+
+        if (this.equals(startOfLoop)) {
+
+            int playerKalaha = getKalaha().getMyRocks();
+
+            if (scorePlayer == playerKalaha) {
+
+                if (scorePlayer == scoreOpponent) getMyOwner().gotADraw();
+                else if (scorePlayer > scoreOpponent) getMyOwner().isTheWinner();
+                else getMyOwner().getOpponent().isTheWinner();
+
+            }
+
+
+        } else getNextBowl().endTheGame(startOfLoop, scorePlayer, scoreOpponent);
+    }
 
-    Player getMyOwner();
 }
diff --git a/domain/src/main/java/mancala/domain/Kalaha.java b/domain/src/main/java/mancala/domain/Kalaha.java
index 361ec50..9e70e6c 100644
--- a/domain/src/main/java/mancala/domain/Kalaha.java
+++ b/domain/src/main/java/mancala/domain/Kalaha.java
@@ -1,62 +1,50 @@
 package mancala.domain;
 
-class Kalaha implements Bowl {
-    private int myRocks;
-    private final Player playerThatOwnsMe;
-    private final Bowl nextBowl;
+class Kalaha extends Bowl {
+    Kalaha(int boardSize, int bowlsToAdd, Bowl startBowl, Player playerOwningThisSide) {
+        bowlsToAdd = bowlsToAdd - 1;
 
-    public Kalaha() {
         this.myRocks = 0;
+        this.myOwner = playerOwningThisSide;
 
-        this.playerThatOwnsMe = new Player();
-        int boardSize = 14;
+        if (bowlsToAdd == 0) this.nextBowl = startBowl;
 
-        this.nextBowl = new SmallBowl(boardSize, --boardSize, this, this.getMyOwner().getOpponent());
+        else this.nextBowl = new SmallBowl(boardSize, bowlsToAdd, startBowl, playerOwningThisSide.getOpponent());
     }
 
-    Kalaha(int boardSize, int remainingBowls, Bowl startBowl, Player playerOwningThisSide) {
-        this.myRocks = 0;
-        this.playerThatOwnsMe = playerOwningThisSide;
-
-        // one more connection to make?
-        if (remainingBowls == 1) {
-            this.nextBowl = startBowl;
-        }
-        else {
-            this.nextBowl = new SmallBowl(boardSize, --remainingBowls, startBowl, playerOwningThisSide.getOpponent());
-        }
+    Kalaha getKalaha() {
+        return this;
     }
 
-    @Override
-    public int getMyRocks() {
-        return myRocks;
+    SmallBowl getSmallBowl() {
+        return getNextBowl().getSmallBowl();
     }
 
-    @Override
-    public Bowl getNextBowl() {
-        return nextBowl;
+    SmallBowl getOpposite(int countTillThis) {
+        return getNextBowl().getNextSmallBowlTimes(countTillThis - 1);
     }
 
-    @Override
-    public Player getMyOwner() {
-        return playerThatOwnsMe;
+    SmallBowl getNextSmallBowlTimes(int i) {
+        return getNextBowl().getNextSmallBowlTimes(i);
     }
 
-    Bowl distribute(int remainingRocks) {
+    void distribute(int remainingRocks) {
         myRocks++;
-        SmallBowl next = (SmallBowl) getNextBowl();
         // Skip?
-        if (!getMyOwner().hasTheTurn()) {
+        if (getMyOwner().hasTheTurn() == false) {
             myRocks--;
-            return next.distribute(remainingRocks);
-        }
-        else if (remainingRocks == 1) {
-            return this;
-        } else {
-            return next.distribute(--remainingRocks);
-        }
+            getNextBowl().distribute(remainingRocks);
+        } else if (remainingRocks == 1) {
+            endTheGame();
+        } else getNextBowl().distribute(--remainingRocks);
     }
 
+    @Override
+    boolean isEmpty() {
+        return true;
+    }
+
+
     void claimStolenBooty(int booty) {
         myRocks = myRocks + booty;
     }
diff --git a/domain/src/main/java/mancala/domain/SmallBowl.java b/domain/src/main/java/mancala/domain/SmallBowl.java
index 4488cd1..b5de82f 100644
--- a/domain/src/main/java/mancala/domain/SmallBowl.java
+++ b/domain/src/main/java/mancala/domain/SmallBowl.java
@@ -1,171 +1,107 @@
 package mancala.domain;
 
-public class SmallBowl implements Bowl {
-    private int myRocks;
-    private final Player myOwner;
-    private final Bowl nextBowl;
+public class SmallBowl extends Bowl {
 
     public SmallBowl() {
         this.myRocks = 4;
-
         this.myOwner = new Player();
+
         int boardSize = 14;
+        int bowlsToAdd = boardSize - 1;
 
-        this.nextBowl = new SmallBowl(boardSize, --boardSize, this, this.getMyOwner());
+        this.nextBowl = new SmallBowl(boardSize, bowlsToAdd, this, this.getMyOwner());
     }
 
-    SmallBowl(int boardSize, int remainingBowls, Bowl startBowl, Player playerOwningThisSide) {
+    public SmallBowl(int boardSize) {
         this.myRocks = 4;
+        this.myOwner = new Player();
+        int bowlsToAdd = boardSize - 1;
+        this.nextBowl = new SmallBowl(boardSize, bowlsToAdd, this, this.getMyOwner());
+    }
+
+    SmallBowl(int boardSize, int bowlsToAdd, Bowl startBowl, Player playerOwningThisSide) {
+        bowlsToAdd = bowlsToAdd - 1;
         this.myOwner = playerOwningThisSide;
+        this.myRocks = 4;
 
-        boolean startingFromKalaha = startBowl.getClass() == Kalaha.class;
-        int startingFromKalahaAdjustment = 0;
-        if (startingFromKalaha)
-            startingFromKalahaAdjustment = -1;
-
-        // One more connection to make?
-        if (remainingBowls == 1) {
-            this.nextBowl = startBowl;
-        } // Where are the Kalahas?
-        else if (remainingBowls == boardSize / 2 + 2 + startingFromKalahaAdjustment || (remainingBowls == 2 && !startingFromKalaha)) {
-            this.nextBowl = new Kalaha(boardSize, --remainingBowls, startBowl, playerOwningThisSide);
-        } else {
-            this.nextBowl = new SmallBowl(boardSize, --remainingBowls, startBowl, playerOwningThisSide);
-        }
-    }
+        if (bowlsToAdd == 0) nextBowl = startBowl;
 
-    @Override
-    public int getMyRocks() {
-        return myRocks;
-    }
+        else if (bowlsToAdd == (boardSize / 2) + 1) nextBowl = new Kalaha(boardSize, bowlsToAdd, startBowl, playerOwningThisSide);
 
-    @Override
-    public Bowl getNextBowl() {
-        return nextBowl;
-    }
+        else if (bowlsToAdd == 1) nextBowl = new Kalaha(boardSize, bowlsToAdd, startBowl, playerOwningThisSide);
 
-    @Override
-    public Player getMyOwner() {
-        return myOwner;
+        else nextBowl = new SmallBowl(boardSize, bowlsToAdd, startBowl, playerOwningThisSide);
     }
 
     public SmallBowl getNextSmallBowlTimes(int remainingTimes) {
         if (remainingTimes == 0)
             return this;
         else {
-            return getNextSmallBowl().getNextSmallBowlTimes(--remainingTimes);
+            return getNextBowl().getNextSmallBowlTimes(--remainingTimes);
         }
     }
 
     public void play() {
-        if ((!myOwner.hasTheTurn())) return;
-        if (myRocks == 0) return;
-
-        Bowl lastToReceiveRock;
-        int myRocksBefore = myRocks;
-        // Which distribute method do we need?
-        if (getNextBowl().getClass() == Kalaha.class) {
-            lastToReceiveRock = getNextKalaha().distribute(myRocks);
-        } else {
-            lastToReceiveRock = getNextSmallBowl().distribute(myRocks);
-        }
-        myRocks = (myRocks - myRocksBefore);
+        if (myOwner.hasTheTurn() == false) return;
+        if (isEmpty()) return;
 
-        // Did play end in smallbowl of my player? steal, otherwise do nothing
-        if (lastToReceiveRock.getClass() == SmallBowl.class && lastToReceiveRock.getMyOwner().equals(getMyOwner())) {
-            stealTheBooty((SmallBowl) lastToReceiveRock);
-        }
-
-        // Did play end in Kalaha? do nothing, otherwise switch turn
-        if (!(lastToReceiveRock.getClass() == Kalaha.class)) {
-            getMyOwner().switchTurn();
-        }
+        int passThese = myRocks;
+        myRocks = 0;
+        getNextBowl().distribute(passThese);
+    }
 
-        // Should a player win or is it a draw? tell player he won/ drew, otherwise do nothing
-        endTheGame();
+    @Override
+    boolean isEmpty() {
+        return this.myRocks == 0;
     }
 
-    Bowl distribute(int remainingRocks) {
+    void distribute(int remainingRocks) {
         this.myRocks++;
         // last?
         if (remainingRocks == 1)
-            return this;
+            lastSmallBowl();
         else {
-            if (getNextBowl().getClass() == SmallBowl.class) {
-                return getNextSmallBowl().distribute(--remainingRocks);
-            } else {
-                return getNextKalaha().distribute(--remainingRocks);
-            }
+            getNextBowl().distribute(--remainingRocks);
         }
     }
 
-    private void stealTheBooty(SmallBowl thievingBowl) {
-        SmallBowl victim = thievingBowl.getOpposite();
-        int booty;
-        if (thievingBowl.getMyRocks() == 1 && victim.getMyRocks() != 0) {
-            booty = victim.getMyRocks();
-            booty++;
-            thievingBowl.myRocks = 0;
-            victim.myRocks = 0;
-            getNextKalaha().claimStolenBooty(booty);
-        }
-    }
-
-    private void endTheGame() {
-        SmallBowl firstBowlPlayer = (SmallBowl) getOpposite().getNextKalaha().getNextBowl();
-        int playerRocks = firstBowlPlayer.countRocksInSmallBowlsUntilOpponentBowls();
-
-        if (playerRocks == 0) return;
-
-        SmallBowl firstBowlOpponent = (SmallBowl) getNextKalaha().getNextBowl();
-        int opponentRocks = firstBowlOpponent.countRocksInSmallBowlsUntilOpponentBowls();
+    private void lastSmallBowl() {
+        // Did play end in smallbowl of my player? steal, otherwise do nothing
+        if (getMyOwner().hasTheTurn()) stealTheBooty(false);
 
-        int playerKalaha = getNextKalaha().getMyRocks();
-        int opponentKalaha = getOpposite().getNextKalaha().getMyRocks();
+        getMyOwner().switchTurn();
 
-        if ((playerRocks + playerKalaha) == (opponentRocks + opponentKalaha)) {
-            getMyOwner().gotADraw();
-        } else if ((playerRocks + playerKalaha) > (opponentRocks + opponentKalaha)) {
-            getMyOwner().isTheWinner();
-        } else {
-            getMyOwner().getOpponent().isTheWinner();
-        }
+        endTheGame();
     }
 
-    private SmallBowl getNextSmallBowl() {
-        if (getNextBowl().getClass() == Kalaha.class) {
-            return (SmallBowl) getNextBowl().getNextBowl();
-        } else {
-            return (SmallBowl) getNextBowl();
-        }
+    SmallBowl getSmallBowl() {
+        return this;
     }
 
-    private Kalaha getNextKalaha() {
-        if (!(getNextBowl().getClass() == Kalaha.class)) {
-            return getNextSmallBowl().getNextKalaha();
-        } else {
-            return (Kalaha) getNextBowl();
-        }
+    Kalaha getKalaha() {
+        return getNextBowl().getKalaha();
     }
 
-    private SmallBowl getOpposite() {
-        SmallBowl opponentFirst = (SmallBowl) getNextKalaha().getNextBowl();
-        return opponentFirst.getNextSmallBowlTimes(countStepsToKalaha());
-    }
+    private void stealTheBooty(boolean victim) {
+        if (victim){
+            getOpposite().getKalaha().claimStolenBooty(myRocks);
+            myRocks = 0;
 
-    private int countStepsToKalaha() {
-        if (getNextBowl().getClass() == Kalaha.class) {
-            return 0;
-        } else {
-            return 1 + getNextSmallBowl().countStepsToKalaha();
+        } else if (getMyRocks() == 1 &&
+                getOpposite().getMyRocks() != 0) {
+
+            getKalaha().claimStolenBooty(myRocks);
+            myRocks = 0;
+            getOpposite().stealTheBooty(true);
         }
     }
 
-    private int countRocksInSmallBowlsUntilOpponentBowls() {
-        if (!(getNextSmallBowl().getMyOwner().equals(getMyOwner()))) {
-            return this.myRocks;
-        } else {
-            return this.myRocks + getNextSmallBowl().countRocksInSmallBowlsUntilOpponentBowls();
-        }
+    SmallBowl getOpposite() {
+        return getOpposite(0);
+    }
+
+    SmallBowl getOpposite(int count) {
+        count = count + 1;
+        return getNextBowl().getOpposite(count);
     }
-}
\ 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 1d811e3..530f628 100644
--- a/domain/src/test/java/mancala/domain/BowlTest.java
+++ b/domain/src/test/java/mancala/domain/BowlTest.java
@@ -43,7 +43,7 @@ class BowlTest {
         @BeforeEach
         public void makeASmallBowlInMancala() {
             firstSmallBowlPlayer = new SmallBowl();
-            // traverseAndCheckBoard(firstSmallBowlPlayer, 1);
+            traverseAndCheckBoard(firstSmallBowlPlayer, 1);
         }
 
         @Nested
@@ -185,16 +185,17 @@ class BowlTest {
                 firstSmallBowlPlayer.getNextSmallBowlTimes(2).play();
                 // Set up for steal move
                 firstSmallBowlPlayer.getNextSmallBowlTimes(4).play();
-                assertEquals(2, firstSmallBowlPlayer.getNextSmallBowlTimes(5).getNextBowl().getMyRocks());
+                assertEquals(2, firstSmallBowlPlayer.getKalaha().getMyRocks());
 
                 // opponent
                 // ... worst opening?
                 firstSmallBowlOpponent.play();
 
                 // player
+                assertSame(firstSmallBowlPlayer.getNextSmallBowlTimes(4).getOpposite(), firstSmallBowlPlayer.getKalaha().getNextBowl().getNextBowl());
                 firstSmallBowlPlayer.play();
                 // Check if i did it properly on paper
-                assertEquals(9, firstSmallBowlPlayer.getNextSmallBowlTimes(5).getNextBowl().getMyRocks());
+                assertEquals(9, firstSmallBowlPlayer.getKalaha().getMyRocks());
                 assertEquals(0, firstSmallBowlPlayer.getNextSmallBowlTimes(4).getMyRocks());
                 // assertEquals(0, firstSmallBowlPlayer.getNextSmallBowlTimes(4).getOpposite().getMyRocks());
 
@@ -209,6 +210,8 @@ class BowlTest {
                 firstSmallBowlOpponent.getNextSmallBowlTimes(1).play();
 
                 // player makes big steal
+                //assertEquals(0, firstSmallBowlPlayer.getNextSmallBowlTimes(5).getNextBowl().getMyRocks());
+                assertEquals(10, firstSmallBowlPlayer.getNextSmallBowlTimes(5).getNextBowl().getMyRocks());
                 firstSmallBowlPlayer.getNextSmallBowlTimes(2).play();
                 assertEquals(19, firstSmallBowlPlayer.getNextSmallBowlTimes(5).getNextBowl().getMyRocks());
 
@@ -279,6 +282,8 @@ class BowlTest {
                 firstSmallBowlPlayer.getNextSmallBowlTimes(5).play();
                 SmallBowl firstSmallBowlOpponent = firstSmallBowlPlayer.getNextSmallBowlTimes(6);
                 firstSmallBowlOpponent.getNextSmallBowlTimes(5).play();
+                assertSame(firstSmallBowlPlayer.getNextSmallBowlTimes(1).getOpposite(), firstSmallBowlPlayer.getKalaha().getSmallBowl().getNextSmallBowlTimes(4));
+                // assertSame(firstSmallBowlPlayer.getOpposite(), firstSmallBowlPlayer.getKalaha().getNextSmallBowlTimes(5));
                 firstSmallBowlPlayer.play();
                 assertEquals(7, firstSmallBowlPlayer.getNextSmallBowlTimes(5).getNextBowl().getMyRocks());
             }
@@ -292,16 +297,18 @@ class BowlTest {
     @DisplayNameGeneration(DisplayNameGenerator.ReplaceUnderscores.class)
     class a_kalaha {
 
+        SmallBowl smallBowl;
         Kalaha kalaha;
 
         @BeforeEach
         public void makeKalahaInBoard() {
-            kalaha = new Kalaha();
+            smallBowl = new SmallBowl();
+            kalaha = smallBowl.getNextSmallBowlTimes(6).getKalaha();
         }
 
         @Test
         public void exists_in_a_mancala_board() {
-            // traverseAndCheckBoard(kalaha, 14);
+            traverseAndCheckBoard(kalaha, 14);
         }
 
         @Test