diff --git a/src/main/java/Game.java b/src/main/java/Game.java index c2654d9..504800c 100644 --- a/src/main/java/Game.java +++ b/src/main/java/Game.java @@ -1,21 +1,125 @@ +import java.util.ArrayList; +import java.util.concurrent.TimeUnit; + +import static java.lang.System.exit; + public class Game { Gameboard gb; - Player p1; - Player p2; - Player p3; - Player p4; + ArrayList players; - public static void main(String[] args) { + public static void main(String[] args) throws InterruptedException { Game g = new Game(); + Player winner; + while(true){ + for (Player p : g.players) { + int c = 0; + int dice; + System.out.println("Spieler " + p.name + " an der Reihe."); + do { + int figId; + dice = p.rollDice(); + TimeUnit.SECONDS.sleep(1L); + System.out.println("Würfel: " + dice); + c++; + ArrayList usableFigures = g.getUsableFigures(dice, p, g); + if(usableFigures.size() > 0) { + do { + figId = p.choose(usableFigures); + } while(figId == -1); + g.setFigure(figId, dice, p, g); + } + } while (g.checkDice(dice, p, c)); + if(p.checkGameWin(p.figures)) { + winner = p; + System.out.println("Spieler " + winner.name + " gewinnt!"); + exit(42); + } + } + } } public Game() { this.gb = new Gameboard(); gb.initGameboard(); - p1 = new Player("Rot", 40, 43); - p2 = new Player("Blau", 44, 47); - p3 = new Player("Gelb", 48, 51); - p4 = new Player("Grün", 52, 55); + players = new ArrayList<>(); + players.add(new Player("Rot",0, 40, 39)); + players.add(new Player("Blau",10, 44, 9)); + players.add(new Player("Gelb",20, 48, 19)); + players.add(new Player("Grün",30, 52, 29)); + } + + public boolean checkDice(int dice, Player p, int countRolls) { + int figuresInBase = p.checkFigureInBase(p.figures); + if(figuresInBase == 4) { + return countRolls <= 3; + } else return dice == 6; + } + + public int checkFieldClear(int posToCheck, Player p, Game g) { + int mode; + for (Player currentPlayer : g.players) { + if (currentPlayer.name.equals(p.name)) { + mode = 2; + } else { + mode = 1; + } + for (Figure f : currentPlayer.figures) { + if (posToCheck == f.getPosition()) { + return mode; + } + } + } + return 0; + } + + public ArrayList getUsableFigures(int dice, Player p, Game g) { + ArrayList result = new ArrayList<>(); + for(int i = 0; i < p.figures.size(); i++) { + if(figureIsUsable(dice, i, p, g)) { + result.add(i); + } + } + return result; + } + + public boolean figureIsUsable(int dice, int figId, Player p, Game g) { + Figure f = p.figures.get(figId); + + if(p.checkFigureInBase(p.figures) > 0 && dice == 6){ + if(g.checkFieldClear(p.startPos, p, g) == 2) { + return f.getPosition() == p.startPos; //TODO Wenn Figur auf Startpos von anderer Figur blockiert ist + } + return f.getPosition() == -1; + } else if (f.getPosition() <= p.jumpToHome && (f.getPosition() + dice) > p.jumpToHome) { + if((f.getPosition() + dice) <= p.jumpToHome + 4) { + return g.checkFieldClear(f.getPosition() + dice - p.jumpToHome + p.startHome - 1, p, g) != 2; + } else { + return false; + } + } else if(f.getPosition() != -1) { + return g.checkFieldClear((f.getPosition() + dice) % 40, p, g) != 2; + } + return false; + } + + public int setFigure(int figId, int dice, Player p, Game g) { + int preCalculated; + if(p.figures.get(figId).getPosition() == -1) { + preCalculated = p.startPos; + } else { + preCalculated = (p.figures.get(figId).getPosition() + dice) % 40; + } + int kicked = 0; + for(Player currentPlayer : g.players) { + for(Figure currentFigure : currentPlayer.figures) { + if(currentFigure.getPosition() == preCalculated) { + currentFigure.setPosition(-1); + kicked = 1; + } + } + } + p.figures.get(figId).setPosition(preCalculated); + return kicked; } -} +} \ No newline at end of file diff --git a/src/main/java/Player.java b/src/main/java/Player.java index c143347..fd04ee1 100644 --- a/src/main/java/Player.java +++ b/src/main/java/Player.java @@ -1,30 +1,25 @@ -import java.util.ArrayList; -import java.util.Iterator; -import java.util.Scanner; +import java.util.*; public class Player { String name; ArrayList
figures; + int startPos; int startHome; - int endHome; + int jumpToHome; Scanner scanner; - public Player (String name, int startHome, int endHome) { + public Player(String name, int startPos, int startHome, int jumpToHome) { this.name = name; + this.startPos = startPos; this.startHome = startHome; - this.endHome = endHome; + this.jumpToHome = jumpToHome; figures = new ArrayList<>(); for(int i = 0; i < 4; i++) { figures.add(new Figure()); } } - @Override - public String toString() { - return name; - } - public int rollDice() { return (int) (Math.random() * 6 + 1); } @@ -34,39 +29,40 @@ public class Player { Figure f; while(it.hasNext()) { f = it.next(); - if(!(f.getPosition() >= startHome && f.getPosition() <= endHome)) { + if(!(f.getPosition() >= startHome && f.getPosition() <= startHome+3)) { return false; } } return true; } - public boolean checkFigureInBase(ArrayList
figures) { + public int checkFigureInBase(ArrayList
figures) { Iterator
it = figures.iterator(); Figure f; + int count = 0; while(it.hasNext()) { f = it.next(); if(f.getPosition() == -1) { - return true; + count++; } } - return false; + return count; } - public int choose() { + public int choose(ArrayList usableFigures) { scanner = new Scanner(System.in); - System.out.print("Wählen Sie eine Figur(1-4): "); + System.out.print("Wählen Sie eine Figur " + usableFigures.toString() + ": "); try{ int input = scanner.nextInt(); - if (input > 4 || input < 1) { + if (input > Collections.max(usableFigures) || input < Collections.min(usableFigures)) { System.out.println("Die eingegebene Zahl war zu groß oder zu klein.\n" + - "Bitte nur Zahlen von 1 bis 4 eingeben."); + "Bitte nur Zahlen von " + Collections.min(usableFigures) + " bis " + Collections.max(usableFigures) + " eingeben."); return -1; } return input; } catch (Exception e) { System.out.println("Die Eingabe hat keine Zahl bekommen.\n" + - "Bitte nur Zahlen von 1 bis 4 eingeben."); + "Bitte nur Zahlen von " + Collections.min(usableFigures) + " bis " + Collections.max(usableFigures) + " eingeben."); return -1; } } diff --git a/src/test/java/GameTest.java b/src/test/java/GameTest.java index bd47a51..27d63dc 100644 --- a/src/test/java/GameTest.java +++ b/src/test/java/GameTest.java @@ -1,13 +1,184 @@ +import static org.assertj.core.api.Assertions.*; + import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; + +import java.util.*; +import java.util.stream.Stream; public class GameTest { private Game g; + private Player p1; + private Game g2; + private Player p2; @BeforeEach void setup() { g = new Game(); + p1 = g.players.get(0); + + g2 = new Game(); + p2 = g2.players.get(0); + p2.figures.get(0).setPosition(5); + p2.figures.get(1).setPosition(10); + g2.players.get(3).figures.get(1).setPosition(14); + } + + @ParameterizedTest + @MethodSource("checkDiceTestData") + void checkDiceTest(String testname, Collection positions, int dice, int c, boolean expectedResult) { + Iterator
it = p1.figures.iterator(); + Iterator it2 = positions.iterator(); + while(it.hasNext()) { + it.next().setPosition(it2.next()); + } + boolean calculatedResult = g.checkDice(dice, p1, c); + assertThat(calculatedResult).describedAs(testname).isEqualTo(expectedResult); + } + + static Stream checkDiceTestData () { + return Stream.of( + Arguments.of("No figures on Field - d: 1 - c: 1", + Arrays.asList(-1, -1, -1, -1), + 1, + 1, + true + ), + Arguments.of("No figures on Field - d: 1 - c: 2", + Arrays.asList(-1, -1, -1, -1), + 1, + 2, + true + ), + Arguments.of("No figures on Field - d: 1 - c: 3", + Arrays.asList(-1, -1, -1, -1), + 1, + 3, + true + ), + Arguments.of("No figures on Field - d: 1 - c: 4", + Arrays.asList(-1, -1, -1, -1), + 1, + 4, + false + ), + Arguments.of("Figures on Field - d: 1 - c: 1", + Arrays.asList(10, -1, 2, -1), + 1, + 1, + false + ), + Arguments.of("Figures on Field - d: 6 - c: 1", + Arrays.asList(10, -1, 2, -1), + 6, + 1, + true + ) + ); + } + + @Test + void checkFieldClearTestFieldNotTaken() { + int expectedResult = 0; + int calculatedResult = g.checkFieldClear(1, p1, g); + assertThat(calculatedResult).describedAs("Check Field Clear").isEqualTo(expectedResult); } + @Test + void checkFieldClearTestFieldTakenByOtherPlayer() { + int expectedResult = 1; + g.players.get(1).figures.get(0).setPosition(1); + int calculatedResult = g.checkFieldClear(1, p1, g); + assertThat(calculatedResult).describedAs("Check Field Clear").isEqualTo(expectedResult); + } + + @Test + void checkFieldClearTestFieldTakenByOwnFigure() { + int expectedResult = 2; + p1.figures.get(1).setPosition(1); + int calculatedResult = g.checkFieldClear(1, p1, g); + assertThat(calculatedResult).describedAs("Check Field Clear").isEqualTo(expectedResult); + } + + @ParameterizedTest + @MethodSource("usableFiguresData") + void getUsableFiguresTest(String testname, int dice, Collection positions, ArrayList expectedResult) { + Iterator
figureIt = p1.figures.iterator(); + Iterator posIt = positions.iterator(); + while(figureIt.hasNext()) { + Figure f = figureIt.next(); + f.setPosition(posIt.next()); + } + + List calculatedResult = g.getUsableFigures(dice, p1, g); + assertThat(calculatedResult).describedAs(testname).isEqualTo(expectedResult); + } + + static Stream usableFiguresData () { + return Stream.of( + Arguments.of( //Würfel 1-6 - Keine Figur im Ziel - Alle Figuren auf dem Spielfeld - StartFeld frei - Keine Figur vor Ziel + "Alle Figuren", + 1, + Arrays.asList(10, 25, 2, 17), + new ArrayList<>(Arrays.asList(0, 1, 2, 3)) + ), + Arguments.of( //Würfel 6 - Keine Figur im Ziel - 1 Figur auf dem Spielfeld - StartFeld frei - Keine Figur vor Ziel + "Figuren die nicht am Spielfeld stehen", + 6, + Arrays.asList(10, -1, -1, -1), + new ArrayList<>(Arrays.asList(1, 2, 3)) + ), + Arguments.of( //Würfel 6 - Keine Figur im Ziel - 1 Figur auf dem Spielfeld - StartFeld besetzt - Keine Figur vor Ziel + "Figur die das Startfeld besetzt", + 6, + Arrays.asList(10, 0, -1, -1), + new ArrayList<>(List.of(1)) + ), + Arguments.of( //Würfel 5 - Keine Figur im Ziel - 1 Figur auf dem Spielfeld - StartFeld besetzt - Figur vor Ziel + "Figur vor dem Ziel - kann man benutzen", + 5, + Arrays.asList(10, 37, -1, -1), + new ArrayList<>(Arrays.asList(0,1)) + ), + Arguments.of( //Würfel 5 - Keine Figur im Ziel - 1 Figur auf dem Spielfeld - StartFeld besetzt - Figur vor Ziel + "Figur vor dem Ziel - kann man nicht benutzen", + 5, + Arrays.asList(10, 39, -1, -1), + new ArrayList<>(List.of(0)) + ), + Arguments.of( //Würfel 5 - Figur im Ziel - 1 Figur auf dem Spielfeld - StartFeld besetzt - Figur vor Ziel + "Nur Figuren die auf ein freies Feld kommen", + 2, + Arrays.asList(10, 12, -1, -1), + new ArrayList<>(List.of(1)) + ), + Arguments.of( //Würfel 6 - 1 Figur auf dem Spielfeld - StartFeld besetzt + "Figur auf Startfeld", + 6, + Arrays.asList(-1, -1, -1, 0), + new ArrayList<>(List.of(3)) + ) + ); + } + + @ParameterizedTest + @MethodSource("setFigureData") + void setFigureTest(String testname, int figId, int dice, int expectedResult) { + int calculatedResult = g.setFigure(figId, dice, p2, g2); + assertThat(calculatedResult).describedAs(testname).isEqualTo(expectedResult); + } + + static Stream setFigureData () { + return Stream.of( + Arguments.of("Figur wird auf Feld gesetzt - Niemand gekicked", 0, 4, 0), + Arguments.of("Figur wird auf Feld gesetzt - Jemand gekicked", 1, 4, 1) + ); + } } + + diff --git a/src/test/java/PlayerTest.java b/src/test/java/PlayerTest.java index c419115..0a38a78 100644 --- a/src/test/java/PlayerTest.java +++ b/src/test/java/PlayerTest.java @@ -7,10 +7,7 @@ import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.MethodSource; import java.io.ByteArrayInputStream; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collection; -import java.util.Iterator; +import java.util.*; import java.util.stream.Stream; public class PlayerTest { @@ -19,7 +16,7 @@ public class PlayerTest { @BeforeEach void setup() { - p = new Player("Rot", 40, 43); + p = new Player("Rot",0, 40, 39); } @Test @@ -28,13 +25,6 @@ public class PlayerTest { assertThat(calculatedResult).describedAs("Dice result").isBetween(1,6); } - @Test - void testToString() { - String expectedResult = "Rot"; - String calculatedResult = p.toString(); - assertThat(calculatedResult).describedAs("Player Name").isEqualTo(expectedResult); - } - @Test void checkStartPositionOfFigures() { int expectedResult = -1; @@ -64,13 +54,13 @@ public class PlayerTest { @ParameterizedTest @MethodSource("BaseTestData") - void checkFigureInBase(String testname, ArrayList
figures, Collection positions, boolean expectedResult) { + void checkFigureInBase(String testname, ArrayList
figures, Collection positions, int expectedResult) { Iterator
it = figures.iterator(); Iterator it2 = positions.iterator(); while(it.hasNext()) { it.next().setPosition(it2.next()); } - boolean calculatedResult = p.checkFigureInBase(figures); + int calculatedResult = p.checkFigureInBase(figures); assertThat(calculatedResult).describedAs(testname).isEqualTo(expectedResult); } @@ -134,7 +124,7 @@ public class PlayerTest { new Figure(), new Figure()) ), Arrays.asList(-1, -1, -1, -1), - true), + 4), Arguments.of("Three Figures in Base", new ArrayList<>( Arrays.asList( @@ -143,7 +133,7 @@ public class PlayerTest { new Figure(), new Figure()) ), Arrays.asList(40, -1, -1, -1), - true), + 3), Arguments.of("Two Figures in Base", new ArrayList<>( Arrays.asList( @@ -152,7 +142,7 @@ public class PlayerTest { new Figure(), new Figure()) ), Arrays.asList(40, 41, -1, -1), - true), + 2), Arguments.of("One Figure in Base", new ArrayList<>( Arrays.asList( @@ -161,7 +151,7 @@ public class PlayerTest { new Figure(), new Figure()) ), Arrays.asList(40, 41, 42, -1), - true), + 1), Arguments.of("No Figures in Base", new ArrayList<>( Arrays.asList( @@ -170,29 +160,31 @@ public class PlayerTest { new Figure(), new Figure()) ), Arrays.asList(40, 41, 42, 43), - false) + 0) ); } @ParameterizedTest @MethodSource("checkChooseMethodData") - void checkChoose(String testName, String input, int expectedResult) { + void checkChoose(String testName, String input,ArrayList usableFiugres, int expectedResult) { System.setIn(new ByteArrayInputStream(input.getBytes())); - int calculatedResult = p.choose(); + int calculatedResult = p.choose(usableFiugres); assertThat(calculatedResult).describedAs(testName).isEqualTo(expectedResult); } static Stream checkChooseMethodData() { return Stream.of( - Arguments.of("Figure 1 choosen", "1\n", 1), - Arguments.of("Figure 2 choosen", "2\n", 2), - Arguments.of("Figure 3 choosen", "3\n", 3), - Arguments.of("Figure 4 choosen", "4\n", 4), - Arguments.of("Index out of bounds choosen", "16\n", -1), - Arguments.of("Index out of bounds choosen", "-2\n", -1), - Arguments.of("Input a letter or char", "g\n", -1), - Arguments.of("Input a empty string", "\n", -1), - Arguments.of("Input a special character", "&\n", -1) + Arguments.of("Figure 1 choosen", "1\n", new ArrayList<>(Arrays.asList(1,2,3,4)), 1), + Arguments.of("Figure 2 choosen", "2\n", new ArrayList<>(Arrays.asList(1,2,3,4)), 2), + Arguments.of("Figure 3 choosen", "3\n", new ArrayList<>(Arrays.asList(1,2,3,4)),3), + Arguments.of("Figure 4 choosen", "4\n", new ArrayList<>(Arrays.asList(1,2,3,4)),4), + Arguments.of("Index out of bounds choosen", "16\n",new ArrayList<>(Arrays.asList(1,2,3,4)), -1), + Arguments.of("Index out of bounds choosen", "-2\n",new ArrayList<>(Arrays.asList(1,2,3,4)), -1), + Arguments.of("Input a letter or char", "g\n",new ArrayList<>(Arrays.asList(1,2,3,4)), -1), + Arguments.of("Input a empty string", "\n",new ArrayList<>(Arrays.asList(1,2,3,4)), -1), + Arguments.of("Input a special character", "&\n",new ArrayList<>(Arrays.asList(1,2,3,4)), -1), + Arguments.of("Only one Figure available", "1\n", new ArrayList<>(List.of(1)),1), + Arguments.of("Figure not available", "4\n", new ArrayList<>(Arrays.asList(1,2)),-1) ); } }