From a15537ec310d8fe6ba458971caa3ec31fe80412e Mon Sep 17 00:00:00 2001 From: Marco de Wild Date: Thu, 14 Jan 2021 14:32:49 +0100 Subject: Added files for interfacing with the domain --- domain/src/main/java/mancala/domain/Mancala.java | 55 ++++++++++++++++++++++ .../main/java/mancala/domain/MancalaException.java | 7 +++ .../src/main/java/mancala/domain/MancalaImpl.java | 34 +++++++++++++ 3 files changed, 96 insertions(+) create mode 100644 domain/src/main/java/mancala/domain/Mancala.java create mode 100644 domain/src/main/java/mancala/domain/MancalaException.java create mode 100644 domain/src/main/java/mancala/domain/MancalaImpl.java (limited to 'domain/src/main/java') diff --git a/domain/src/main/java/mancala/domain/Mancala.java b/domain/src/main/java/mancala/domain/Mancala.java new file mode 100644 index 0000000..b8b8b7b --- /dev/null +++ b/domain/src/main/java/mancala/domain/Mancala.java @@ -0,0 +1,55 @@ +package mancala.domain; + +public interface Mancala { + public static final int NO_PLAYERS = 0; + public static final int PLAYER_ONE = 1; + public static final int PLAYER_TWO = 1; + public static final int BOTH_PLAYERS = 3; + + /** + * Method indicating if the first player has the next turn or not. + * If player 1 is not in turn, then player 2 is in turn. + * @param The player which you want to know the turn for. + * @return True if the first player has the next turn, false if it's the turn of the other player. + */ + boolean isPlayersTurn(int player); + + /** + * Method for playing the specified recess. Index is as specified below: + * + * 12 11 10 9 8 7 + * 13 6 + * 0 1 2 3 4 5 + * + * @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; + + /** + * 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. + */ + int getStonesForPit(int index); + + /** + * Method for retrieving whether the game has ended or not. + * + * @return True is the game has ended otherwise False. + */ + boolean isEndOfGame(); + + /** + * Method for retrieving the player that has won the game. + * + * @return Integer value representing which player(s) (if any) won the game. + */ + int getWinner(); + +} \ No newline at end of file diff --git a/domain/src/main/java/mancala/domain/MancalaException.java b/domain/src/main/java/mancala/domain/MancalaException.java new file mode 100644 index 0000000..783b229 --- /dev/null +++ b/domain/src/main/java/mancala/domain/MancalaException.java @@ -0,0 +1,7 @@ +package mancala.domain; + +public class MancalaException extends Exception { + public MancalaException(String message) { + super(message); + } +} \ No newline at end of file diff --git a/domain/src/main/java/mancala/domain/MancalaImpl.java b/domain/src/main/java/mancala/domain/MancalaImpl.java new file mode 100644 index 0000000..de04c8f --- /dev/null +++ b/domain/src/main/java/mancala/domain/MancalaImpl.java @@ -0,0 +1,34 @@ +package mancala.domain; + +public class MancalaImpl implements Mancala { + public MancalaImpl() { + // Initialize the game here. + } + + @Override + public boolean isPlayersTurn(int player) { + return true; + } + + @Override + public void playPit(int index) throws MancalaException { + // Implement playing a pit. + } + + @Override + public int getStonesForPit(int index) { + // Make a sane implementation. + if((index + 1 % 7) == 0) return 0; + return 4; + } + + @Override + public boolean isEndOfGame() { + return false; + } + + @Override + public int getWinner() { + return Mancala.NO_PLAYERS; + } +} \ No newline at end of file -- cgit v1.2.3 From 77d64a8bcac263c4f399a6c05fb9efc1aa45071a Mon Sep 17 00:00:00 2001 From: Stijn Linderman Date: Mon, 12 Apr 2021 14:59:44 +0000 Subject: Update Mancala.java --- domain/src/main/java/mancala/domain/Mancala.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'domain/src/main/java') diff --git a/domain/src/main/java/mancala/domain/Mancala.java b/domain/src/main/java/mancala/domain/Mancala.java index b8b8b7b..f8a2621 100644 --- a/domain/src/main/java/mancala/domain/Mancala.java +++ b/domain/src/main/java/mancala/domain/Mancala.java @@ -3,7 +3,7 @@ package mancala.domain; public interface Mancala { public static final int NO_PLAYERS = 0; public static final int PLAYER_ONE = 1; - public static final int PLAYER_TWO = 1; + public static final int PLAYER_TWO = 2; public static final int BOTH_PLAYERS = 3; /** @@ -52,4 +52,4 @@ public interface Mancala { */ int getWinner(); -} \ No newline at end of file +} -- cgit v1.2.3 From 653764b4fcd3fd951cb1ca7b7993a1736fd9dda6 Mon Sep 17 00:00:00 2001 From: Mike Vink Date: Mon, 21 Jun 2021 18:13:31 +0200 Subject: merge mainline domain with mvcFeature domain --- domain/src/main/java/mancala/domain/Bowl.java | 61 +++++++++++ domain/src/main/java/mancala/domain/Kalaha.java | 51 +++++++++ domain/src/main/java/mancala/domain/Player.java | 52 ++++++++++ domain/src/main/java/mancala/domain/SmallBowl.java | 114 +++++++++++++++++++++ 4 files changed, 278 insertions(+) create mode 100644 domain/src/main/java/mancala/domain/Bowl.java create mode 100644 domain/src/main/java/mancala/domain/Kalaha.java create mode 100644 domain/src/main/java/mancala/domain/Player.java create mode 100644 domain/src/main/java/mancala/domain/SmallBowl.java (limited to 'domain/src/main/java') diff --git a/domain/src/main/java/mancala/domain/Bowl.java b/domain/src/main/java/mancala/domain/Bowl.java new file mode 100644 index 0000000..ade728d --- /dev/null +++ b/domain/src/main/java/mancala/domain/Bowl.java @@ -0,0 +1,61 @@ +package mancala.domain; + +abstract class Bowl { + protected int myRocks; + protected Player myOwner; + protected Bowl nextBowl; + + public int getMyRocks() { + return myRocks; + } + + 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); + } + +} diff --git a/domain/src/main/java/mancala/domain/Kalaha.java b/domain/src/main/java/mancala/domain/Kalaha.java new file mode 100644 index 0000000..9e70e6c --- /dev/null +++ b/domain/src/main/java/mancala/domain/Kalaha.java @@ -0,0 +1,51 @@ +package mancala.domain; + +class Kalaha extends Bowl { + Kalaha(int boardSize, int bowlsToAdd, Bowl startBowl, Player playerOwningThisSide) { + bowlsToAdd = bowlsToAdd - 1; + + this.myRocks = 0; + this.myOwner = playerOwningThisSide; + + if (bowlsToAdd == 0) this.nextBowl = startBowl; + + else this.nextBowl = new SmallBowl(boardSize, bowlsToAdd, startBowl, playerOwningThisSide.getOpponent()); + } + + Kalaha getKalaha() { + return this; + } + + SmallBowl getSmallBowl() { + return getNextBowl().getSmallBowl(); + } + + SmallBowl getOpposite(int countTillThis) { + return getNextBowl().getNextSmallBowlTimes(countTillThis - 1); + } + + SmallBowl getNextSmallBowlTimes(int i) { + return getNextBowl().getNextSmallBowlTimes(i); + } + + void distribute(int remainingRocks) { + myRocks++; + // Skip? + if (getMyOwner().hasTheTurn() == false) { + myRocks--; + 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/Player.java b/domain/src/main/java/mancala/domain/Player.java new file mode 100644 index 0000000..1eef716 --- /dev/null +++ b/domain/src/main/java/mancala/domain/Player.java @@ -0,0 +1,52 @@ +package mancala.domain; + +public class Player { + private boolean hasTheTurn; + private boolean isTheWinner; + final private Player opponent; + + public Player() { + this.hasTheTurn = true; + + this.opponent = new Player(this); + } + + private Player(Player opponent) { + this.hasTheTurn = false; + + this.opponent = opponent; + } + + public Player getOpponent() { + return opponent; + } + + public boolean hasTheTurn() { + return hasTheTurn; + } + + public void switchTurn() { + if (this.hasTheTurn == true) { + this.hasTheTurn = false; + this.opponent.hasTheTurn = true; + } else { + this.hasTheTurn = true; + this.opponent.hasTheTurn = false; + } + } + + public boolean won() { + return this.isTheWinner; + } + + void isTheWinner() { + this.isTheWinner = true; + this.opponent.isTheWinner = false; + } + + 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 new file mode 100644 index 0000000..5c97d72 --- /dev/null +++ b/domain/src/main/java/mancala/domain/SmallBowl.java @@ -0,0 +1,114 @@ +package mancala.domain; + +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, bowlsToAdd, this, this.getMyOwner()); + } + + public SmallBowl(int boardSize) { + try { + if (boardSize < 4) { + throw new Exception("Can't have a board smaller than four bowls."); + } + } catch (Exception e) { + e.printStackTrace(); + } + 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; + + if (bowlsToAdd == 0) nextBowl = startBowl; + + else if (bowlsToAdd == (boardSize / 2) + 1) nextBowl = new Kalaha(boardSize, bowlsToAdd, startBowl, playerOwningThisSide); + + else if (bowlsToAdd == 1) nextBowl = new Kalaha(boardSize, bowlsToAdd, startBowl, playerOwningThisSide); + + else nextBowl = new SmallBowl(boardSize, bowlsToAdd, startBowl, playerOwningThisSide); + } + + public SmallBowl getNextSmallBowlTimes(int remainingTimes) { + if (remainingTimes == 0) + return this; + else { + return getNextBowl().getNextSmallBowlTimes(--remainingTimes); + } + } + + public void play() { + if (myOwner.hasTheTurn() == false) return; + if (isEmpty()) return; + + int passThese = myRocks; + myRocks = 0; + getNextBowl().distribute(passThese); + } + + @Override + boolean isEmpty() { + return this.myRocks == 0; + } + + void distribute(int remainingRocks) { + this.myRocks++; + // last? + if (remainingRocks == 1) + lastSmallBowl(); + else { + getNextBowl().distribute(--remainingRocks); + } + } + + private void lastSmallBowl() { + // Did play end in smallbowl of my player? steal, otherwise do nothing + if (getMyOwner().hasTheTurn()) stealTheBooty(false); + + getMyOwner().switchTurn(); + + endTheGame(); + } + + SmallBowl getSmallBowl() { + return this; + } + + Kalaha getKalaha() { + return getNextBowl().getKalaha(); + } + + private void stealTheBooty(boolean victim) { + if (victim){ + getOpposite().getKalaha().claimStolenBooty(myRocks); + myRocks = 0; + + } else if (getMyRocks() == 1 && + getOpposite().getMyRocks() != 0) { + + getKalaha().claimStolenBooty(myRocks); + myRocks = 0; + getOpposite().stealTheBooty(true); + } + } + + SmallBowl getOpposite() { + return getOpposite(0); + } + + SmallBowl getOpposite(int count) { + count = count + 1; + return getNextBowl().getOpposite(count); + } +} -- cgit v1.2.3 From 431af32d73a37887fa7d35f371a21260f5e93949 Mon Sep 17 00:00:00 2001 From: Mike Vink Date: Tue, 22 Jun 2021 15:33:33 +0200 Subject: refactoring endgame --- domain/src/main/java/mancala/domain/Bowl.java | 21 ++++--- domain/src/main/java/mancala/domain/Foo.java | 11 ---- domain/src/main/java/mancala/domain/Kalaha.java | 9 +++ .../src/main/java/mancala/domain/MancalaImpl.java | 66 ++++++++++++++++++++-- domain/src/main/java/mancala/domain/SmallBowl.java | 13 ++++- 5 files changed, 92 insertions(+), 28 deletions(-) delete mode 100644 domain/src/main/java/mancala/domain/Foo.java (limited to 'domain/src/main/java') diff --git a/domain/src/main/java/mancala/domain/Bowl.java b/domain/src/main/java/mancala/domain/Bowl.java index ade728d..a7a2e78 100644 --- a/domain/src/main/java/mancala/domain/Bowl.java +++ b/domain/src/main/java/mancala/domain/Bowl.java @@ -5,7 +5,7 @@ abstract class Bowl { protected Player myOwner; protected Bowl nextBowl; - public int getMyRocks() { + public int getMyStones() { return myRocks; } @@ -27,24 +27,25 @@ abstract class Bowl { abstract SmallBowl getSmallBowl(); + abstract SmallBowl goToFirstBowlOfPlayerWithTurn(); + + abstract boolean isEmpty(); // abstract SmallBowl getNextSmallBowl(); void endTheGame() { - getNextBowl().endTheGame(this, 0, 0); + goToFirstBowlOfPlayerWithTurn().getNextBowl().endTheGame(goToFirstBowlOfPlayerWithTurn(), 0, 0); } - abstract boolean isEmpty(); - - private void endTheGame(Bowl startOfLoop, int scorePlayer, int scoreOpponent) { - if (isEmpty() == false && myOwner.hasTheTurn()) return; + protected void endTheGame(Bowl startOfLoop, int scorePlayer, int scoreOpponent) { + if (isEmpty() == false) return; if (getMyOwner().equals(startOfLoop.getMyOwner())) { - scorePlayer = scorePlayer + getMyRocks(); - } else scoreOpponent = scoreOpponent + getMyRocks(); + scorePlayer = scorePlayer + getMyStones(); + } else scoreOpponent = scoreOpponent + getMyStones(); if (this.equals(startOfLoop)) { - int playerKalaha = getKalaha().getMyRocks(); + int playerKalaha = getKalaha().getMyStones(); if (scorePlayer == playerKalaha) { @@ -58,4 +59,6 @@ abstract class Bowl { } else getNextBowl().endTheGame(startOfLoop, scorePlayer, scoreOpponent); } + + } diff --git a/domain/src/main/java/mancala/domain/Foo.java b/domain/src/main/java/mancala/domain/Foo.java deleted file mode 100644 index bcce6fa..0000000 --- a/domain/src/main/java/mancala/domain/Foo.java +++ /dev/null @@ -1,11 +0,0 @@ -package mancala.domain; - -// Make your own mancala implementation using your design. -// You can take this stub as an example how to make a -// class inside a package and how to test it. -public class Foo { - - public int theAnswerToLifeTheUniverseAndEverything() { - return 41; - } -} \ No newline at end of file diff --git a/domain/src/main/java/mancala/domain/Kalaha.java b/domain/src/main/java/mancala/domain/Kalaha.java index 9e70e6c..7ab954c 100644 --- a/domain/src/main/java/mancala/domain/Kalaha.java +++ b/domain/src/main/java/mancala/domain/Kalaha.java @@ -20,6 +20,15 @@ class Kalaha extends Bowl { return getNextBowl().getSmallBowl(); } + @Override + SmallBowl goToFirstBowlOfPlayerWithTurn() { + if (getMyOwner().hasTheTurn()) { + return getNextBowl().getKalaha().getSmallBowl(); + } else { + return getSmallBowl(); + } + } + SmallBowl getOpposite(int countTillThis) { return getNextBowl().getNextSmallBowlTimes(countTillThis - 1); } diff --git a/domain/src/main/java/mancala/domain/MancalaImpl.java b/domain/src/main/java/mancala/domain/MancalaImpl.java index de04c8f..81dbbe8 100644 --- a/domain/src/main/java/mancala/domain/MancalaImpl.java +++ b/domain/src/main/java/mancala/domain/MancalaImpl.java @@ -1,29 +1,83 @@ package mancala.domain; +import java.util.HashSet; +import java.util.stream.Collectors; +import java.util.stream.IntStream; + public class MancalaImpl implements Mancala { + + public static HashSet PLAYER_ONE_PITS = new HashSet<>( + IntStream.rangeClosed(0, 5).boxed().collect(Collectors.toList()) + ); + public static HashSet PLAYER_TWO_PITS = new HashSet<>( + IntStream.rangeClosed(7, 12).boxed().collect(Collectors.toList()) + ); + public static int PLAYER_ONE_KALAHA = 6; + public static int PLAYER_TWO_KALAHA = 13; + + private SmallBowl domainReference; + public MancalaImpl() { - // Initialize the game here. + domainReference = new SmallBowl(); } @Override public boolean isPlayersTurn(int player) { - return true; + switch (player) { + case Mancala.PLAYER_ONE: + return domainReference.getMyOwner().hasTheTurn(); + case Mancala.PLAYER_TWO: + return domainReference.getMyOwner().getOpponent().hasTheTurn(); + default: + return false; + } } @Override public void playPit(int index) throws MancalaException { - // Implement playing a pit. + if (isPlayersTurn(Mancala.PLAYER_ONE) && MancalaImpl.PLAYER_TWO_PITS.contains(index)) { + throw new MancalaException("Player one cannot play player two's pits."); + } + if (isPlayersTurn(Mancala.PLAYER_TWO) && MancalaImpl.PLAYER_ONE_PITS.contains(index)) { + throw new MancalaException("Player two cannot play player one's pits."); + } + if (index == MancalaImpl.PLAYER_ONE_KALAHA || index == MancalaImpl.PLAYER_TWO_KALAHA) { + throw new MancalaException("A kalaha can never be played!"); + } + if (getStonesForPit(index) == 0) { + throw new MancalaException("The pit was empty when played!"); + } + + if (isPlayersTurn(Mancala.PLAYER_ONE)) { + domainReference.getNextSmallBowlTimes(index).play(); + } else { + int skipKalahaIndex = index - 1; + domainReference.getNextSmallBowlTimes(skipKalahaIndex).play(); + } + } @Override public int getStonesForPit(int index) { - // Make a sane implementation. - if((index + 1 % 7) == 0) return 0; - return 4; + if (MancalaImpl.PLAYER_ONE_PITS.contains(index)) { + return domainReference.getNextSmallBowlTimes(index).getMyStones(); + } + else if (MancalaImpl.PLAYER_TWO_PITS.contains(index)) { + return domainReference.getNextSmallBowlTimes(--index).getMyStones(); + } + else if (index == MancalaImpl.PLAYER_ONE_KALAHA) { + return domainReference.getKalaha().getMyStones(); + } + else if (index == MancalaImpl.PLAYER_TWO_KALAHA) { + return domainReference.getKalaha().getNextBowl().getKalaha().getMyStones(); + } + else + return -1; } @Override public boolean isEndOfGame() { + //domainReference.endTheGame(); return false; } diff --git a/domain/src/main/java/mancala/domain/SmallBowl.java b/domain/src/main/java/mancala/domain/SmallBowl.java index 5c97d72..ce4c0ce 100644 --- a/domain/src/main/java/mancala/domain/SmallBowl.java +++ b/domain/src/main/java/mancala/domain/SmallBowl.java @@ -85,6 +85,15 @@ public class SmallBowl extends Bowl { return this; } + @Override + SmallBowl goToFirstBowlOfPlayerWithTurn() { + if (getMyOwner().hasTheTurn()) { + return getKalaha().getNextBowl().getKalaha().getSmallBowl(); + } else { + return getKalaha().getSmallBowl(); + } + } + Kalaha getKalaha() { return getNextBowl().getKalaha(); } @@ -94,8 +103,8 @@ public class SmallBowl extends Bowl { getOpposite().getKalaha().claimStolenBooty(myRocks); myRocks = 0; - } else if (getMyRocks() == 1 && - getOpposite().getMyRocks() != 0) { + } else if (getMyStones() == 1 && + getOpposite().getMyStones() != 0) { getKalaha().claimStolenBooty(myRocks); myRocks = 0; -- cgit v1.2.3 From e410bb8ccd47d7e9e58379dad5b138692de083e5 Mon Sep 17 00:00:00 2001 From: Mike Vink Date: Tue, 22 Jun 2021 15:39:30 +0200 Subject: finished refactor endTheGame --- domain/src/main/java/mancala/domain/Bowl.java | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) (limited to 'domain/src/main/java') diff --git a/domain/src/main/java/mancala/domain/Bowl.java b/domain/src/main/java/mancala/domain/Bowl.java index a7a2e78..a29b806 100644 --- a/domain/src/main/java/mancala/domain/Bowl.java +++ b/domain/src/main/java/mancala/domain/Bowl.java @@ -37,11 +37,7 @@ abstract class Bowl { } protected void endTheGame(Bowl startOfLoop, int scorePlayer, int scoreOpponent) { - if (isEmpty() == false) return; - - if (getMyOwner().equals(startOfLoop.getMyOwner())) { - scorePlayer = scorePlayer + getMyStones(); - } else scoreOpponent = scoreOpponent + getMyStones(); + if (isEmpty() == false && getMyOwner().equals(startOfLoop.getMyOwner())) return; if (this.equals(startOfLoop)) { @@ -56,7 +52,13 @@ abstract class Bowl { } - } else getNextBowl().endTheGame(startOfLoop, scorePlayer, scoreOpponent); + } else { + if (getMyOwner().equals(startOfLoop.getMyOwner())) { + scorePlayer = scorePlayer + getMyStones(); + } else scoreOpponent = scoreOpponent + getMyStones(); + + getNextBowl().endTheGame(startOfLoop, scorePlayer, scoreOpponent); + } } -- cgit v1.2.3 From 17b594e943eaccc69b6036e258308d1a1ddad53f Mon Sep 17 00:00:00 2001 From: Mike Vink Date: Tue, 22 Jun 2021 15:42:54 +0200 Subject: refactor(endTheGame) <- returns boolean --- domain/src/main/java/mancala/domain/Bowl.java | 12 +++++++----- domain/src/main/java/mancala/domain/MancalaImpl.java | 3 +-- 2 files changed, 8 insertions(+), 7 deletions(-) (limited to 'domain/src/main/java') diff --git a/domain/src/main/java/mancala/domain/Bowl.java b/domain/src/main/java/mancala/domain/Bowl.java index a29b806..fece393 100644 --- a/domain/src/main/java/mancala/domain/Bowl.java +++ b/domain/src/main/java/mancala/domain/Bowl.java @@ -32,12 +32,12 @@ abstract class Bowl { abstract boolean isEmpty(); // abstract SmallBowl getNextSmallBowl(); - void endTheGame() { - goToFirstBowlOfPlayerWithTurn().getNextBowl().endTheGame(goToFirstBowlOfPlayerWithTurn(), 0, 0); + boolean endTheGame() { + return goToFirstBowlOfPlayerWithTurn().getNextBowl().endTheGame(goToFirstBowlOfPlayerWithTurn(), 0, 0); } - protected void endTheGame(Bowl startOfLoop, int scorePlayer, int scoreOpponent) { - if (isEmpty() == false && getMyOwner().equals(startOfLoop.getMyOwner())) return; + protected boolean endTheGame(Bowl startOfLoop, int scorePlayer, int scoreOpponent) { + if (isEmpty() == false && getMyOwner().equals(startOfLoop.getMyOwner())) return false; if (this.equals(startOfLoop)) { @@ -49,6 +49,7 @@ abstract class Bowl { else if (scorePlayer > scoreOpponent) getMyOwner().isTheWinner(); else getMyOwner().getOpponent().isTheWinner(); + return true; } @@ -57,8 +58,9 @@ abstract class Bowl { scorePlayer = scorePlayer + getMyStones(); } else scoreOpponent = scoreOpponent + getMyStones(); - getNextBowl().endTheGame(startOfLoop, scorePlayer, scoreOpponent); + return getNextBowl().endTheGame(startOfLoop, scorePlayer, scoreOpponent); } + return false; } diff --git a/domain/src/main/java/mancala/domain/MancalaImpl.java b/domain/src/main/java/mancala/domain/MancalaImpl.java index 81dbbe8..82f914f 100644 --- a/domain/src/main/java/mancala/domain/MancalaImpl.java +++ b/domain/src/main/java/mancala/domain/MancalaImpl.java @@ -77,8 +77,7 @@ public class MancalaImpl implements Mancala { @Override public boolean isEndOfGame() { - //domainReference.endTheGame(); - return false; + return domainReference.endTheGame(); } @Override -- cgit v1.2.3 From 92c61668daefe1486d8ce6aefcf4c60c2eee0c3b Mon Sep 17 00:00:00 2001 From: Mike Vink Date: Tue, 22 Jun 2021 17:11:42 +0200 Subject: refactor(domain tests) <- configurable state --- domain/src/main/java/mancala/domain/Bowl.java | 19 +++---- domain/src/main/java/mancala/domain/Kalaha.java | 22 ++++---- .../src/main/java/mancala/domain/MancalaImpl.java | 25 ++++++--- domain/src/main/java/mancala/domain/SmallBowl.java | 63 +++++++++++----------- 4 files changed, 69 insertions(+), 60 deletions(-) (limited to 'domain/src/main/java') diff --git a/domain/src/main/java/mancala/domain/Bowl.java b/domain/src/main/java/mancala/domain/Bowl.java index fece393..8a214da 100644 --- a/domain/src/main/java/mancala/domain/Bowl.java +++ b/domain/src/main/java/mancala/domain/Bowl.java @@ -1,12 +1,12 @@ package mancala.domain; abstract class Bowl { - protected int myRocks; + protected int myStones; protected Player myOwner; protected Bowl nextBowl; public int getMyStones() { - return myRocks; + return myStones; } public Bowl getNextBowl() { @@ -25,19 +25,19 @@ abstract class Bowl { abstract Kalaha getKalaha(); - abstract SmallBowl getSmallBowl(); + abstract SmallBowl getNextSmallBowl(); abstract SmallBowl goToFirstBowlOfPlayerWithTurn(); abstract boolean isEmpty(); // abstract SmallBowl getNextSmallBowl(); - boolean endTheGame() { - return goToFirstBowlOfPlayerWithTurn().getNextBowl().endTheGame(goToFirstBowlOfPlayerWithTurn(), 0, 0); + void endTheGame() { + goToFirstBowlOfPlayerWithTurn().getNextBowl().endTheGame(goToFirstBowlOfPlayerWithTurn(), 0, 0); } - protected boolean endTheGame(Bowl startOfLoop, int scorePlayer, int scoreOpponent) { - if (isEmpty() == false && getMyOwner().equals(startOfLoop.getMyOwner())) return false; + protected void endTheGame(Bowl startOfLoop, int scorePlayer, int scoreOpponent) { + if (isEmpty() == false && getMyOwner().equals(startOfLoop.getMyOwner())) return; if (this.equals(startOfLoop)) { @@ -48,8 +48,6 @@ abstract class Bowl { if (scorePlayer == scoreOpponent) getMyOwner().gotADraw(); else if (scorePlayer > scoreOpponent) getMyOwner().isTheWinner(); else getMyOwner().getOpponent().isTheWinner(); - - return true; } @@ -58,9 +56,8 @@ abstract class Bowl { scorePlayer = scorePlayer + getMyStones(); } else scoreOpponent = scoreOpponent + getMyStones(); - return getNextBowl().endTheGame(startOfLoop, scorePlayer, scoreOpponent); + getNextBowl().endTheGame(startOfLoop, scorePlayer, scoreOpponent); } - return false; } diff --git a/domain/src/main/java/mancala/domain/Kalaha.java b/domain/src/main/java/mancala/domain/Kalaha.java index 7ab954c..a13ebd8 100644 --- a/domain/src/main/java/mancala/domain/Kalaha.java +++ b/domain/src/main/java/mancala/domain/Kalaha.java @@ -1,31 +1,33 @@ package mancala.domain; +import java.util.List; + class Kalaha extends Bowl { - Kalaha(int boardSize, int bowlsToAdd, Bowl startBowl, Player playerOwningThisSide) { + Kalaha(int boardSize, int bowlsToAdd, List stonesList, Bowl startBowl, Player playerOwningThisSide) { bowlsToAdd = bowlsToAdd - 1; - this.myRocks = 0; + this.myStones = stonesList.remove(0); this.myOwner = playerOwningThisSide; if (bowlsToAdd == 0) this.nextBowl = startBowl; - else this.nextBowl = new SmallBowl(boardSize, bowlsToAdd, startBowl, playerOwningThisSide.getOpponent()); + else this.nextBowl = new SmallBowl(boardSize, bowlsToAdd, stonesList, startBowl, playerOwningThisSide.getOpponent()); } Kalaha getKalaha() { return this; } - SmallBowl getSmallBowl() { - return getNextBowl().getSmallBowl(); + SmallBowl getNextSmallBowl() { + return getNextBowl().getNextSmallBowl(); } @Override SmallBowl goToFirstBowlOfPlayerWithTurn() { if (getMyOwner().hasTheTurn()) { - return getNextBowl().getKalaha().getSmallBowl(); + return getNextBowl().getKalaha().getNextSmallBowl(); } else { - return getSmallBowl(); + return getNextSmallBowl(); } } @@ -38,10 +40,10 @@ class Kalaha extends Bowl { } void distribute(int remainingRocks) { - myRocks++; + myStones++; // Skip? if (getMyOwner().hasTheTurn() == false) { - myRocks--; + myStones--; getNextBowl().distribute(remainingRocks); } else if (remainingRocks == 1) { endTheGame(); @@ -55,6 +57,6 @@ class Kalaha extends Bowl { void claimStolenBooty(int booty) { - myRocks = myRocks + booty; + myStones = myStones + booty; } } diff --git a/domain/src/main/java/mancala/domain/MancalaImpl.java b/domain/src/main/java/mancala/domain/MancalaImpl.java index 82f914f..29048ff 100644 --- a/domain/src/main/java/mancala/domain/MancalaImpl.java +++ b/domain/src/main/java/mancala/domain/MancalaImpl.java @@ -6,19 +6,21 @@ import java.util.stream.IntStream; public class MancalaImpl implements Mancala { - public static HashSet PLAYER_ONE_PITS = new HashSet<>( + public static final HashSet PLAYER_ONE_PITS = new HashSet<>( IntStream.rangeClosed(0, 5).boxed().collect(Collectors.toList()) ); - public static HashSet PLAYER_TWO_PITS = new HashSet<>( + public static final HashSet PLAYER_TWO_PITS = new HashSet<>( IntStream.rangeClosed(7, 12).boxed().collect(Collectors.toList()) ); - public static int PLAYER_ONE_KALAHA = 6; - public static int PLAYER_TWO_KALAHA = 13; + public static final int PLAYER_ONE_KALAHA = 6; + public static final int PLAYER_TWO_KALAHA = 13; private SmallBowl domainReference; public MancalaImpl() { domainReference = new SmallBowl(); + domainPlayer = domainReference.getMyOwner(); + domainOpponent = domainPlayer.getOpponent(); } @Override @@ -75,13 +77,22 @@ public class MancalaImpl implements Mancala { return -1; } - @Override + private final mancala.domain.Player domainPlayer; + private final mancala.domain.Player domainOpponent; + + @Override public boolean isEndOfGame() { - return domainReference.endTheGame(); + return domainPlayer.won() || domainOpponent.won(); } @Override public int getWinner() { - return Mancala.NO_PLAYERS; + if (!isEndOfGame()) return Mancala.NO_PLAYERS; + + 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; } + } \ No newline at end of file diff --git a/domain/src/main/java/mancala/domain/SmallBowl.java b/domain/src/main/java/mancala/domain/SmallBowl.java index ce4c0ce..07fa1e0 100644 --- a/domain/src/main/java/mancala/domain/SmallBowl.java +++ b/domain/src/main/java/mancala/domain/SmallBowl.java @@ -1,45 +1,44 @@ package mancala.domain; +import java.util.Arrays; +import java.util.List; +import java.util.stream.Collectors; + public class SmallBowl extends Bowl { public SmallBowl() { - this.myRocks = 4; + this( + Arrays.stream(new int[] {4,4,4,4,4,4,0,4,4,4,4,4,4,0}).boxed().collect(Collectors.toList()) + ); + } + + public SmallBowl(List stonesList) { this.myOwner = new Player(); - int boardSize = 14; + int boardSize = stonesList.size(); int bowlsToAdd = boardSize - 1; - this.nextBowl = new SmallBowl(boardSize, bowlsToAdd, this, this.getMyOwner()); - } + this.myStones = stonesList.remove(0); + + this.nextBowl = new SmallBowl(boardSize, bowlsToAdd, stonesList, this, this.getMyOwner()); - public SmallBowl(int boardSize) { - try { - if (boardSize < 4) { - throw new Exception("Can't have a board smaller than four bowls."); - } - } catch (Exception e) { - e.printStackTrace(); - } - 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) { + SmallBowl(int boardSize, int bowlsToAdd, List stonesList, Bowl startBowl, Player playerOwningThisSide) { bowlsToAdd = bowlsToAdd - 1; this.myOwner = playerOwningThisSide; - this.myRocks = 4; + this.myStones = stonesList.remove(0); if (bowlsToAdd == 0) nextBowl = startBowl; - else if (bowlsToAdd == (boardSize / 2) + 1) nextBowl = new Kalaha(boardSize, bowlsToAdd, startBowl, playerOwningThisSide); + else if (bowlsToAdd == (boardSize / 2) + 1) nextBowl = new Kalaha(boardSize, bowlsToAdd, stonesList, startBowl, playerOwningThisSide); - else if (bowlsToAdd == 1) nextBowl = new Kalaha(boardSize, bowlsToAdd, startBowl, playerOwningThisSide); + else if (bowlsToAdd == 1) nextBowl = new Kalaha(boardSize, bowlsToAdd, stonesList, startBowl, playerOwningThisSide); - else nextBowl = new SmallBowl(boardSize, bowlsToAdd, startBowl, playerOwningThisSide); + else nextBowl = new SmallBowl(boardSize, bowlsToAdd, stonesList, startBowl, playerOwningThisSide); } + public SmallBowl getNextSmallBowlTimes(int remainingTimes) { if (remainingTimes == 0) return this; @@ -52,18 +51,18 @@ public class SmallBowl extends Bowl { if (myOwner.hasTheTurn() == false) return; if (isEmpty()) return; - int passThese = myRocks; - myRocks = 0; + int passThese = myStones; + myStones = 0; getNextBowl().distribute(passThese); } @Override boolean isEmpty() { - return this.myRocks == 0; + return this.myStones == 0; } void distribute(int remainingRocks) { - this.myRocks++; + this.myStones++; // last? if (remainingRocks == 1) lastSmallBowl(); @@ -81,16 +80,16 @@ public class SmallBowl extends Bowl { endTheGame(); } - SmallBowl getSmallBowl() { + SmallBowl getNextSmallBowl() { return this; } @Override SmallBowl goToFirstBowlOfPlayerWithTurn() { if (getMyOwner().hasTheTurn()) { - return getKalaha().getNextBowl().getKalaha().getSmallBowl(); + return getKalaha().getNextBowl().getKalaha().getNextSmallBowl(); } else { - return getKalaha().getSmallBowl(); + return getKalaha().getNextSmallBowl(); } } @@ -100,14 +99,14 @@ public class SmallBowl extends Bowl { private void stealTheBooty(boolean victim) { if (victim){ - getOpposite().getKalaha().claimStolenBooty(myRocks); - myRocks = 0; + getOpposite().getKalaha().claimStolenBooty(myStones); + myStones = 0; } else if (getMyStones() == 1 && getOpposite().getMyStones() != 0) { - getKalaha().claimStolenBooty(myRocks); - myRocks = 0; + getKalaha().claimStolenBooty(myStones); + myStones = 0; getOpposite().stealTheBooty(true); } } -- cgit v1.2.3 From 0f4370cee071ada7bf1974a3ae2eeb14c4d00aab Mon Sep 17 00:00:00 2001 From: Mike Vink Date: Tue, 22 Jun 2021 17:28:10 +0200 Subject: refactor(domain tests) <- reorganising --- .../main/java/mancala/domain/DomainSmallBowlException.java | 7 +++++++ domain/src/main/java/mancala/domain/MancalaImpl.java | 6 +++++- domain/src/main/java/mancala/domain/SmallBowl.java | 11 ++++++----- 3 files changed, 18 insertions(+), 6 deletions(-) create mode 100644 domain/src/main/java/mancala/domain/DomainSmallBowlException.java (limited to 'domain/src/main/java') diff --git a/domain/src/main/java/mancala/domain/DomainSmallBowlException.java b/domain/src/main/java/mancala/domain/DomainSmallBowlException.java new file mode 100644 index 0000000..56e5de1 --- /dev/null +++ b/domain/src/main/java/mancala/domain/DomainSmallBowlException.java @@ -0,0 +1,7 @@ +package mancala.domain; + +public class DomainSmallBowlException extends Exception { + public DomainSmallBowlException(String message) { + super(message); + } +} diff --git a/domain/src/main/java/mancala/domain/MancalaImpl.java b/domain/src/main/java/mancala/domain/MancalaImpl.java index 29048ff..a8e6691 100644 --- a/domain/src/main/java/mancala/domain/MancalaImpl.java +++ b/domain/src/main/java/mancala/domain/MancalaImpl.java @@ -18,7 +18,11 @@ public class MancalaImpl implements Mancala { private SmallBowl domainReference; public MancalaImpl() { - domainReference = new SmallBowl(); + try { + domainReference = new SmallBowl(); + } catch (DomainSmallBowlException e) { + e.printStackTrace(); + } domainPlayer = domainReference.getMyOwner(); domainOpponent = domainPlayer.getOpponent(); } diff --git a/domain/src/main/java/mancala/domain/SmallBowl.java b/domain/src/main/java/mancala/domain/SmallBowl.java index 07fa1e0..b9e4b45 100644 --- a/domain/src/main/java/mancala/domain/SmallBowl.java +++ b/domain/src/main/java/mancala/domain/SmallBowl.java @@ -6,13 +6,14 @@ import java.util.stream.Collectors; public class SmallBowl extends Bowl { - public SmallBowl() { - this( - Arrays.stream(new int[] {4,4,4,4,4,4,0,4,4,4,4,4,4,0}).boxed().collect(Collectors.toList()) - ); + public SmallBowl() throws DomainSmallBowlException { + this(Arrays.stream(new int[] {4,4,4,4,4,4,0,4,4,4,4,4,4,0}).boxed().collect(Collectors.toList())); } - public SmallBowl(List stonesList) { + public SmallBowl(List stonesList) throws DomainSmallBowlException { + if (stonesList.size() % 2 != 0) { + throw new DomainSmallBowlException("Stones List should contain even number of elements."); + } this.myOwner = new Player(); int boardSize = stonesList.size(); -- cgit v1.2.3 From 2e1a7cbcd36296c5abb1bb6d12fc155e3e3913fb Mon Sep 17 00:00:00 2001 From: Mike Vink Date: Tue, 22 Jun 2021 20:14:22 +0200 Subject: finished making my life easier (domain tests) --- domain/src/main/java/mancala/domain/Bowl.java | 2 +- domain/src/main/java/mancala/domain/Kalaha.java | 14 +++++++++++ domain/src/main/java/mancala/domain/SmallBowl.java | 29 ++++++++++++++++++++-- 3 files changed, 42 insertions(+), 3 deletions(-) (limited to 'domain/src/main/java') diff --git a/domain/src/main/java/mancala/domain/Bowl.java b/domain/src/main/java/mancala/domain/Bowl.java index 8a214da..a36c621 100644 --- a/domain/src/main/java/mancala/domain/Bowl.java +++ b/domain/src/main/java/mancala/domain/Bowl.java @@ -61,5 +61,5 @@ abstract class Bowl { } - + protected abstract String makeString(String playerBowls, String opponentBowls, String kalahas); } diff --git a/domain/src/main/java/mancala/domain/Kalaha.java b/domain/src/main/java/mancala/domain/Kalaha.java index a13ebd8..c85af4a 100644 --- a/domain/src/main/java/mancala/domain/Kalaha.java +++ b/domain/src/main/java/mancala/domain/Kalaha.java @@ -55,6 +55,20 @@ class Kalaha extends Bowl { return true; } + @Override + protected String makeString(String playerBowls, String opponentBowls, String kalahas) { + if (getMyOwner().equals(SmallBowl.referencePoint.getMyOwner().getOpponent())) { + return " " + opponentBowls + "\n" + + getMyStones() + "\t\t\t\t " + kalahas + "\n" + + " " + playerBowls; + } + else { + return getNextBowl().makeString( + playerBowls, + opponentBowls, + kalahas + getMyStones()); + } + } void claimStolenBooty(int booty) { myStones = myStones + booty; diff --git a/domain/src/main/java/mancala/domain/SmallBowl.java b/domain/src/main/java/mancala/domain/SmallBowl.java index b9e4b45..216e2ad 100644 --- a/domain/src/main/java/mancala/domain/SmallBowl.java +++ b/domain/src/main/java/mancala/domain/SmallBowl.java @@ -6,8 +6,11 @@ import java.util.stream.Collectors; public class SmallBowl extends Bowl { + public static SmallBowl referencePoint; + public SmallBowl() throws DomainSmallBowlException { this(Arrays.stream(new int[] {4,4,4,4,4,4,0,4,4,4,4,4,4,0}).boxed().collect(Collectors.toList())); + referencePoint = this; } public SmallBowl(List stonesList) throws DomainSmallBowlException { @@ -22,7 +25,7 @@ public class SmallBowl extends Bowl { this.myStones = stonesList.remove(0); this.nextBowl = new SmallBowl(boardSize, bowlsToAdd, stonesList, this, this.getMyOwner()); - + referencePoint = this; } SmallBowl(int boardSize, int bowlsToAdd, List stonesList, Bowl startBowl, Player playerOwningThisSide) { @@ -76,9 +79,10 @@ public class SmallBowl extends Bowl { // Did play end in smallbowl of my player? steal, otherwise do nothing if (getMyOwner().hasTheTurn()) stealTheBooty(false); + endTheGame(); + getMyOwner().switchTurn(); - endTheGame(); } SmallBowl getNextSmallBowl() { @@ -100,11 +104,13 @@ public class SmallBowl extends Bowl { private void stealTheBooty(boolean victim) { if (victim){ + System.out.println("help! i'm being robbed, my precious " + getMyStones() + " stones are gone :(."); getOpposite().getKalaha().claimStolenBooty(myStones); myStones = 0; } else if (getMyStones() == 1 && getOpposite().getMyStones() != 0) { + System.out.println("stealing"); getKalaha().claimStolenBooty(myStones); myStones = 0; @@ -120,4 +126,23 @@ public class SmallBowl extends Bowl { count = count + 1; return getNextBowl().getOpposite(count); } + + public String stateString() { + return SmallBowl.referencePoint.makeString("", "", ""); + } + + protected String makeString(String playerBowls, String opponentBowls, String kalahas) { + if (!this.getMyOwner().equals(SmallBowl.referencePoint.getMyOwner())) { + return getNextBowl().makeString( + playerBowls, + (getMyStones() + ", ") + opponentBowls, + kalahas); + } else { + return getNextBowl().makeString( + playerBowls + (playerBowls.equals("") ? getMyStones() : ", " + getMyStones()), + opponentBowls, + kalahas); + } + } + } -- cgit v1.2.3 From 3906fcf3d702f13da79c797c91a2dd32d874af49 Mon Sep 17 00:00:00 2001 From: Mike Vink Date: Tue, 22 Jun 2021 21:12:52 +0200 Subject: update(MancalaImpl) <- playPit returns stateArray --- domain/src/main/java/mancala/domain/Bowl.java | 2 ++ domain/src/main/java/mancala/domain/Kalaha.java | 12 ++++++++++++ domain/src/main/java/mancala/domain/Mancala.java | 2 +- .../src/main/java/mancala/domain/MancalaImpl.java | 21 ++++++++++++++++++--- domain/src/main/java/mancala/domain/SmallBowl.java | 16 +++++++++++++++- 5 files changed, 48 insertions(+), 5 deletions(-) (limited to 'domain/src/main/java') 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); + } + } } -- cgit v1.2.3 From 976ed2b105e80b257ebb724b3061400f37460041 Mon Sep 17 00:00:00 2001 From: Mike Vink Date: Thu, 24 Jun 2021 23:11:39 +0200 Subject: mega commit --- domain/src/main/java/mancala/domain/MancalaImpl.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'domain/src/main/java') diff --git a/domain/src/main/java/mancala/domain/MancalaImpl.java b/domain/src/main/java/mancala/domain/MancalaImpl.java index 0090f2d..576eeb4 100644 --- a/domain/src/main/java/mancala/domain/MancalaImpl.java +++ b/domain/src/main/java/mancala/domain/MancalaImpl.java @@ -77,7 +77,7 @@ public class MancalaImpl implements Mancala { return domainReference.toStateArray(new int[15], 0); } - + @Override public int getStonesForPit(int index) { if (MancalaImpl.PLAYER_ONE_PITS.contains(index)) { @@ -114,4 +114,4 @@ public class MancalaImpl implements Mancala { else return Mancala.NO_PLAYERS; } -} \ No newline at end of file +} -- cgit v1.2.3 From 102b25f18d9b269c58d15677f10cd71c15003c4b Mon Sep 17 00:00:00 2001 From: Mike Vink Date: Fri, 25 Jun 2021 11:49:50 +0200 Subject: ending game from a steal should work now --- domain/src/main/java/mancala/domain/SmallBowl.java | 1 + 1 file changed, 1 insertion(+) (limited to 'domain/src/main/java') diff --git a/domain/src/main/java/mancala/domain/SmallBowl.java b/domain/src/main/java/mancala/domain/SmallBowl.java index b750f61..b62ef43 100644 --- a/domain/src/main/java/mancala/domain/SmallBowl.java +++ b/domain/src/main/java/mancala/domain/SmallBowl.java @@ -88,6 +88,7 @@ public class SmallBowl extends Bowl { getMyOwner().switchTurn(); + endTheGame(); } SmallBowl getNextSmallBowl() { -- cgit v1.2.3