refactored a lot and added possibility to play games on DedicatedServer (#43)

Backend/schafkopf-shared/src/main/java/org/schafkopf/GameState.java

@@ -0,0 +1,80 @@
+package org.schafkopf;
+
+import com.google.gson.Gson;
+import com.google.gson.JsonObject;
+import org.schafkopf.karte.Karte;
+import org.schafkopf.karte.KartenFarbe;
+
+/** GameState. */
+public class GameState {
+
+  public GamePhase getGamePhase() {
+    return this.gamePhase;
+  }
+
+  /** GamePhase. */
+  public enum GamePhase {
+    CHOOSE_GAME("Spiel muss gewählt werden"),
+
+    GAME_START("Warten auf das Legen einer Karte"),
+
+    TRICK_START("Warten auf das Legen einer Karte"),
+    WAIT_FOR_CARD("Warten auf das Legen einer Karte"),
+    PLAYER_CARD("Warten auf das Legen einer Karte"),
+    PLAYER_TRICK("Spieler sticht"),
+    GAME_STOP("Spieler sticht");
+    // Add more phases as needed
+
+    private final String description;
+
+    GamePhase(String description) {
+      this.description = description;
+    }
+
+    public String getDescription() {
+      return description;
+    }
+  }
+
+  private GamePhase gamePhase;
+  private Integer currentPlayer; // Using Integer to allow for null
+  private Karte card;
+  private KartenFarbe color;
+  private boolean trumpf;
+
+  // Constructors, getters, and setters
+
+  public GameState(GamePhase phase) {
+    this.gamePhase = phase;
+  }
+
+  public GameState(GamePhase phase, Integer player) {
+    this.gamePhase = phase;
+    this.currentPlayer = player;
+  }
+
+  /** GameState. */
+  public GameState(GamePhase phase, Integer player, Karte card, KartenFarbe color, boolean trumpf) {
+    this.gamePhase = phase;
+    this.currentPlayer = player;
+    this.card = card;
+    this.color = color;
+    this.trumpf = trumpf;
+  }
+
+  /** GameState. */
+  public GameState(GamePhase phase, Integer player, Karte card) {
+    this.gamePhase = phase;
+    this.currentPlayer = player;
+    this.card = card;
+  }
+
+  /** GameState. */
+  public JsonObject getJson() {
+    Gson gson = new Gson();
+    JsonObject jsonObject = new JsonObject();
+    jsonObject.add("gamestate", gson.toJsonTree(this));
+
+    return jsonObject;
+  }
+}

Backend/schafkopf-shared/src/main/java/org/schafkopf/MessageSender.java

@@ -0,0 +1,6 @@
+package org.schafkopf;
+
+/** The main entrypoint of the Application. */
+public interface MessageSender {
+  void sendMessage(String message);
+}

Backend/schafkopf-shared/src/main/java/org/schafkopf/Schafkopf.java

@@ -0,0 +1,155 @@
+package org.schafkopf;
+
+import org.schafkopf.GameState.GamePhase;
+import org.schafkopf.karte.Karte;
+import org.schafkopf.karte.KartenFarbe;
+import org.schafkopf.karte.KartenListe;
+import org.schafkopf.karte.KartenUtil;
+import org.schafkopf.player.BotPlayer;
+import org.schafkopf.player.Player;
+import org.schafkopf.spielcontroller.FarbGeierController;
+import org.schafkopf.spielcontroller.FarbSoloController;
+import org.schafkopf.spielcontroller.FarbWenzController;
+import org.schafkopf.spielcontroller.GeierController;
+import org.schafkopf.spielcontroller.SauSpielController;
+import org.schafkopf.spielcontroller.SpielController;
+import org.schafkopf.spielcontroller.WenzController;
+
+/** The main class representing the Schafkopf game. */
+public class Schafkopf {
+  private final MessageSender messageSender;
+
+  /** The game controller. This is the class that implements the game logic. */
+  private SpielController spiel = new SauSpielController(0, KartenFarbe.EICHEL);
+
+  private final Player[] player;
+
+  private GameState gameState = new GameState(GamePhase.GAME_STOP);
+  private Thread spielThread;
+
+  /**
+   * Constructor for the Schafkopf class.
+   *
+   * @param messageSender MessageSender
+   */
+  public Schafkopf(Player[] player, MessageSender messageSender) {
+    this.player = player;
+    this.messageSender = messageSender;
+    System.out.println("SchaffKopfGame erstellt");
+  }
+
+  public Player[] getPlayer() {
+    return player;
+  }
+
+  /** Set GameState to "started" and start Game Thread. */
+  public void startGame() {
+    if (gameState.getGamePhase() != GamePhase.GAME_STOP) {
+      System.out.println("Game already started!");
+      messageSender.sendMessage("Game already started!");
+    } else {
+      gameState = new GameState(GamePhase.GAME_START);
+      setAndSendGameState(gameState);
+      System.out.println("Start Game");
+
+      KartenListe austeilen = KartenUtil.initializeSchafKopfCardDeck();
+      for (Player currentPlayer : player) {
+        if (currentPlayer instanceof BotPlayer botPlayer) {
+          KartenListe botHand = new KartenListe();
+          for (int i = 7; i >= 0; i--) {
+            System.out.println("Austeilen: " + austeilen.size());
+            System.out.println("Bot Hand: " + i);
+            botHand.addKarten(austeilen.removeKarten(austeilen.getByIndex(i)));
+          }
+          System.out.println("Bot Hand: " + botHand.getJson().toString());
+          botPlayer.setCards(botHand); // Replace with the actual method you want to call
+        }
+      }
+
+      spielThread = new Thread(() -> new Spielablauf(this, spiel));
+
+      spielThread.start();
+    }
+  }
+
+  /** Set GameState to "stopped" and interrupt Game Thread. */
+  public void stopGame() {
+    if (gameState.getGamePhase() == GamePhase.GAME_STOP) {
+      System.out.println("no active Game!");
+      messageSender.sendMessage("no active Game!");
+    } else {
+      gameState = new GameState(GamePhase.GAME_STOP);
+      setAndSendGameState(gameState);
+    }
+
+    spielThread.interrupt();
+  }
+
+  /** Set GameType. */
+  public void setGame(String message) {
+    System.out.println("Set Game: " + message);
+    messageSender.sendMessage("Set Game: " + message);
+    switch (message) {
+      case "setgame:herzsolo":
+        this.spiel = new FarbSoloController(0, KartenFarbe.HERZ);
+        break;
+      case "setgame:blattsolo":
+        this.spiel = new FarbSoloController(0, KartenFarbe.BLATT);
+        break;
+      case "setgame:eichelsolo":
+        this.spiel = new FarbSoloController(0, KartenFarbe.EICHEL);
+        break;
+      case "setgame:schellsolo":
+        this.spiel = new FarbSoloController(0, KartenFarbe.SCHELL);
+        break;
+
+      case "setgame:wenz":
+        this.spiel = new WenzController(0);
+        break;
+      case "setgame:geier":
+        this.spiel = new GeierController(0);
+        break;
+
+      case "setgame:eichelwenz":
+        this.spiel = new FarbWenzController(0, KartenFarbe.EICHEL);
+        break;
+      case "setgame:herzwenz":
+        this.spiel = new FarbWenzController(0, KartenFarbe.HERZ);
+        break;
+      case "setgame:blattwenz":
+        this.spiel = new FarbWenzController(0, KartenFarbe.BLATT);
+        break;
+      case "setgame:schellwenz":
+        this.spiel = new FarbWenzController(0, KartenFarbe.SCHELL);
+        break;
+
+      case "setgame:eichelgeier":
+        this.spiel = new FarbGeierController(0, KartenFarbe.EICHEL);
+        break;
+      case "setgame:herzgeier":
+        this.spiel = new FarbGeierController(0, KartenFarbe.HERZ);
+        break;
+      case "setgame:blattgeier":
+        this.spiel = new FarbGeierController(0, KartenFarbe.BLATT);
+        break;
+      case "setgame:schellgeier":
+        this.spiel = new FarbGeierController(0, KartenFarbe.SCHELL);
+        break;
+
+      case "setgame:sauspiel":
+        this.spiel = new SauSpielController(0, KartenFarbe.EICHEL);
+        break;
+      default:
+        System.out.println("Ungültiges Spiel");
+    }
+  }
+
+  public void setAndSendGameState(GameState gameState) {
+    this.gameState = gameState;
+    this.messageSender.sendMessage(this.gameState.getJson().toString());
+  }
+
+  public GameState getGameState() {
+    return this.gameState;
+  }
+}

Backend/schafkopf-shared/src/main/java/org/schafkopf/Spielablauf.java

@@ -0,0 +1,86 @@
+package org.schafkopf;
+
+import org.schafkopf.GameState.GamePhase;
+import org.schafkopf.karte.Karte;
+import org.schafkopf.karte.KartenListe;
+import org.schafkopf.player.Player;
+import org.schafkopf.spielcontroller.SpielController;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/** The main class that controlls the game flow. */
+public class Spielablauf {
+
+  private static final Logger logger = LoggerFactory.getLogger(Spielablauf.class);
+  private final KartenListe gespielteKarten = new KartenListe();
+
+  private final KartenListe tischKarten = new KartenListe();
+
+  private final SpielController spiel;
+
+  private final Player[] players;
+
+  private final Schafkopf schafkopf;
+
+  Spielablauf(Schafkopf schafkopf, SpielController spiel) {
+    this.schafkopf = schafkopf;
+    this.spiel = spiel;
+    this.players = schafkopf.getPlayer();
+
+    playRound();
+  }
+
+  private void playRound() {
+    int startingPlayer = 0;
+
+    logger.info("Starte Stiche");
+    for (int i = 0; i < 8; i++) {
+      logger.info("Stich: {}", i);
+      startingPlayer = playTrick(startingPlayer);
+    }
+    schafkopf.stopGame();
+  }
+
+  private int playTrick(int startingPlayer) {
+    schafkopf.setAndSendGameState(new GameState(GamePhase.TRICK_START));
+
+    for (int i = 0; i < 4; i++) {
+      int currentPlayer = (i + startingPlayer) % 4;
+
+      logger.info("Spieler ist dran: {}", currentPlayer);
+      schafkopf.setAndSendGameState(new GameState(GamePhase.WAIT_FOR_CARD, currentPlayer));
+
+      Karte playedCard = players[currentPlayer].play(spiel, tischKarten, gespielteKarten);
+      tischKarten.addKarten(playedCard);
+
+      schafkopf.setAndSendGameState(
+          new GameState(
+              GamePhase.PLAYER_CARD,
+              currentPlayer,
+              playedCard,
+              tischKarten.getByIndex(0).getFarbe(),
+              spiel.isTrumpf(tischKarten.getByIndex(0))));
+    }
+    int stichSpieler = SpielController.welcheKarteSticht(tischKarten);
+
+    logger.info("Stiche ende");
+
+    int winningPlayerIndex = (startingPlayer + stichSpieler) % 4;
+    logger.warn("Karte sticht: {}", winningPlayerIndex);
+
+    schafkopf.setAndSendGameState(
+        new GameState(
+            GamePhase.PLAYER_TRICK, winningPlayerIndex, tischKarten.getByIndex(stichSpieler)));
+
+    try {
+      Thread.sleep(3000);
+    } catch (InterruptedException e) {
+      logger.error("error sleep");
+    }
+
+    gespielteKarten.addKarten(tischKarten);
+    tischKarten.clear();
+
+    return winningPlayerIndex;
+  }
+}

Backend/schafkopf-shared/src/main/java/org/schafkopf/player/BotPlayer.java

@@ -0,0 +1,43 @@
+package org.schafkopf.player;
+
+import org.schafkopf.karte.Karte;
+import org.schafkopf.karte.KartenListe;
+import org.schafkopf.karte.KartenUtil;
+import org.schafkopf.spielcontroller.SpielController;
+
+/** Player that represents the Bot. */
+public class BotPlayer extends Player {
+
+  private KartenListe eigeneKarten;
+  private KartenListe unbekannteKarten = KartenUtil.initializeSchafKopfCardDeck();
+
+  public BotPlayer() {
+    // TODO document why this constructor is empty
+  }
+
+  @Override
+  public Karte play(SpielController spiel, KartenListe tischKarten, KartenListe gespielteKarten) {
+
+    try {
+      Thread.sleep(1000);
+    } catch (InterruptedException e) {
+      throw new RuntimeException(e);
+    }
+
+    Karte card = spiel.welcheKarteSpielIch(true, gespielteKarten, eigeneKarten, tischKarten);
+
+    eigeneKarten.removeKarten(card);
+
+    System.out.println("Eigene Karte legen");
+    return card;
+  }
+
+  /** Set the Cards of the Player. */
+  public void setCards(KartenListe cards) {
+    System.out.println("Eigene Karte setzen");
+    this.eigeneKarten = cards;
+    this.unbekannteKarten = KartenUtil.initializeSchafKopfCardDeck();
+    this.unbekannteKarten.removeKarten(eigeneKarten);
+    System.out.println("Eigene Karte fertig");
+  }
+}

Backend/schafkopf-shared/src/main/java/org/schafkopf/player/Player.java

@@ -0,0 +1,11 @@
+package org.schafkopf.player;
+
+import org.schafkopf.karte.Karte;
+import org.schafkopf.karte.KartenListe;
+import org.schafkopf.spielcontroller.SpielController;
+
+/** Class that represents one Player of the game. */
+public abstract class Player {
+  public abstract Karte play(
+      SpielController spiel, KartenListe tischKarten, KartenListe gespielteKarten);
+}

Backend/schafkopf-shared/src/main/java/org/schafkopf/spielcontroller/FarbGeierController.java

@@ -0,0 +1,36 @@
+package org.schafkopf.spielcontroller;
+
+import org.schafkopf.karte.Karte;
+import org.schafkopf.karte.KartenFarbe;
+import org.schafkopf.karte.KartenListe;
+import org.schafkopf.karte.KartenSymbol;
+import org.schafkopf.karte.KartenUtil;
+
+/** SpielController that implements Logic of a Farb Geier. */
+public class FarbGeierController extends SoloController {
+  /**
+   * Create instance of SpielController.
+   *
+   * @param farbe Trumpffarbe of the Farb Geier.
+   */
+  public FarbGeierController(int activePlayer, KartenFarbe farbe) {
+    super(activePlayer);
+    KartenListe kartenList = KartenUtil.initializeSchafKopfCardDeck();
+    KartenListe oberKarten = kartenList.getKarten(KartenSymbol.OBER);
+    KartenListe farbTrumpfKarten = kartenList.getKarten(farbe);
+    farbTrumpfKarten.removeKarten(KartenSymbol.OBER);
+    farbTrumpfKarten.addKarten(oberKarten);
+    kartenList.removeKarten(farbTrumpfKarten);
+
+    this.trumpfKarten = new KartenListe(farbTrumpfKarten);
+    this.farbKarten = new KartenListe(kartenList);
+  }
+
+  public Karte welcheKarteSpielIch(
+      boolean istSpieler,
+      KartenListe gespielteKarten,
+      KartenListe meineHand,
+      KartenListe tischKarten) {
+    return null;
+  }
+}

Backend/schafkopf-shared/src/main/java/org/schafkopf/spielcontroller/FarbSoloController.java

@@ -0,0 +1,40 @@
+package org.schafkopf.spielcontroller;
+
+import org.schafkopf.karte.Karte;
+import org.schafkopf.karte.KartenFarbe;
+import org.schafkopf.karte.KartenListe;
+import org.schafkopf.karte.KartenSymbol;
+import org.schafkopf.karte.KartenUtil;
+
+/** SpielController that implements Logic of a Farb Solo. */
+public class FarbSoloController extends SoloController {
+  /**
+   * Create instance of SpielController.
+   *
+   * @param farbe Trumpffarbe of the Farb Solo.
+   */
+  public FarbSoloController(int activePlayer, KartenFarbe farbe) {
+    super(activePlayer);
+    KartenListe kartenList = KartenUtil.initializeSchafKopfCardDeck();
+    KartenListe unterKarten = kartenList.getKarten(KartenSymbol.UNTER);
+
+    KartenListe farbTrumpfKarten = kartenList.getKarten(farbe);
+    farbTrumpfKarten.removeKarten(KartenSymbol.UNTER);
+    farbTrumpfKarten.removeKarten(KartenSymbol.OBER);
+    farbTrumpfKarten.addKarten(kartenList.getKarten(KartenSymbol.UNTER));
+    farbTrumpfKarten.addKarten(kartenList.getKarten(KartenSymbol.OBER));
+
+    kartenList.removeKarten(farbTrumpfKarten);
+
+    this.trumpfKarten = new KartenListe(farbTrumpfKarten);
+    this.farbKarten = new KartenListe(kartenList);
+  }
+
+  public Karte welcheKarteSpielIch(
+      boolean istSpieler,
+      KartenListe gespielteKarten,
+      KartenListe meineHand,
+      KartenListe tischKarten) {
+    return null;
+  }
+}

Backend/schafkopf-shared/src/main/java/org/schafkopf/spielcontroller/FarbWenzController.java

@@ -0,0 +1,36 @@
+package org.schafkopf.spielcontroller;
+
+import org.schafkopf.karte.Karte;
+import org.schafkopf.karte.KartenFarbe;
+import org.schafkopf.karte.KartenListe;
+import org.schafkopf.karte.KartenSymbol;
+import org.schafkopf.karte.KartenUtil;
+
+/** SpielController that implements Logic of a Farb Wenz. */
+public class FarbWenzController extends SoloController {
+  /**
+   * Create instance of SpielController.
+   *
+   * @param farbe Trumpffarbe of the Farb Wenz.
+   */
+  public FarbWenzController(int activePlayer, KartenFarbe farbe) {
+    super(activePlayer);
+    KartenListe kartenList = KartenUtil.initializeSchafKopfCardDeck();
+    KartenListe unterKarten = kartenList.getKarten(KartenSymbol.UNTER);
+    KartenListe farbTrumpfKarten = kartenList.getKarten(farbe);
+    farbTrumpfKarten.removeKarten(KartenSymbol.UNTER);
+    farbTrumpfKarten.addKarten(unterKarten);
+    kartenList.removeKarten(farbTrumpfKarten);
+
+    this.trumpfKarten = new KartenListe(farbTrumpfKarten);
+    this.farbKarten = new KartenListe(kartenList);
+  }
+
+  public Karte welcheKarteSpielIch(
+      boolean istSpieler,
+      KartenListe gespielteKarten,
+      KartenListe meineHand,
+      KartenListe tischKarten) {
+    return null;
+  }
+}

Backend/schafkopf-shared/src/main/java/org/schafkopf/spielcontroller/GeierController.java

@@ -0,0 +1,24 @@
+package org.schafkopf.spielcontroller;
+
+import org.schafkopf.karte.KartenListe;
+import org.schafkopf.karte.KartenSymbol;
+import org.schafkopf.karte.KartenUtil;
+
+/**
+ * SpielController that implements Logic of a Geier Game.
+ */
+public class GeierController extends GeierWenzController {
+  /**
+   * Create instance of Geier Game.
+   */
+  public GeierController(int activePlayer) {
+    super(activePlayer);
+    KartenListe kartenList = KartenUtil.initializeSchafKopfCardDeck();
+    KartenListe oberKarten = kartenList.getKarten(KartenSymbol.OBER);
+
+    kartenList.removeKarten(oberKarten);
+
+    this.trumpfKarten = new KartenListe(oberKarten);
+    this.farbKarten = new KartenListe(kartenList);
+  }
+}

Backend/schafkopf-shared/src/main/java/org/schafkopf/spielcontroller/GeierWenzController.java

@@ -0,0 +1,20 @@
+package org.schafkopf.spielcontroller;
+
+import org.schafkopf.karte.Karte;
+import org.schafkopf.karte.KartenListe;
+
+/**
+ * SpielController that implements Logic of a Geier/Wenz Game.
+ */
+public class GeierWenzController extends SoloController {
+
+  public GeierWenzController(int activePlayer) {
+    super(activePlayer);
+  }
+
+  @Override
+  public Karte welcheKarteSpielIch(boolean istSpieler, KartenListe gespielteKarten,
+      KartenListe meineHand, KartenListe tischKarten) {
+    return null;
+  }
+}

Backend/schafkopf-shared/src/main/java/org/schafkopf/spielcontroller/SauSpielController.java

@@ -0,0 +1,58 @@
+package org.schafkopf.spielcontroller;
+
+import org.schafkopf.karte.Karte;
+import org.schafkopf.karte.KartenFarbe;
+import org.schafkopf.karte.KartenListe;
+
+/** SpielController that implements Logic of a Sau Spiel Game. */
+public class SauSpielController extends StandardController {
+
+  KartenFarbe suchFarbe;
+
+  /** Class that represents one Card of the game. */
+  public SauSpielController(int activePlayer, KartenFarbe farbe) {
+    super(activePlayer);
+    this.suchFarbe = farbe;
+  }
+
+  /** choose witch Card should be played with the right Game logic. */
+  public Karte welcheKarteSpielIch(
+      boolean istSpieler,
+      KartenListe gespielteKarten,
+      KartenListe meineHand,
+      KartenListe tischKarten) {
+    System.out.println("Ich spiele eine Karte Sauspiel");
+
+    int spielerNummer = tischKarten.size();
+
+    switch (spielerNummer) {
+      case 0:
+        if (istSpieler) {
+          return meineHand.getLast();
+        } else {
+          return meineHand.getByIndex(0);
+        }
+      case 1:
+        if (istSpieler) {
+          return farbeZugeben(meineHand, tischKarten.getByIndex(0), 2);
+        } else {
+          return farbeZugeben(meineHand, tischKarten.getByIndex(0), 0);
+        }
+      case 2:
+        if (istSpieler) {
+          return farbeZugeben(meineHand, tischKarten.getByIndex(0), 2);
+        } else {
+          return farbeZugeben(meineHand, tischKarten.getByIndex(0), 0);
+        }
+      case 3:
+        if (istSpieler) {
+          return farbeZugeben(meineHand, tischKarten.getByIndex(0), 2);
+        } else {
+          return farbeZugeben(meineHand, tischKarten.getByIndex(0), 0);
+        }
+      default:
+        System.out.println("Ungültige SpielerNummer");
+    }
+    return null;
+  }
+}

Backend/schafkopf-shared/src/main/java/org/schafkopf/spielcontroller/SoloController.java

@@ -0,0 +1,19 @@
+package org.schafkopf.spielcontroller;
+
+import org.schafkopf.karte.Karte;
+import org.schafkopf.karte.KartenListe;
+
+/**
+ * abstract Class that represents Logic of a Solo like Game.
+ */
+public abstract class SoloController extends SpielController {
+
+  SoloController(int activePlayer) {
+    super(activePlayer);
+  }
+  
+  public Karte welcheKarteSpielIch(
+      KartenListe gespielteKarten, KartenListe meineHand, KartenListe tischKarten) {
+    return null;
+  }
+}

Backend/schafkopf-shared/src/main/java/org/schafkopf/spielcontroller/SpielController.java

@@ -0,0 +1,133 @@
+package org.schafkopf.spielcontroller;
+
+import org.schafkopf.karte.Karte;
+import org.schafkopf.karte.KartenFarbe;
+import org.schafkopf.karte.KartenListe;
+import org.schafkopf.karte.KartenUtil;
+
+/** Base Class of Game Controllers. */
+public abstract class SpielController {
+  protected static KartenListe trumpfKarten;
+  protected static KartenListe farbKarten;
+
+  protected static int activePlayer;
+
+  public SpielController(int activePlayer) {
+    this.activePlayer = activePlayer;
+  }
+
+  /**
+   * Create instance of SpielController.
+   *
+   * @param meineHand Cards one Player holds.
+   * @param ersteKarte color the Player has to play.
+   * @param mode Mode the player chooses a Card if multiple are available.
+   */
+  public static Karte farbeZugeben(KartenListe meineHand, Karte ersteKarte, int mode) {
+    KartenListe hand = new KartenListe(meineHand);
+    sortiereKarten(hand);
+
+    boolean trumpfGespielt = trumpfKarten.containsKarte(ersteKarte);
+
+    KartenListe handTrumpfKarten = hand.removeKarten(trumpfKarten);
+    KartenListe handfarbKarten;
+
+    if (trumpfGespielt) {
+      handfarbKarten = handTrumpfKarten;
+    } else {
+      handfarbKarten = hand.getKarten(ersteKarte.getFarbe());
+    }
+
+    if (handfarbKarten.size() == 1) {
+      return handfarbKarten.getByIndex(0);
+    } else if (handfarbKarten.size() > 1) {
+      return switch (mode) {
+        case 0 -> // Abspatzen
+        handfarbKarten.getByIndex(0);
+        case 1, 2 -> // Stechen // Schmieren
+        handfarbKarten.getLast();
+        default -> null;
+      };
+    }
+    if (handfarbKarten.isEmpty()) {
+      switch (mode) {
+        case 0: // Abspatzen
+          return hand.getByIndex(0);
+        case 1: // Schmieren
+          return hand.getLast();
+        case 2: // Stechen
+          if (!handTrumpfKarten.isEmpty()) {
+            return handTrumpfKarten.getLast(); // trumpf reinspielen
+          } else {
+            return hand.getByIndex(0); // wenn kein Trumpf und farblos, abschpatzen
+          }
+        default:
+          return null;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * sorts Cards, so they are in the right order for the active game.
+   *
+   * @param karten Trumpffarbe of the Farb Geier.
+   */
+  public static void sortiereKarten(KartenListe karten) {
+    KartenListe kartenReihenfolge = new KartenListe(farbKarten);
+    kartenReihenfolge.addKarten(trumpfKarten);
+
+    KartenListe kartenListe = KartenUtil.initializeSchafKopfCardDeck();
+
+    kartenListe.removeKarten(karten);
+    kartenReihenfolge.removeKarten(kartenListe);
+
+    karten.clear();
+    karten.addKarten(kartenReihenfolge);
+  }
+
+  /**
+   * checks, which card has the highest strength and will win one Stich.
+   *
+   * @param karten Cards to check.
+   */
+  public static int welcheKarteSticht(KartenListe karten) {
+    KartenListe kartenNew = new KartenListe(karten);
+    sortiereKarten(kartenNew);
+    KartenListe farbTischKarten = kartenNew.removeKarten(trumpfKarten);
+    System.out.println("trumpfKarten:");
+    System.out.println(trumpfKarten.getJson());
+
+    if (!farbTischKarten.isEmpty()) {
+      System.out.println("trumpfkarten:");
+      System.out.println(farbTischKarten.getJson());
+      return karten.indexOf(farbTischKarten.getLast());
+    } else {
+      KartenFarbe firstColor = karten.getByIndex(0).getFarbe();
+      KartenListe firstColorCards = kartenNew.removeKarten(firstColor);
+
+      System.out.println("firstcolor:");
+      System.out.println(firstColorCards.getJson());
+
+      return karten.indexOf(firstColorCards.getLast());
+    }
+  }
+
+  public abstract Karte welcheKarteSpielIch(
+      boolean istSpieler,
+      KartenListe gespielteKarten,
+      KartenListe meineHand,
+      KartenListe tischKarten);
+
+  public KartenListe getTrumpfKarten() {
+    return trumpfKarten;
+  }
+
+  public boolean isTrumpf(Karte card) {
+    return trumpfKarten.containsKarte(card);
+  }
+
+  public KartenListe getFarbKarten() {
+    return farbKarten;
+  }
+}

Backend/schafkopf-shared/src/main/java/org/schafkopf/spielcontroller/StandardController.java

@@ -0,0 +1,33 @@
+package org.schafkopf.spielcontroller;
+
+import org.schafkopf.karte.Karte;
+import org.schafkopf.karte.KartenFarbe;
+import org.schafkopf.karte.KartenListe;
+import org.schafkopf.karte.KartenSymbol;
+import org.schafkopf.karte.KartenUtil;
+
+/** SpielController that has the standard Card Deck for Sauspiel, Bettel und Co. */
+public abstract class StandardController extends SpielController {
+
+  StandardController(int activePlayer) {
+    super(activePlayer);
+    KartenListe kartenList = KartenUtil.initializeSchafKopfCardDeck();
+    KartenListe herzKarten = kartenList.getKarten(KartenFarbe.HERZ);
+    herzKarten.removeKarten(KartenSymbol.UNTER);
+    herzKarten.removeKarten(KartenSymbol.OBER);
+
+    herzKarten.addKarten(kartenList.getKarten(KartenSymbol.UNTER));
+    herzKarten.addKarten(kartenList.getKarten(KartenSymbol.OBER));
+
+    kartenList.removeKarten(herzKarten);
+
+    this.trumpfKarten = new KartenListe(herzKarten);
+    this.farbKarten = new KartenListe(kartenList);
+  }
+
+  public abstract Karte welcheKarteSpielIch(
+      boolean istSpieler,
+      KartenListe gespielteKarten,
+      KartenListe meineHand,
+      KartenListe tischKarten);
+}

Backend/schafkopf-shared/src/main/java/org/schafkopf/spielcontroller/WenzController.java

@@ -0,0 +1,25 @@
+package org.schafkopf.spielcontroller;
+
+import org.schafkopf.karte.KartenListe;
+import org.schafkopf.karte.KartenSymbol;
+import org.schafkopf.karte.KartenUtil;
+
+/**
+ * SpielController that implements Logic of a Wenz Game.
+ */
+public class WenzController extends GeierWenzController {
+  /**
+   * Create instance of Wenz Game.
+   */
+  public WenzController(int activePlayer) {
+    super(activePlayer);
+    this.activePlayer = activePlayer;
+    KartenListe kartenList = KartenUtil.initializeSchafKopfCardDeck();
+    KartenListe unterKarten = kartenList.getKarten(KartenSymbol.UNTER);
+
+    kartenList.removeKarten(unterKarten);
+
+    this.trumpfKarten = new KartenListe(unterKarten);
+    this.farbKarten = new KartenListe(kartenList);
+  }
+}