2025ft

src/j2025/FT/Game.java

@@ -1,5 +1,141 @@
 package j2025.FT;
 
 public class Game {
+
+    private final PlayerHandler playerHandler;
+    private PairOfDice dice;
+    private PairOfDice announcement;
+
+    public Game(PlayerHandler playerHandler) {
+        this.playerHandler = playerHandler;
+    }
+
+    public void checkValue() {
+        state.checkValue();
+    }
+
+    public void rollTheDice() {
+        state.rollTheDice();
+    }
+
+    public void announce(PairOfDice pairOfDice) {
+        state.announce(pairOfDice);
+    }
+
+    public void callLiar() {
+        state.callLiar();
+    }
+
+    public PairOfDice getDice() {
+        return dice;
+    }
+
+    public PairOfDice getAnnouncement() {
+        return announcement;
+    }
+
+    public PlayerHandler getPlayerHandler() {
+        return playerHandler;
+    }
     
+
+
+
+
+    private State startRound = new State() {
+
+        @Override
+        void checkValue() {
+            System.out.println("Aktueller Spieler sieht:" + getDice().toString());
+        }
+
+        @Override
+        void rollTheDice() {
+            dice = PairOfDice.random();
+            state = initialValue;
+        }
+        
+    };
+
+    private State initialValue = new State() {
+        
+        @Override
+        void checkValue() {
+            System.out.println("Aktueller Spieler sieht:" + getDice().toString());
+        }
+
+        @Override
+        void announce(PairOfDice value) {
+            announcement = value;
+            playerHandler.nextTurn();
+            state = choice;
+        }
+    };
+    
+    private State choice = new State() {
+        
+        @Override
+        void announce(PairOfDice value) {
+            if (value.compareTo(getAnnouncement()) > 0) {
+                announcement = value;
+                playerHandler.nextTurn();
+            } 
+        }
+
+        @Override
+        void checkValue() {
+            System.out.println("Aktueller Spieler sieht:" + getDice().toString());
+            state = increaseValue;
+        }
+
+        @Override
+        void callLiar() {
+            if (getAnnouncement().compareTo(dice) > 0) {
+                playerHandler.currentPlayerWinsRound();
+            } else {
+                playerHandler.previusPlayerWinsRound();
+            }
+
+            if (playerHandler.remaining() > 1) {
+                state = startRound;
+            } else {
+                state = gameOver;
+            }
+        }
+    };
+    
+    private State increaseValue = new State() {
+        
+        @Override
+        void checkValue() {
+            System.out.println("Aktueller Spieler sieht:" + getDice().toString());
+        }
+
+        @Override
+        void announce(PairOfDice value) {
+            if (value.compareTo(announcement) > 0) {
+                announcement = value;
+                playerHandler.nextTurn();
+                state = choice;
+            }
+        }
+    };
+    
+    private State gameOver = new State() {
+
+        // Konstruktor von anonymen Klassen
+        {
+             entry();
+        }
+
+            private void entry() {
+                System.out.println("Spiel vorbei!");
+                System.out.println("Spieler " + playerHandler.getCurrentPlayer().getName() + " gewinnt!");
+                for (Player player : playerHandler.getRanking()) {
+                    System.out.println("Platz " + (playerHandler.getRanking().indexOf(player) + 2) + ": " + player.getName());
+                }
+            }
+    };
+
+    private State state = startRound;
 }

src/j2025/FT/InvalidAction.java

@@ -0,0 +1,7 @@
+package j2025.FT;
+
+public class InvalidAction extends RuntimeException{
+    public InvalidAction(String message) {
+        super(message);
+    }
+}

src/j2025/FT/PairOfDice.java

@@ -33,4 +33,8 @@ public class PairOfDice implements Comparable<PairOfDice> {
         return new PairOfDice(Die.random(), Die.random());
     }
 
+    @Override
+    public String toString() {
+        return die1.ordinal() + 1  + " " + (die2.ordinal() + 1); 
+    }
 }

src/j2025/FT/PairOfDiceTest.java

@@ -18,4 +18,10 @@ public class PairOfDiceTest {
         assertEquals(0, p33.compareTo(p33));
         assertEquals(0, p41.compareTo(p41));
     }
+
+    @Test
+    public void testToString() {
+        assertEquals("3 3", p33.toString());
+        assertEquals("4 1", p41.toString());
+    }
 }

src/j2025/FT/Player.java

@@ -3,7 +3,7 @@ package j2025.FT;
 public class Player {
     
     private final String name;
-    private int points = 0;
+    private int points = 10;
 
     public Player(String name, int points) {
         this.name = name;

src/j2025/FT/PlayerHandler.java

@@ -1,11 +1,13 @@
 package j2025.FT;
 
+import java.util.ArrayList;
 import java.util.LinkedList;
 import java.util.List;
 
 public class PlayerHandler {
     
     private List<Player> players = new LinkedList<>();
+    private List<Player> ranking = new ArrayList<>();
 
     public void addPlayer(Player player) {
         players.add(player);
@@ -14,4 +16,40 @@ public class PlayerHandler {
     public Player getCurrentPlayer() {
         return players.getFirst();
     }
+
+    public void nextTurn() {
+        players.add(players.removeFirst());
+    }
+
+    public int remaining() {
+        return players.size();
+    }
+
+    public void currentPlayerWinsRound() {
+        Player lastPlayer = players.getLast();
+        lastPlayer.losesPoint();
+        removePlayer(lastPlayer);
+    }
+
+    public void previusPlayerWinsRound() {
+        Player currentPlayer = getCurrentPlayer();
+        Player lastPlayer = players.getLast();
+        currentPlayer.losesPoint();
+        removePlayer(currentPlayer);
+
+        while (players.getFirst() != lastPlayer) {
+            nextTurn();
+        }
+    }
+
+    private void removePlayer(Player player) {
+        if (player.getPoints() == 0) {
+            ranking.add(player);
+            players.remove(player);
+        }
+    }
+
+    public List<Player> getRanking() {
+        return ranking;
+    }
 }

src/j2025/FT/State.java

@@ -1,5 +1,17 @@
 package j2025.FT;
 
-public class State {
+abstract class State {
+    void checkValue() {}
     
-}
+    void rollTheDice() {
+        throw new InvalidAction("You must not roll the dice in state " + this);
+    }
+
+    void announce(PairOfDice value) {
+        throw new InvalidAction("You must not announce a value in state " + this);
+    }
+
+    void callLiar() {
+        throw new InvalidAction("You must not call liar in state " + this);
+    }
+}